_{Điều này liên quan đến nhiệm vụ của tôi để phát minh ra một ngôn ngữ lập trình bí truyền .}

Một bảng gồm các số nhị phân 0 .. 15 có thể được sử dụng để triển khai Hàm nhị phân phổ quát sử dụng các thao tác lập chỉ mục. Cho hai đầu vào 1 bit X và Y, tất cả 16 hàm có thể có thể được mã hóa trong opcode 4 bit.

X Y  F|0 1 2 3 4 5 6 7 8 9 A B C D E F
- -    - - - - - - - - - - - - - - - -  
0 0    0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1    0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
1 0    0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
1 1    0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
       -     -   - -   -   -   -   - -
       0    ~X  ~Y ^   &   Y   X   | 1
      ZERO    NOT-Y   AND         OR
          NOT-X   XOR              ONE

Vì vậy, bộ 16 hàm này có thể được áp dụng cho các đầu vào nhị phân làm hàm

U (f, x, y): (f >> ((x << 1) | y)) & 1 ,

hoặc là

U (f, x, y): (f / 2 ^ (x × 2 + y))% 2 ,

hoặc với lập chỉ mục hoặc phân vùng ma trận.

Sẽ rất hữu ích khi biết cách nhỏ gọn nhất để biểu diễn hoặc tạo một bảng giá trị như vậy cho bất kỳ ngôn ngữ nào có thể được xây dựng dựa trên loại hoạt động nhị phân này.

Mục đích:

Tạo đầu ra văn bản chính xác này:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

Đó là nó! Mã ngắn nhất thắng.

J, 10 (13?) Ký tự

|.|:#:i.16

Danh sách số:

   i.16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15`

thành nhị phân:

   #:i.16
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1

Chuyển đổi:

   |:#:i.16
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Đảo ngược:

   |.|:#:i.16
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

Chúng ta có cần phải loại bỏ không gian? Nhìn vào câu trả lời J khác có vẻ như chúng tôi vì vậy chúng tôi sẽ cần phải thêm 3 nhân vật và mượn 1":từ câu trả lời của Jan .

Con trăn 2, 40

for n in 1,2,4,8:print 8/n*('0'*n+'1'*n)

APL (14)

Giả sử ⎕IO=0(đó là một cài đặt):

⎕D[⊖(4⍴2)⊤⍳16]

Giải trình:

• ⍳16: số [0,16)
• (4⍴2)⊤: mã hóa mỗi số trong cơ sở 2 bằng 4 chữ số
• ⊖: đảo ngược theo chiều ngang (vì vậy MSB kết thúc ở trên cùng)
• ⎕D[... ]: chọn các giá trị này từ ⎕Dđó là chuỗi 0123456789. (Một ma trận số được hiển thị với khoảng trắng giữa các giá trị, ma trận ký tự thì không. Vì vậy, ma trận này chuyển đổi từng bit số thành một trong các ký tự '0' '1').

Jelly , 42 7 byte (không cạnh tranh)

⁴ḶBUz0Y

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

Cảm ơn Dennis vì sự giúp đỡ của anh ấy. Đây là tin nhắn đầu tiên, đây là tin nhắn cuối cùng (các cuộc thảo luận khác cũng xảy ra). Với sự giúp đỡ của anh ấy, tôi dường như (gần như) bắt nguồn từ điểm số.

/// , 51 byte

Dùng thử trực tuyến

/a/0101/aaaa
/b/0011/bbbb
/z/0000//o/1111/zozo
zzoo

GolfScript ( 18 17 15 ký tự)

(Cảm ơn Howard)

16,zip{','-~n}%

Tôi không hiểu tại sao 10-char

16,zip{n}/

không hoạt động; Tôi nghi ngờ rằng một lỗi trong trình thông dịch chuẩn sẽ dẫn đến các loại không được hỗ trợ trên ngăn xếp.

Một thay thế ở 18 ký tự mà tôi hiểu đầy đủ là:

4,{2\?.2,*$8@/*n}%

Một cách tiếp cận toán học dài hơn một chút, ở 28 ký tự:

4,{2.@??)2.4??.@/+2base(;n}/

Rất nhiều trong số đó là cho chuyển đổi cơ sở và không đệm. Không có những thứ đó, nó giảm xuống còn 19 ký tự,

4,{2.@??)2.4??\/n}/

với đầu ra

21845
13107
3855
255

CJam - 16

4,{G,f{\m>2%}N}/

Mã java tương đương (như giải thích):

public class Lookup {
    public static void main(final String... args) {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 16; ++j) {
                System.out.print((j >> i) % 2);
            }
            System.out.println();
        }
    }
}

Javascript (ECMA6), 67

s=(k,n)=>n-.5?s((k<<n/2)^k,n/2)+"0".repeat(n)+k.toString(2)+"\n":"" 

Để sử dụng, hãy gọi

s(255,8)

Chặt chẽ!
Và cũng XOR và một chút đệ quy.

Điều đầu tiên cần lưu ý là nếu chúng tôi lấy bất kỳ dòng nào và bạn dịch chuyển nó (# của 0 liên tục) / 2 trái, chúng tôi sẽ có một XOR đẹp để đưa dòng tiếp theo lên.

Ví dụ,

0000000011111111 //line 4
0000111111110000 //shifted 4 to the left

XOR những bitwise cho chúng tôi

0000111100001111 //XOR'ed. This is line 3!

đó là dòng tiếp theo lên (dòng 3).
Áp dụng quy trình tương tự cho dòng 3, shift 2 trái và chúng tôi nhận được ...

0000111100001111
0011110000111100

XOR'ed cho

0011001100110011

đó là dòng 2.
Chú ý rằng số tiền chúng tôi chuyển nửa mỗi lần.
Bây giờ chúng ta chỉ cần gọi hàm này một cách đệ quy, với 2 đối số. Giá trị nguyên của dòng này và N, là giá trị chúng ta cần thay đổi. Khi chúng tôi thực hiện đệ quy, chỉ cần chuyển vào giá trị XOR'ed đã dịch chuyển và n / 2.

"0".repeat(n)

là để đệm 0 đến đầu mỗi dòng vì toString đưa ra 0 hàng đầu.

J, 21 ký tự

1":<.2|(2^i.4)%~/i.16

• i.16 là danh sách 0..15
• 2^i.4 là một danh sách (1,2,4,8)
• %~/ tạo bảng các phân chia trong đó đối số bên trái tạo thành các hàng nhưng là đối số bên phải để phân chia
• 2| tính phần còn lại sau khi chia [mỗi ô] cho hai
• <. các tầng có giá trị bằng 0 hoặc 1
• 1": định dạng bảng với một ký tự cho mỗi ô

GolfScript, 19 ký tự

Một cách tiếp cận GolfScript khác

4,{2\?{&!!}+16,%n}%

Hồng ngọc (44)

Nhàm chán và dài: Chỉ cần in các biểu diễn nhị phân 0 đệm của các số.

[21845,13107,3855,255].map{|i|puts"%016b"%i}

Bản thảo 108 177 126 77 74 70

[43690 52428 61680 65280]
{16{dup 2 mod =only 2 idiv}repeat<>=}forall

Đảo ngược các giá trị cho một đơn giản Mod tắt phương pháp.

151 131 119

Áp dụng một cách tiếp cận APL -ish hơn. chỉnh sửa: thay thế chuỗi cắt và nén mảng bằng lập chỉ mục và vòng lặp for.

[[0 1 15{}for]{16 add 2 5 string cvrs}forall]4 
-1 1{0 1 15{2 index exch get 1 index 1
getinterval =only}for pop<>=}for

Thụt lề:

[[0 1 15{}for]{16 add 2 5 string cvrs}forall]
4 -1 1{ % [] i
    0 1 15{ % [] i j
        2 index exch get % [] i [](j)
        1 index 1  % [] i [](j) i 
        getinterval  % [] i [](j)<i>
        =only  % [] i
    }for 
    pop<>= % []
}for

Thực hiện lại các chức năng được sử dụng trong câu trả lời J chiến thắng dẫn đến điều này (với rất nhiều mã hỗ trợ ).

-1 16 i + #: |: |.{{==only}forall()=}forall

iđây là vectơ dựa trên 1 được mô tả trong Hàm cơ bản của Iverson , do đó -1 ... +sẽ tạo ra 0 .. 15.

Perl (36 + 1)

+1 cho say, như thường lệ. đôi 0không phải là một lỗi đánh máy :)

map say((00x$_,1x$_)x(8/$_)),1,2,4,8

JavaScript (ECMA6), 108

Thử một cách tiếp cận khác ở đây. Mặc dù nó được khuyến khích sử dụng các toán tử nhị phân, tôi đã cho phép bản thân gửi giải pháp này vì challange cũng phức tạp kolmogorov và tôi đã nghĩ - làm cách nào tôi có thể giảm số lượng mã đại diện cho các giá trị đó ...? Căn cứ .

['gut','a43','2z3','73'].forEach(n=>{a=parseInt(n,36).toString(2);
alert(('00000000'+a).substr(a.length-8))})

(Ngắt dòng cho thuận tiện).

Thật xấu hổ khi tôi phải loay hoay với việc đệm với các số 0 đứng đầu, nhưng điểm của mã này chỉ đơn giản là biểu thị kết quả nhị phân đích trong Base 36, chính xác là các gut, a43, 2z3, 73giá trị đó.

Lưu ý: Tôi nhận ra rằng nó sẽ không ở bất cứ đâu gần câu trả lời chiến thắng, nhưng chỉ vì ý tưởng ...

Sprects , 44 byte

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

Câu trả lời của Cedric chuyển đến Sprects.

MATL ( không cạnh tranh ), 8 byte

16:qYB!P

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

Giải trình

16:    % Generate range [1 2 ... 16]
q      % Subtract 1, element-wise
YB     % Convert to binary. Gives a 16×4 char array. Each original number is a row
!      % Transpose
P      % Reverse vertically. Implicitly display

CJam ( không cạnh tranh ), 10 9 byte

Cảm ơn @Dennis đã giảm 1 byte!

Y4m*zW%N*

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

Giải trình

Y     e# Push 2
4     e# Push 4
m*    e# Cartesian power of 2 (interpreted as [0 1]) with exponent 4
z     e# Zip
W%    e# Reverse the order of rows
N*    e# Join with newlines. Implicitly display

JavaScript (ES6), 58 52 byte

Xây dựng chuỗi đệ quy.

f=(n=64)=>n--?f(n)+(!n|n&15?'':`
`)+(n>>(n>>4)&1):''

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

Đệ quy này dựa trên thực tế là mô hình được tạo từ biểu diễn nhị phân dọc của nibble 0x0 đến 0xF:

  0101010101010101 bit #0 <- Y = 0
  0011001100110011 bit #1
  0000111100001111 bit #2
  0000000011111111 bit #3 <- Y = 3
  ----------------
  0123456789ABCDEF
  ^              ^
X = 0          X = 15

Do đó, mỗi vị trí (X, Y) trong mẫu này có thể được biểu thị dưới dạng bit Y-th của X : X & (1 << Y). Chúng ta cũng có thể cô lập bit này với : (X >> Y) & 1. Thay vì theo dõi X và Y, chúng tôi lặp lại trên một biến duy nhất ntrong khoảng từ 0 đến 63. Vì vậy, công thức trở thành : (n >> (n >> 4)) & 1. Thực sự dễ dàng hơn để lặp từ 63 đến 0, vì vậy chuỗi được xây dựng theo thứ tự ngược lại. Nói cách khác, ký tự n-1 được gắn vào bên trái của ký tự n .

Như một lưu ý phụ, đệ quy không mang lại bất cứ điều gì ở đây ngoại trừ mã ngắn hơn.

Không có ngắt dòng, mã dài 35 byte:

f=(n=64)=>n--?f(n)+(n>>(n>>4)&1):''

Chúng ta cần thêm 17 byte để chèn các ngắt dòng. Điều này có thể được rút ngắn xuống còn 14 byte nếu việc ngắt dòng hàng đầu được chấp nhận.

Bản giới thiệu

f=(n=64)=>n--?f(n)+(!n|n&15?'':`
`)+(n>>(n>>4)&1):''

console.log(f());

Bash + coreutils, 65 byte

Không phải ngắn nhất, nhưng cũng không dài nhất:

for i in {1,2,4,8};{ eval echo \$\[\({0..15}\&$i\)/$i];}|tr -d \ 

(Ký tự cuối cùng là một khoảng trắng)

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

APAR NARS2000, 22

"01"[⊖1+(4⍴2)⊤(⍳16)-1]

Bắt nguồn từ câu trả lời APL của marinus, dường như không hoạt động trên NARS2000.

Tạo vector

      ⍳16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Thay đổi thành không dựa trên

      (⍳16)-1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Tạo hình dạng cho mã hóa

      (4⍴2)
2 2 2 2

Mã hóa

      (4⍴2)⊤(⍳16)-1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Điều chỉnh để lập chỉ mục dựa trên 1

      1+(4⍴2)⊤(⍳16)-1
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2
1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2
1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2

Đảo ngược trục chính

      ⊖1+(4⍴2)⊤(⍳16)-1
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2
1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2

Mục lục

      "01"[⊖1+(4⍴2)⊤(⍳16)-1]
0101010101010101
0011001100110011
0000111100001111
0000000011111111

C, 73 ký tự

i;main(){for(;i<64;)i&15||puts(""),putchar(48|1&~0xFF0F0F33335555>>i++);}

Đây chỉ là một giải pháp chung để xuất 64 bit thành bốn khối 16 bit; bạn chỉ cần thay đổi số 0xFF0F0F33335555để xuất ra một chuỗi bit khác.

đơn giản hóa và vô dụng:

int main() {
    int i;
    for(i = 0; i < 64; i++) {
        if(i % 16 == 0) {
            puts("");
        }
        int bit = ~0xFF0F0F33335555 >> i;
        bit &= 1;
        putchar('0' + bit);
    }
}

Haskell, 73

Rất tiếc, 73 ký tự! Mặc dù vậy, tôi không thể vì tình yêu của chúa.

r=replicate
f n=r(div 8n)("01">>=r n)>>=id
main=mapM(putStrLn.f)[1,2,4,8]

Điều đáng buồn thực sự ở đây là nếu bạn lặp lại đầu ra bằng bash, bạn chỉ cần 74 ký tự.

JavaScript (ES5) 69

for(x="";4>x;x++){z="";for(n=0;16>n;)z+=1-!(n++&1<<x);console.log(z)}

inca2 ,33 27 24

4 16#(,`2|(~16)%.2^~4){D

Điều này dựa trên câu trả lời của Jan Dvorak . inca2 có thể thực thi điều này như là lỗi của ngày hôm qua. Kỹ thuật không hợp lệ vì ngôn ngữ được phát minh sau câu hỏi, nhưng phát minh ra ngôn ngữ là một phần mục tiêu của tôi khi đặt câu hỏi. Vì vậy, đây là một số hoàn vốn để biết ơn các câu trả lời khác. :)

Giải trình:

4 16#(,`2|(~16)%.2^~4){D
          (~16)               integers 0 .. 15 
                 2^~4         first 4 powers of 2: 1 2 4 8
          (~16)%.2^~4         division table
        2|                    mod 2 (and floor)
       `                      transpose
      ,                       ravel
     (               ){D      map to chars '0'..'9'
4 16#                         reshape to 4x16

Một số dấu ngoặc đơn là không cần thiết, nhưng rõ ràng có một số vấn đề còn lại với cách giải thích ngữ pháp của tôi. Và "ravel => map => reshape" thực sự vụng về: bản đồ cần phải thông minh hơn. Chỉnh sửa: bugfix cho phép loại bỏ parens.

Bao thanh toán chuyển đổi cơ sở thành một chức năng riêng biệt N:x|y%.x^~1+[]/x.y mang lại điều này19 Phiên bản 16 char.

4 16#(,`2N~16){D

Và trong khi tôi đang gian lận ở đây, tôi đã đi trước và biến nó thành một chức năng tích hợp. Nhưng, mặc dù đó là một hàm niladic (không yêu cầu đối số), không có hỗ trợ cho các hàm niladic và nó phải được cung cấp với một đối số giả.

inca2, 2

U0

Ngày 24/26

Phương pháp ngắn nhất là câu trả lời của grc được dịch sang Pyth mà tôi cảm thấy rẻ tiền nên tôi đã thực hiện phương pháp của riêng mình:

Của tôi: 26 ký tự

 mpbjk*/8dS*d[0 1)[1 2 4 8

grc: 24 ký tự

Fd[1 2 4 8)*/8d+*\0d*\1d

C ++ 130

Chuyển đổi hex thành nhị phân

#define B std::bitset<16>
#define C(x) cout<<x<<endl;
void main(){
B a(0xFF),b(0xF0F),c(0x3333),d(0x5555);
C(d)C(c)C(b)C(a)
}

Haskell (Lambdabot), 47 byte

unlines$reverse$transpose$replicateM 4['1','0']

Kinda gian lận vì nó sử dụng chuyển đổi từ Data.List và sao chépM từ Control.Monad, tuy nhiên cả hai đều được tải theo mặc định từ Lambdabot.

Ngoài ra, tôi chắc chắn có chỗ để cải thiện, chỉ muốn chia sẻ ý tưởng

Julia (39 byte)

Kịch bản thứ hai tôi từng viết ở Julia, phải thừa nhận tôi thích Julia, cô ấy là một con thú xinh đẹp.

hcat(map(x->collect(bin(x,4)),0:15)...)

Trả về

[0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 
 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 
 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]  

Giải trình:

• bin(x,4) - Chuyển đổi int thành số nguyên nhị phân với phần đệm thành 4 ký tự.
• collect(_) - Chia chuỗi thành mảng char.
• map(x->_,0:15) - Làm điều này cho 16 chữ số đầu tiên trong phạm vi.
• hcat(_...) - Splat và ghép theo chiều ngang thành một ma trận.

C 83 77 76 74 71

x;f(n){for(;x<4;x++,puts(""))for(n=0;n<16;)putchar(49-!(n++&(1<<x)));}

Khá đơn giản.

x;
f(n){
    for(;x<4;x++,puts(""))
        for(n=0;n<16;)
            putchar(49-!(n++&(1<<x)));
}

R, 53 41 byte

Bản dịch câu trả lời python của @ grc. Cạo 12 byte từ bản dịch ban đầu thông qua sử dụng rep()'s eachvà lengthtranh luận (và phù hợp với lập luận một phần), và bằng cách ghi nhớ rằng 0:1tương đương với c(0,1).

for(n in 2^(0:3))print(rep(0:1,e=n,l=16))

for(n in 2^(0:3))print(rep(c(rep(0,n),rep(1,n)),8/n))

Bạn cũng có thể thử bản dịch câu trả lời J của @ Gareth, đại loại như thế này (34 byte):

t(e1071::bincombinations(4))[4:1,]

Tuy nhiên, nó sử dụng một hàm không phải là một phần của cơ sở R và đưa ra một ma trận khó định dạng thành văn bản in chính xác như trong đặc tả.