Viết hàm khi được cung cấp bộ đệm b(dài 1 - 104857600 byte) và một số bit n(1 <= n <= 64), chia bộ đệm thành các khối nbit. Phải đệm phần cuối cùng với 0s lên đến nbit.

ví dụ

Cho bộ đệm b = "f0oBaR"hoặc tương đương [102,48,111,66,97,82]và n = 5, trả lại

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

Điều này là do bộ đệm ở trên, khi được biểu diễn dưới dạng nhị phân:

01100110 00110000 01101111 01000010 01100001 01010010

Và khi được nhóm lại thành 5s, hình như:

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

Mà khi chuyển đổi trở lại thành thập phân cho câu trả lời.

Ghi chú

• Bạn có thể sử dụng bất kỳ loại dữ liệu nào có ý nghĩa nhất trong ngôn ngữ của bạn để thể hiện bộ đệm. Trong PHP bạn có thể sử dụng một chuỗi, trong Node bạn có thể muốn sử dụng Bộ đệm
  • Nếu bạn sử dụng một chuỗi để biểu diễn bộ đệm, giả sử đó là ASCII cho chuyển đổi char -> int
  • Bạn có thể sử dụng một mảng ints (0-255) cho đầu vào nếu bạn thích
• Giá trị trả về phải là một mảng hoặc danh sách các số nguyên

Các trường hợp thử nghiệm

> 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

Bình thường, 18 17 byte

iR2c.[t.B+C1z\0QQ

Cảm ơn @lirtosiast cho một byte!

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

Thạch, 13 byte

1;ḅ256æ«BḊsḄṖ

Điều này lấy đầu vào là một danh sách các số nguyên. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Đây là một hàm chấp nhận một mảng số nguyên và một số nguyên và trả về một mảng số nguyên. Đó là một bài tập trong lạm dụng đối số chức năng.

Ung dung:

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

Python 3, 102 byte

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]

sử dụng thủ thuật lặp để nhóm chuỗi

Các kết quả

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

JavaScript (ES6), 120 byte

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

Bit đệ quy twiddling trên mảng số nguyên. Ung dung:

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

Ruby, 114 byte

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

Hơi sạch hơn:

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 byte

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

PHP 262 217 189 byte

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

(được cập nhật với các mẹo từ Ismael Miguel )

Được định dạng để dễ đọc:

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

Thí dụ:

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

CJam, 30 byte

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

Hãy thử trực tuyến!

Đây là một khối không tên, dự kiến ​​bộ đệm int và số lượng khối trên ngăn xếp và để lại kết quả trên ngăn xếp.

Quyết định cho CJam thử. Chỉ mất 2 giờ để hoàn thành nó ^^ Điều này có lẽ quá dài, những lời đề nghị rất đáng hoan nghênh!

Giải trình

_ e # nhân đôi số lượng
@ e # xoay ngăn xếp, mảng bây giờ trên đầu và số lượng chunk ở phía dưới
{e # bắt đầu một khối mới
 2b e # chuyển đổi thành nhị phân
 8 0e [e # thêm số không ở bên trái, vì vậy nhị phân là 8 bit
} e # kết thúc khối trước
% e # áp dụng khối này cho từng thành phần mảng (bản đồ)
e_ e # làm phẳng mảng
0a e # đẩy một mảng có một số 0 vào ngăn xếp
@ e # xoay ngăn xếp, ngăn xếp chứa ngay n [mảng] [0] n
* e # lặp lại mảng [0] n lần
+ e # concat hai mảng
/ e # chia thành các đoạn có độ dài n, bây giờ các ngăn xếp chỉ chứa mảng
-1 <e # loại bỏ đoạn cuối cùng
{2b}% e # chuyển đổi mọi đoạn trở lại thành số thập phân

JavaScript (ES6) 104

Lặp đi lặp lại từng chút một,

Chỉnh sửa 5 byte lưu 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)

Ít chơi gôn

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

Kiểm tra

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 byte

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

Đây là một chức năng ẩn danh, mất n số bên trái và blàm số làm đối số bên phải.

Kiểm tra:

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

Giải trình:

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

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

Ví dụ sử dụng: 5 # [102,48,111,66,97,82]-> [12,24,24,6,30,16,19,1,10,8].

Làm thế nào nó hoạt động

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 byte

Tôi hy vọng điều này đánh bại PHP ... Và không. Tên hàm dài ngu ngốc.

-7 cảm ơn @quartata vì đã thoát khỏi công khai +16 để sửa lỗi khi phân tách chính xác, cảm ơn @TheCoder đã bắt được nó

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

Ruby , 66 byte

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

Hãy thử trực tuyến!

Lấy bộ đệm đầu vào dưới dạng một chuỗi, để một vài chuỗi thử nghiệm được xây dựng trực tiếp ở chân trang để tránh không thể in được.

MATL , 9 byte

8&B!we!XB

Hãy thử trực tuyến!

Lấy đầu vào bdưới dạng một chuỗi được phân tách bằng ''hoặc như một mảng các giá trị được phân tách bằng dấu phẩy như [102, 48, 111]sau đó 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 byte

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

Hãy thử trực tuyến!

Yêu cầu Data::Dumpmô-đun.

Lấy ndòng đầu tiên và số trên mỗi dòng sau đó.

Đầu ra cho STDERR (trường Gỡ lỗi trên TIO).

Depared và dọn dẹp:

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 byte

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

Đi vào bộ đệm và chuyển đổi nó thành một mảng char và sau đó là một mảng số nguyên. Đối với mỗi chuyển đổi thành nhị phân, hãy đệm các mục nhập bằng 0 khi cần và tham gia dưới dạng một chuỗi lớn. Tách chuỗi đó trên n ký tự và thả các khoảng trống được tạo. Mỗi phần tử từ phần tách được đệm (chỉ phần tử cuối cùng thực sự cần nó) và được chuyển đổi trở lại thành một số nguyên. Đầu ra là một mảng

Python 3,5 - 312 292 byte:

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

Mặc dù điều này có thể dài, điều này là, trong sự hiểu biết của tôi, là con đường ngắn nhất để chấp nhận cả hai chức năng và mảng mà không có lỗi, và vẫn có thể giữ lại một số chính xác bằng Python 3.5.

Java, 253 247 byte

Chơi gôn

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

Vô duyên

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

Thạch , 13 byte

+256BḊ€Ẏsz0ZḄ

Hãy thử trực tuyến!

Khác với câu trả lời của Dennis.

Lưu ý: Đầu vào thực sự là một danh sách các số nguyên không âm, nhưng liên kết TIO giúp giảm bớt nỗi đau cho bạn và chấp nhận một danh sách hoặc chuỗi như vậy.

Stax , 12 byte

è■àåk┘K¥xk└╣

Chạy và gỡ lỗi nó

Đây không phải là một chức năng như được chỉ định trong thử thách, mà là một chương trình, vì stax không hỗ trợ các chức năng. Nó hỗ trợ đầu vào của chuỗi hoặc bằng chữ.

Python 2 , 101 byte

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

Hãy thử trực tuyến!

APL Dyalog , 36 byte

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

Hãy thử trực tuyến!

Điều này có lẽ có thể được đánh golf xuống nhiều hơn.

PHP , 135 byte

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

Hãy thử trực tuyến!

Được thực hiện như một hàm, bộ đệm đầu vào là một mảng các số nguyên và trả về một mảng các số nguyên.

Đầu ra

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

Xác nhận tất cả các trường hợp kiểm tra

APL (NARS), 471 ký tự, 942 byte

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

mã nhận xét và kiểm tra:

  ⍝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 

Thuốc tiên , 63 60 byte

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

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng nhị phân Elixir, đưa ra danh sách các số nguyên.

Mã này sử dụng sự hiểu biết của bộ tạo chuỗi Elixir để phân đoạn nhị phân đầu &1vào thành các khối bit có kích thước được cung cấp làm đối số &2. Để tính toán cho bất kỳ bit còn lại nào ở cuối, chúng ta đệm nhị phân với &2 - 1các bit bằng không. Đây cũng là nơi mà một số tính dài dòng không mong muốn xuất hiện: Elixir phàn nàn nếu chúng tôi không tuyên bố rõ ràng &1là chuỗi bit và nó cũng không hỗ trợ các biểu thức trongsize(...) , do đó cần thêm một phép gán biến.

Trứng phục sinh: ở chân trang, thay thế IO.inspect với IO.puts, và chức năng của chúng tôi một cách kỳ diệu "dịch" Lorem ipsum từ Latinh sang tiếng Trung - Hãy thử nó trên mạng!