Напишите функцию, которая при bвыделении буфера (длиной 1 - 104857600 байт) и количества бит n(1 <= n <= 64) разделяет буфер на куски nбитов. Вставьте правую часть последнего фрагмента с битами 0до s n.

например

Учитывая буфер b = "f0oBaR"или эквивалентно [102,48,111,66,97,82]и n = 5, вернуть

[12, 24, 24, 6, 30, 16, 19, 1, 10, 8]

Это потому, что вышеприведенный буфер, представленный в виде двоичного файла, выглядит следующим образом:

01100110 00110000 01101111 01000010 01100001 01010010

А при перегруппировке в 5s выглядит так:

01100 11000 11000 00110 11110 10000 10011 00001 01010 010[00]

Который при преобразовании обратно в десятичную дает ответ.

Заметки

• Вы можете использовать любой тип данных, наиболее подходящий для вашего языка, для представления буфера. В PHP вы, вероятно, будете использовать строку, в Node вы можете использовать буфер
  • Если вы используете строку для представления буфера, предположите, что это ASCII для преобразования char -> int
  • Вы можете использовать массив значений (0-255) для ввода, если вы предпочитаете
• Возвращаемое значение должно быть массивом или списком целых

Тестовые случаи

> b = "Hello World", n = 50
318401791769729, 412278856237056

> b = [1,2,3,4,5], n = 1
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1

> b = "codegolf", n = 32
1668244581, 1735355494

> b = "codegolf" n = 64
7165055918859578470

> b = "codegolf" n = 7
49, 91, 108, 70, 43, 29, 94, 108, 51, 0

> b = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque vel est eu velit lacinia iaculis. Nulla facilisi. Mauris vitae elit sapien. Nullam odio nulla, laoreet at lorem eu, elementum ultricies libero. Praesent orci elit, sodales consectetur magna eget, pulvinar eleifend mi. Ut euismod leo ut tortor ultrices blandit. Praesent dapibus tincidunt velit vitae viverra. Nam posuere dui quis ipsum iaculis, quis tristique nisl tincidunt. Aliquam ac ligula a diam congue tempus sit amet quis nisl. Nam lacinia ante vitae leo efficitur, eu tincidunt metus condimentum. Cras euismod quis quam vitae imperdiet. Ut at est turpis.", n = 16
19567, 29285, 27936, 26992, 29557, 27936, 25711, 27759, 29216, 29545, 29728, 24941, 25972, 11296, 25455, 28275, 25955, 29797, 29813, 29216, 24932, 26992, 26995, 25449, 28263, 8293, 27753, 29742, 8272, 25964, 27749, 28276, 25971, 29045, 25888, 30309, 27680, 25971, 29728, 25973, 8310, 25964, 26996, 8300, 24931, 26990, 26977, 8297, 24931, 30060, 26995, 11808, 20085, 27756, 24864, 26209, 25449, 27753, 29545, 11808, 19809, 30066, 26995, 8310, 26996, 24933, 8293, 27753, 29728, 29537, 28777, 25966, 11808, 20085, 27756, 24941, 8303, 25705, 28448, 28277, 27756, 24876, 8300, 24943, 29285, 25972, 8289, 29728, 27759, 29285, 27936, 25973, 11296, 25964, 25965, 25966, 29813, 27936, 30060, 29810, 26979, 26981, 29472, 27753, 25189, 29295, 11808, 20594, 24933, 29541, 28276, 8303, 29283, 26912, 25964, 26996, 11296, 29551, 25697, 27749, 29472, 25455, 28275, 25955, 29797, 29813, 29216, 28001, 26478, 24864, 25959, 25972, 11296, 28789, 27766, 26990, 24946, 8293, 27749, 26982, 25966, 25632, 28009, 11808, 21876, 8293, 30057, 29549, 28516, 8300, 25967, 8309, 29728, 29807, 29300, 28530, 8309, 27764, 29289, 25445, 29472, 25196, 24942, 25705, 29742, 8272, 29281, 25971, 25966, 29728, 25697, 28777, 25205, 29472, 29801, 28259, 26980, 30062, 29728, 30309, 27753, 29728, 30313, 29793, 25888, 30313, 30309, 29298, 24878, 8270, 24941, 8304, 28531, 30053, 29285, 8292, 30057, 8305, 30057, 29472, 26992, 29557, 27936, 26977, 25461, 27753, 29484, 8305, 30057, 29472, 29810, 26995, 29801, 29045, 25888, 28265, 29548, 8308, 26990, 25449, 25717, 28276, 11808, 16748, 26993, 30049, 27936, 24931, 8300, 26983, 30060, 24864, 24864, 25705, 24941, 8291, 28526, 26485, 25888, 29797, 28016, 30067, 8307, 26996, 8289, 28005, 29728, 29045, 26995, 8302, 26995, 27694, 8270, 24941, 8300, 24931, 26990, 26977, 8289, 28276, 25888, 30313, 29793, 25888, 27749, 28448, 25958, 26217, 25449, 29813, 29228, 8293, 29984, 29801, 28259, 26980, 30062, 29728, 28005, 29813, 29472, 25455, 28260, 26989, 25966, 29813, 27950, 8259, 29281, 29472, 25973, 26995, 28015, 25632, 29045, 26995, 8305, 30049, 27936, 30313, 29793, 25888, 26989, 28773, 29284, 26981, 29742, 8277, 29728, 24948, 8293, 29556, 8308, 30066, 28777, 29486

> b = [2,31,73,127,179,233], n = 8
2, 31, 73, 127, 179, 233

Pyth, 18 17 байт

iR2c.[t.B+C1z\0QQ

Спасибо @lirtosiast за байт!

            z      get input
         +C1       prepend a 0x01 to prevent leading zeroes from disappearing
       .B          convert to binary string
      t            remove the leading 1 from ^^
    .[       \0Q   pad right with zeroes to multiple of second input
   c            Q  get chunks/slices of length second input
iR2                map(x: int(x, 2))

Желе, 13 байт

1;ḅ256æ«BḊsḄṖ

Это принимает входные данные в виде списка целых чисел. Попробуйте онлайн!

Как это работает

1;ḅ256æ«BḊsḄṖ  Main link. Arguments: A (list), n (integer)

1;             Prepend 1 to A.
  ḅ256         Convert from base 256 to integer.
      æ«       Bitshift the result n units to the left.
        B      Convert to binary.
         Ḋ     Discard the first binary digit (corresponds to prepended 1).
          s    Split into chunks of length n.
           Ḅ   Convert each chunk from binary to integer.
            Ṗ  Discard the last integer (corresponds to bitshift/padding).

Юлия, 117 байт

f(x,n,b=join(map(i->bin(i,8),x)),d=endof,z=rpad(b,d(b)+d(b)%n,0))=map(i->parse(Int,i,2),[z[i:i+n-1]for i=1:n:d(z)-n])

Это функция, которая принимает целочисленный массив и целое число и возвращает целочисленный массив. Это упражнение в злоупотреблении аргументом функции.

Ungolfed:

function f(x::Array{Int,1},                  # Input array
           n::Int,                           # Input integer
           b = join(map(i -> bin(i, 8), x)), # `x` joined as a binary string
           d = endof,                        # Store the `endof` function
           z = rpad(b, d(b) + d(b) % n, 0))  # `b` padded to a multiple of n

    # Parse out the integers in base 2
    map(i -> parse(Int, i, 2), [z[i:i+n-1] for i = 1:n:d(z)-n])
end

JavaScript (ES6), 120 байт

f=(a,n,b=0,t=0,r=[])=>b<n?a.length?f(a.slice(1),n,b+8,t*256+a[0],r):b?[...r,t<<n-b]:r:f(a,n,b-=n,t&(1<<b)-1,[...r,t>>b])

Рекурсивное переворачивание битов на целочисленных массивах. Ungolfed:

function bits(array, nbits) {
    var count = 0;
    var total = 0;
    var result = [];
    for (;;) {
        if (nbits <= count) {
            // We have enough bits to be able to add to the result
            count -= nbits;
            result.push(total >> count);
            total &= (1 << count) - 1;
        } else if (array.length) {
            // Grab the next 8 bits from the array element
            count += 8;
            total <<= 8;
            total += array.shift();
        } else {
            // Deal with any leftover bits
            if (count) result.push(total << nbits - count);
            return result;
        }
    }
}

Python 3, 102 байта

j=''.join
lambda s,n:[int(j(k),2)for k in zip(*[iter(j([bin(i)[2:].zfill(8)for i in s+[0]]))]*n)][:-1]

использовать трюк iter для группировки строк

• s: входная строка / буфер
• n: количество бит в каждом разделенном фрагменте

Полученные результаты

>>> f([102,48,111,66,97,82],4)
[6, 6, 3, 0, 6, 15, 4, 2, 6, 1, 5, 2, 0]

>>> f([102,48,111,66,97,82],5)
[12, 24, 24, 6, 30, 16, 19, 1, 10, 8]

>>> f([102,48,111,66,97,82],6)
[25, 35, 1, 47, 16, 38, 5, 18]

>>> f([102,48,111,66,97,82],8)
[102, 48, 111, 66, 97, 82]

Рубин, 114 байт

->s,n{a=s.bytes.map{|b|b.to_s(2).rjust 8,?0}.join.split""
r=[]
r<<a.shift(n).join.ljust(n,?0).to_i(2)while a[0]
r}

Чуть чище:

f = -> str, num {
    arr = str.bytes.map {|byte|
        byte.to_s(2).rjust(8, "0")
    }.join.split("")
    result = []
    while arr.size > 0
        result << arr.shift(num).join.ljust(num, "0").to_i(2)
    end
    result
}

puts f["f0oBaR", 5]

Perl 6, 93 68 байт

{@^a».&{sprintf "%08b",$_}.join.comb($^b)».&{:2($_~0 x$b-.chars)}}

PHP, 262 217 189 байт

function f($b,$n){$M='array_map';return$M('bindec',$M(function($x)use($n){return str_pad($x,$n,0);},str_split(implode('',$M(function($s){return str_pad($s,8,0,0);},$M('decbin',$b))),$n)));}

(обновлено советами Исмаила Мигеля )

Отформатирован для удобства чтения:

function f($b, $n) {
    $M = 'array_map';
    return $M('bindec', $M(function ($x) use ($n) {
        return str_pad($x, $n, 0);
    }, str_split(implode('', $M(function ($s) {
        return str_pad($s, 8, 0, 0);
    }, $M('decbin', $b))), $n)));
}

Пример:

> implode(', ',f(array_map('ord',str_split('f0oBaR')),5));
"12, 24, 24, 6, 30, 16, 19, 1, 10, 8"

CJam, 30 байтов

{_@{2b8 0e[}%e_0a@*+/-1<{2b}%}

Попробуйте онлайн!

Это неназванный блок, который ожидает буфер int и количество кусков в стеке и оставляет результат в стеке.

Решил попробовать CJam. Мне потребовалось 2 часа, чтобы сделать это ^^ Это, вероятно, слишком долго, предложения очень приветствуются!

объяснение

_ e # дублировать счет чанка
@ e # вращать стек, массив теперь наверху, а чанк - внизу
{e # начать новый блок
 2b e # преобразовать в двоичный файл
 8 0e [e # добавить нули слева, поэтому двоичный файл равен 8 битам
} e # конец предыдущего блока
% e # применить этот блок к каждому элементу массива (map)
e_ e # сгладить массив
0a e # вставка массива с одним нулем в стек
@ e # вращать стек, стек теперь содержит n [массив] [0] n
* e # повторить массив [0] n раз
+ e # конкатить два массива
/ e # разбит на куски длины n, теперь в стеке содержится только массив
-1 <e # сбросить последний кусок
{2b}% e # конвертирует каждый кусок обратно в десятичный

JavaScript (ES6) 104

Итеративное возложение,

Редактировать 5 байт сохранить thx @Neil

(s,g,c=g,t=0)=>(s.map(x=>{for(i=8;i--;--c||(s.push(t),c=g,t=0))t+=t+(x>>i)%2},s=[]),c-g&&s.push(t<<c),s)

Меньше гольфа

( 
 // parameters
 s, // byte source array
 g, // output bit group size
 // default parameters used as locals 
 c = g, // output bit counter
 t = 0  // temp bit accumulator
) => (
  s.map(x => 
    { // for each byte in s
      for(i = 8; // loop for 8 bits
        i--; 
        )
        // loop body
        t += t + (x>>i) % 2, // shift t to left and add next bit
        --c // decrement c,if c==0 add bit group to output and reset count and accumulator
          ||(s.push(t), c=g, t=0)
    }, 
    s=[] // init output, reusing s to avoid wasting another global
  ),
  c-g && s.push(t<<c), // add remaining bits, if any
  s // return result
)

Тест

f=(s,g,c=g,t=0)=>(s.map(x=>{for(i=8;i--;--c||(s.push(t),c=g,t=0))t+=t+(x>>i)%2},s=[]),c-g&&s.push(t<<c),s)

function test()
{
  var a = A.value.match(/\d+/g)||[]
  var g = +G.value
  var r = f(a,g)
  
  O.textContent = r
  K.innerHTML = a.map(x=>`<i>${(256- -x).toString(2).slice(-8)}</i>`).join``
  + '\n'+ r.map(x=>`<i>${(256*256*256*256+x).toString(2).slice(-g)}</i>`).join``
}  

test()

#A { width: 50% }
#G { width: 5% }
i:nth-child(even) { color: #00c }
i:nth-child(odd) { color: #c00 }

Input array <input id=A value="102,48,111,66,97,82">
Group by bits <input id=G value=5> (up to 32)<br>
Output <button onclick="test()">-></button>
<span id=O></span>
<pre id=K></pre>

J, 24 байта

[:#.-@[>\;@(_8:{."1#:@])

Это анонимная функция, которая принимает в nкачестве левого аргументаb число, а в качестве правого аргумента - числа.

Тест:

      5 ([:#.-@[>\;@(_8:{."1#:@])) 102 48 111 66 97 82
12 24 24 6 30 16 19 1 10 8

Объяснение:

[:#.-@[>\;@(_8:{."1#:@])

                   #:@]   NB. Convert each number in `b` to bits
            _8:{."1       NB. Take the last 8 items for each
                          NB.    (padding with zeroes at the front)
         ;@               NB. Make a list of all the bits
    -@[                   NB. Negate `n` 
                          NB. (\ gives non-overlapping infixes if [<0)
       >\                 NB. Get non-overlapping n-sized infixes
 [:#.                     NB. Convert those back to decimal 

Haskell, 112 109 байт

import Data.Digits
import Data.Lists
n#x=unDigits 2.take n.(++[0,0..])<$>chunksOf n(tail.digits 2.(+256)=<<x)

Пример использования: 5 # [102,48,111,66,97,82]-> [12,24,24,6,30,16,19,1,10,8].

Как это работает

import Data.Digits                  -- needed for base 2 conversion
import Data.Lists                   -- needed for "chunksOf", i.e. splitting in
                                    -- sublists of length n

           (                  =<<x) -- map over the input list and combine the
                                    -- results into a single list:
            tail.digits 2.(+256)    -- convert to base two with exactly 8 digits    
         chunksOf n                 -- split into chunks of length n    
       <$>                          -- convert every chunk (<$> is map)
    take n.(++[0,0..])              -- pad with 0s
unDigits 2                          -- convert from base 2   

Java, 313 306 322 байта

Я надеюсь, что это превосходит PHP ... И нет. Глупые длинные имена функций.

-7 спасибо @quartata за избавление от публичного +16, чтобы исправить ошибку, когда раскол был точным, спасибо @TheCoder за его перехват

int[] f(String b,int s){int i=0,o[]=new int[(int)Math.ceil(b.length()*8.0/s)],a=0;String x="",t;for(char c:b.toCharArray()){t=Integer.toString(c,2);while(t.length()<8)t="0"+t;x+=t;a+=8;while(a>=s){o[i++]=Integer.parseInt(x.substring(0,s),2);x=x.substring(s,a);a-=s;}}while(a++<s)x+="0";o[i]=Integer.parseInt(x,2);return o;}

Рубин , 66 байт

->s,n{(s.unpack('B*')[0]+?0*~-n).scan(/.{#{n}}/).map{|x|x.to_i 2}}

Попробуйте онлайн!

Принимает входной буфер как строку, так что несколько тестовых строк были построены непосредственно в нижнем колонтитуле, чтобы избежать непечатных.

MATL , 9 байт

8&B!we!XB

Попробуйте онлайн!

Принимает ввод bв виде строки, разделенной ''или как массив значений, разделенных запятыми, например [102, 48, 111], затем n.

8           # push 8
&B          # implicitly take input b, and use 2-element convert to binary
            # to push a binary matrix of 8 bits
!           # transpose, so each column represents an input
w           # implicitly take input n and swap it with binary matrix to top of stack
e           # reshape into n rows, padding with zeros at end
            # this matrix will have each column as an n-bit integer
!           # transpose, so each row is now the n-bit integer
XB          # convert each row to decimal
            # implicit output

Perl 5 -nl -MData::Dump=pp , 96 байт

$}=$_;pp map{$_=sprintf"%-$}s",$_;y/ /0/;oct"0b$_"}(join'',map{sprintf"%08b",$_}<>)=~m/.{1,$_}/g

Попробуйте онлайн!

Требуется Data::Dump модуль.

принимает n первую строку ввода и цифры в каждой строке после этого.

Выходы в STDERR (поле отладки на TIO).

Оспарил и привел в порядок:

BEGIN { $/ = "\n"; $\ = "\n"; }
use Data::Dump ( split( /,/, 'pp', 0 ) );
LINE: while ( defined( $_ = readline ARGV ) ) {
    chomp $_;
    $} = $_;
    pp(
        map( {
                $_ = sprintf( "%-$}s", $_ );
                tr/ /0/;
                oct "0b$_";
            } join( '', map( { sprintf '%08b', $_; } readline ARGV ) ) =~
              /.{1,$_}/g )
    );
}

Powershell 146 байт

param([int[]][char[]]$b,$n)-join($b|%{[convert]::ToString($_,2).PadLeft(8,"0")})-split"(.{$n})"|?{$_}|%{[convert]::ToInt32($_.PadRight($n,"0"),2)}

Возьмите в буфер и преобразуйте его в массив char, а затем в массив целых чисел. Для каждого из них преобразуйте в двоичный файл, дополните записи нулями там, где это необходимо, и объедините в одну большую строку. Разделите эту строку на n символов и отбросьте созданные пробелы. Каждый элемент из разбиения дополняется (это действительно нужно только последнему элементу) и преобразуется обратно в целое число. Выход представляет собой массив

Python 3,5 - 312 292 байта:

def d(a, b):
    o=[];o+=([str(bin(g)).lstrip('0b')if str(type(g))=="<class 'int'>"else str(bin(ord(g))).lstrip('0b')for g in a]);n=[''.join(o)[i:i+b]for i in range(0,len(''.join(o)),b)];v=[]
    for t in n:
        if len(t)!=b:n[n.index(t)]=str(t)+'0'*(b-len(t))
    v+=([int(str(f),2)for f in n])
    return v

Хотя это может быть длинным, насколько мне известно, это самый короткий способ принять и функции, и массивы без ошибок, и при этом сохранять некоторую точность в Python 3.5.

Ява, 253 247 байт

Golfed

int i,l,a[];Integer I;String f="";int[]c(String s,int n){for(char c:s.toCharArray())f+=f.format("%08d",I.parseInt(I.toString(c, 2)));while(((l=f.length())%n)>0)f+="0";for(a=new int[l=l/n];i<l;)a[i]=I.parseInt(f.substring(i*n,i++*n+n),2);return a;}

UnGolfed

int i,l,a[];
Integer I;
String f="";
int[]c(String s,int n) {
    for(char c:s.toCharArray())
        f+=f.format("%08d",I.parseInt(I.toString(c,2)));
    while(((l=f.length())%n)>0)
        f+="0";
    for(a=new int[l=l/n];i<l;)
        a[i]=I.parseInt(f.substring(i*n,i++*n+n),2);
    return a;
}

Желе , 13 байт

+256BḊ€Ẏsz0ZḄ

Попробуйте онлайн!

Отличается от ответа Денниса.

Примечание. Входные данные на самом деле представляют собой список неотрицательных целых чисел, но ссылка TIO облегчает вам боль и принимает либо такой список, либо строку.

Stax , 12 байт

è■àåk┘K¥xk└╣

Запустите и отладьте его

Это не функция, как указано в вызове, а программа, так как Stax не поддерживает функции. Он поддерживает ввод строк или литералов массива.

Python 2 , 101 байт

lambda a,n:[int(''.join(bin(x+256)[3:]for x in a+[0]*n)[n*i:][:n],2)for i in range((len(a)*8-1)/n+1)]

Попробуйте онлайн!

Дьялог АПЛ , 36 байт

{2∘⊥¨↓A⍴(×/A←⍺,⍨⌈⍺÷⍨8×≢⍵)↑∊↓⍉⍵⊤⍨8/2}

Попробуйте онлайн!

Это, вероятно, могло бы быть в гольфе больше.

Эликсир , 63 60 байт

&(s=&2-1)&&for<<x::size(&2)<-<<"#{&1}",0::size(s)>> >>,do: x

Попробуйте онлайн!

Принимает ввод как бинарный файл Elixir, выводит список целых чисел.

Этот код использует понимание генератора цепочек битов Elixir для разбиения входного двоичного файла &1на битовые блоки размером, предоставленным в качестве аргумента &2. Чтобы учесть любые оставшиеся биты в конце, мы дополняем двоичный файл &2 - 1нулевыми битами. Здесь также есть место, где проявляется нежелательная многословность: Elixir жалуется, если мы явно не объявляем &1как цепочку битов, и также не поддерживает выражения вsize(...) , следовательно, требуется дополнительное присвоение переменной.

Пасхальное яйцо: в сноске, замените IO.inspectс IO.puts, и наша функция магическим образом «переводит» Lorem Ipsum с латыни на китайский - Попробуйте его в Интернете!

Japt , 16 байт

После долгого дня встреч я чувствую, что забыл, как играть в гольф! Позже поиграю с этим в поезде домой, посмотрим, смогу ли я улучшить его.

c_¤ùT8ÃòV úTV mÍ

Попытайся

PHP ,135 129 124 байта

function($b,$n){foreach($b as$c)$a.=sprintf('%08b',$c);foreach(str_split($a,$n)as$s)$d[]=bindec(str_pad($s,$n,0));return$d;}

Попробуйте онлайн!

Реализованный как функция, входной буфер представляет собой массив целых и возвращает массив целых чисел.

Выход

> b = "f0oBaR", n = 5
[12,24,24,6,30,16,19,1,10,8]

> b = "Hello World", n = 50
[318401791769729,412278856237056]

> b = [1,2,3,4,5], n = 1
[0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1]

Проверьте все контрольные примеры

APL (NARS), 471 символ, 942 байта

TH←{v←↑⍴⍴⍵⋄v>2:64⋄v=2:32⋄(v=1)∧''≡0↑⍵:20⋄''≡0↑⍵:4⋄v=1:16⋄⍵≢+⍵:8⋄⍵=⌈⍵:2⋄1}
TV←{x←TH¨⍵⋄k←↑x⋄t←↑⍴⍵⋄t=+/x=2:2⋄t=+/x≤2:1⋄(k≤8)∧⍬≡x∼k:k⋄0}
T←{v←↑⍴⍴⍵⋄v>2:64+TV⍵⋄v=2:32+TV⍵⋄(v=1)∧''≡0↑⍵:20⋄''≡0↑⍵:4⋄v=1:16+TV⍵⋄⍵≢+⍵:8⋄⍵=⌈⍵:2⋄1}
RI←{t←T⍵⋄(t≠1)∧(t≠2)∧(t≠17)∧(t≠18):0⋄∧/((1⊃⍺)≤⍵)∧⍵≤(2⊃⍺)}
B←{(8⍴2)⊤⍵}⋄C←{¯1+⎕AV⍳⍵}⋄f←{t←T⍵⋄(0 255 RI⍵)∧18=t:∊B¨⍵⋄(0 255 RI x←C¨⍵)∧20=t:∊B¨x⋄,¯1}⋄W←{((↑⍴⍵)⍴2)⊥⍵}
q←{(∼1 64 RI,⍺)∨2≠T⍺:,¯1⋄x←f⍵⋄¯1=↑x:,¯1⋄t←↑⍴x⋄k←(⍺-m)×0≠m←⍺∣t⋄W⍉((t+k)÷⍺)⍺⍴(((t⍴1),k⍴0)\x)}

прокомментированный код и тест:

  ⍝TH⍵ return type its argument
  TH←{v←↑⍴⍴⍵⋄v>2:64⋄v=2:32⋄(v=1)∧''≡0↑⍵:20⋄''≡0↑⍵:4⋄v=1:16⋄⍵≢+⍵:8⋄⍵=⌈⍵:2⋄1}
  ⍝ TV⍵ check if type each element of array ⍵ is the same and basic 
  ⍝ (float(int and float too),int,char,complex) and return its number (or 0 if it is not basic)
  TV←{x←TH¨⍵⋄k←↑x⋄t←↑⍴⍵⋄t=+/x=2:2⋄t=+/x≤2:1⋄(k≤8)∧⍬≡x∼k:k⋄0}
  ⍝ T⍵ return the type of ⍵ [it would be ok if ⍵ is not a function]
  ⍝|1 Float|2 Int|4 Char|8 Complex,Quaternion or Oction|16 List|32 Matrix|64 Tensor
  ⍝|17 List Float|18 List Int|20 List Char=string|etc
  T←{v←↑⍴⍴⍵⋄v>2:64+TV⍵⋄v=2:32+TV⍵⋄(v=1)∧''≡0↑⍵:20⋄''≡0↑⍵:4⋄v=1:16+TV⍵⋄⍵≢+⍵:8⋄⍵=⌈⍵:2⋄1}
  ⍝ ⍺RI⍵ check if the numeric array ⍵ has elements in [1⊃⍺ 2⊃⍺]; if type is not ok return 0(false)
  RI←{t←T⍵⋄(t≠1)∧(t≠2)∧(t≠17)∧(t≠18):0⋄∧/((1⊃⍺)≤⍵)∧⍵≤(2⊃⍺)}

  B←{(8⍴2)⊤⍵}   ⍝ from decimal to binary of element 0..255
  C←{¯1+⎕AV⍳⍵}   ⍝ return the number of char that is in array AV seems the ascii number
  ⍝ f⍵ with ⍵ List int element in 0..255 or String with numeric element 0..255 
  ⍝ return the corrispondence disclosed binary array 
  f←{t←T⍵⋄(0 255 RI⍵)∧18=t:∊B¨⍵⋄(0 255 RI x←C¨⍵)∧20=t:∊B¨x⋄,¯1}
  W←{((↑⍴⍵)⍴2)⊥⍵} ⍝ from list of binary digit to decimal
  ⍝ the function for the exercise
  q←{(∼1 64 RI,⍺)∨2≠T⍺:,¯1⋄x←f⍵⋄¯1=↑x:,¯1⋄t←↑⍴x⋄k←(⍺-m)×0≠m←⍺∣t⋄W⍉((t+k)÷⍺)⍺⍴(((t⍴1),k⍴0)\x)}


  5 q    'f0oBaR'
12 24 24 6 30 16 19 1 10 8 
  50 q "Hello World"
318401791769729 412278856237056 
  1  q 1 2 3 4 5
0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 
  32 q "codegolf"
1668244581 1735355494 
  7 q "codegolf"
49 91 108 70 43 29 94 108 51 0 
  8 q 2 31 73 127 179 233
2 31 73 127 179 233 
  64 q 2 31 73 127 179 233
1.529217252E17 
  65 q 2 31 73 127 179 233
¯1 
  0 q 2 31 73 127 179 233
¯1 
  23 q '123'
1612057 4194304 
  23 q '123∞'
¯1 
  23 q '1' 2 3
¯1 
  23 q 2 3.3
¯1 
  23 q 2 
¯1 
  23 q '1'
¯1 
  23 q ,2 
65536 
  23 q ,'1'
1605632