Écrivez une fonction qui, lorsqu'elle reçoit un tampon b(1 - 104857600 octets) et un certain nombre de bits n(1 <= n <= 64), divise le tampon en morceaux de nbits. Remplissez le dernier bloc avec 0s jusqu'à nbits.

par exemple

Étant donné le tampon b = "f0oBaR"ou de manière équivalente [102,48,111,66,97,82]et n = 5, retour

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

En effet, le tampon ci-dessus, lorsqu'il est représenté sous forme binaire, ressemble à:

01100110 00110000 01101111 01000010 01100001 01010010

Et une fois regroupé en 5s ressemble à:

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

Ce qui, une fois reconverti en décimal, donne la réponse.

Remarques

• Vous pouvez utiliser le type de données le plus logique dans votre langue pour représenter le tampon. En PHP, vous utiliseriez probablement une chaîne, dans Node, vous voudrez peut-être utiliser un tampon
  • Si vous utilisez une chaîne pour représenter le tampon, supposez que c'est ASCII pour la conversion char -> int
  • Vous pouvez utiliser un tableau d'ints (0-255) pour l'entrée si vous préférez
• La valeur de retour doit être un tableau ou une liste d'entiers

Cas de test

> 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 octets

iR2c.[t.B+C1z\0QQ

Merci à @lirtosiast pour un octet!

            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))

Gelée, 13 octets

1;ḅ256æ«BḊsḄṖ

Cela prend l'entrée comme une liste d'entiers. Essayez-le en ligne!

Comment ça marche

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).

Julia, 117 octets

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])

Il s'agit d'une fonction qui accepte un tableau entier et un entier et renvoie un tableau entier. C'est un exercice d'abus d'argument de fonction.

Non golfé:

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 octets

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])

Twiddling binaire récursif sur des tableaux entiers. Non golfé:

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 octets

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]

utiliser l' astuce pour regrouper la chaîne

• s: la chaîne / tampon d'entrée
• n: le nombre de bits dans chaque bloc divisé

Résultats

>>> 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]

Rubis, 114 octets

->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}

Légèrement plus propre:

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 octets

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

PHP, 262 217 189 octets

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)));}

(mis à jour avec des conseils d' Ismael Miguel )

Formaté pour la lisibilité:

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)));
}

Exemple:

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

CJam, 30 octets

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

Essayez-le en ligne!

Il s'agit d'un bloc sans nom qui attend le tampon int et la quantité de morceaux sur la pile et laisse le résultat sur la pile.

A décidé d'essayer CJam. Cela ne m'a pris que 2 heures pour le faire ^^ C'est probablement trop long, les suggestions sont les bienvenues!

Explication

_ e # dupliquer le nombre de morceaux
@ e # rotation pile, tableau maintenant en haut et nombre de morceaux en bas
{e # commence un nouveau bloc
 2b e # convertir en binaire
 8 0e [e # ajouter des zéros sur la gauche, donc le binaire est de 8 bits
} e # end block précédent
% e # applique ce bloc à chaque élément du tableau (carte)
e_ e # aplatir le tableau
0a e # pousser un tableau avec un seul zéro dans la pile
@ e # faire pivoter la pile, la pile contient maintenant n [tableau] [0] n
* e # répète le tableau [0] n fois
+ e # concatre les deux tableaux
/ e # divisé en morceaux de longueur n, maintenant les piles ne contiennent que le tableau
-1 <e # jeter le dernier morceau
{2b}% e # reconvertit chaque morceau en décimal

JavaScript (ES6) 104

Petit à petit tripotage itératif,

Modifier 5 octets de sauvegarde 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)

Moins golfé

( 
 // 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
)

Tester

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 octets

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

Il s'agit d'une fonction anonyme, qui prend ncomme argument de gauche et des bnombres comme argument de droite.

Tester:

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

Explication:

[:#.-@[>\;@(_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 octets

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

Exemple d'utilisation: 5 # [102,48,111,66,97,82]-> [12,24,24,6,30,16,19,1,10,8].

Comment ça marche

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 octets

J'espère que cela bat PHP ... Et non. Noms de fonction longs stupides.

-7 merci à @quartata pour se débarrasser du public +16 pour corriger une erreur lorsque le split était exact, merci à @TheCoder pour l'avoir rattrapé

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;}

Rubis , 66 octets

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

Essayez-le en ligne!

Prend le tampon d'entrée sous forme de chaîne, de sorte que quelques chaînes de test ont été construites directement dans le pied de page pour éviter les non imprimables.

MATL , 9 octets

8&B!we!XB

Essayez-le en ligne!

Prend l'entrée bcomme une chaîne délimitée par ''ou comme un tableau de valeurs séparées par des virgules comme [102, 48, 111], alors 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 octets

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

Essayez-le en ligne!

Nécessite le Data::Dumpmodule.

Prend nla première ligne d'entrée et les numéros sur chaque ligne après cela.

Sorties vers STDERR (le champ Debug sur TIO).

Dépareillé et rangé:

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 octets

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

Prenez le tampon et convertissez-le en un tableau de caractères, puis en un tableau d'entiers. Pour chacun de ceux convertis en binaire, remplissez les entrées avec des 0 si nécessaire et joignez-les en une seule grande chaîne. Fractionnez cette chaîne sur n caractères et supprimez les espaces créés. Chaque élément de la division est rembourré (seul le dernier élément en aurait vraiment besoin) et reconverti en entier. La sortie est un tableau

Python 3.5 - 312 292 octets:

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

Bien que cela puisse être long, c'est, à ma connaissance, le moyen le plus court d'accepter à la fois des fonctions et des tableaux sans erreurs, tout en conservant une certaine précision dans Python 3.5.

Java, 253 247 octets

Golfé

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;
}

Gelée , 13 octets

+256BḊ€Ẏsz0ZḄ

Essayez-le en ligne!

Différent de la réponse de Dennis.

Remarque: L'entrée est en fait une liste d'entiers non négatifs, mais le lien TIO vous facilite la tâche et accepte une telle liste ou une chaîne.

Stax , 12 octets

è■àåk┘K¥xk└╣

Exécuter et déboguer

Ce n'est pas une fonction comme spécifié dans le défi, mais un programme, car stax ne prend pas en charge les fonctions. Il prend en charge la saisie de chaînes ou de littéraux de tableau.

Python 2 , 101 octets

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)]

Essayez-le en ligne!

Dyalog APL , 36 octets

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

Essayez-le en ligne!

Cela pourrait probablement être plus bas.

Elixir , 63 60 octets

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

Essayez-le en ligne!

Prend l'entrée comme binaire Elixir, sort une liste d'entiers.

Ce code utilise la compréhension du générateur de chaînes de bits Elixir pour segmenter le binaire d'entrée &1en blocs de bits de taille fournis en argument &2. Pour tenir compte des bits restants à la fin, nous remplissons le binaire avec &2 - 1zéro bits. Voici également l'endroit où intervient une verbosité indésirable: Elixir se plaint si nous ne déclarons pas explicitement &1comme chaîne de bits, et il ne prend pas en charge les expressions dans size(...), d'où la nécessité d'une affectation de variable supplémentaire.

Oeuf de Pâques: dans le pied de page, remplacez IO.inspectpar IO.puts, et notre fonction "traduit" magiquement Lorem ipsum du latin au chinois - Essayez-le en ligne!

Japt , 16 octets

Après une longue journée de rencontres, j'ai l'impression d'avoir oublié comment jouer au golf! Je vais jouer avec ça dans le train plus tard, voir si je peux l'améliorer.

c_¤ùT8ÃòV úTV mÍ

Essayez-le

PHP ,135 129 124 octets

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;}

Essayez-le en ligne!

Mis en œuvre en tant que fonction, le tampon d'entrée est un tableau d'entiers et renvoie un tableau d'entiers.

Sortie

> 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]

Vérifier tous les cas de test

APL (NARS), 471 caractères, 942 octets

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)}

code commenté et test:

  ⍝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