_{Ini secara tangensial terkait dengan pencarian saya untuk menciptakan bahasa pemrograman esoterik .}

Tabel angka biner 0 .. 15 dapat digunakan untuk mengimplementasikan Fungsi Biner Universal menggunakan operasi pengindeksan. Diberikan dua input 1-bit X dan Y, semua 16 fungsi yang mungkin dapat dikodekan dalam 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

Jadi set 16 fungsi ini dapat diterapkan ke input biner sebagai fungsi

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

atau

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

atau dengan pengindeksan atau partisi matriks.

Akan bermanfaat untuk mengetahui cara yang paling ringkas untuk mewakili atau menghasilkan tabel nilai sedemikian untuk bahasa apa pun yang mungkin dibangun di atas jenis operasi biner ini.

Target:

Hasilkan keluaran teks persis ini:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

Itu dia! Kemenangan kode terpendek.

J, 10 (13?) Karakter

|.|:#:i.16

Daftar nomor:

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

ke biner:

   #: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

Mengubah urutan:

   |:#: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

Membalikkan:

   |.|:#: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

Apakah kita perlu menghapus spasi? Melihat jawaban J lain tampaknya kita sehingga kita harus menambahkan 3 karakter dan meminjam 1":dari jawaban Jan ini .

Python 2, 40

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

APL (14)

Dengan asumsi ⎕IO=0(itu adalah pengaturan):

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

Penjelasan:

• ⍳16: angka [0,16)
• (4⍴2)⊤: menyandikan setiap angka dalam basis 2 menggunakan 4 digit
• ⊖: reverse horisontal (sehingga MSB berakhir di atas)
• ⎕D[... ]: pilih nilai-nilai ini dari ⎕Dyang merupakan string 0123456789. (Matriks numerik ditampilkan dengan spasi di antara nilai-nilai, matriks karakter tidak. Jadi ini mengubah setiap bit numerik ke salah satu karakter '0' '1').

Jelly , 42 7 byte (tidak bersaing)

⁴ḶBUz0Y

Cobalah online!

Terima kasih kepada Dennis untuk bantuannya. Inilah pesan pertama, inilah yang terakhir (diskusi lain juga terjadi). Dengan bantuannya, saya tampaknya (hampir) mendapatkan skor kuadrat.

/// , 51 byte

Cobalah online

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

GolfScript ( 18 17 15 karakter)

(Dengan terima kasih kepada Howard)

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

Saya tidak mengerti mengapa 10-char

16,zip{n}/

tidak bekerja; Saya menduga bahwa bug dalam interpreter standar menghasilkan tipe yang tidak didukung pada stack.

Alternatif 18 karakter yang saya mengerti sepenuhnya adalah:

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

Pendekatan yang lebih matematis sedikit lebih lama, pada 28 karakter:

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

Banyak dari itu untuk konversi basis dan zero-padding. Tanpa itu, turun menjadi 19 karakter,

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

dengan output

21845
13107
3855
255

CJam - 16

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

Kode java yang setara (sebagai penjelasan):

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":"" 

Untuk menggunakan ini, hubungi

s(255,8)

Bitshift!
Dan juga XOR dan sedikit rekursi.

Hal pertama yang perlu diperhatikan adalah bahwa jika kita mengambil garis apa pun dan Anda menggesernya (# dari 0 terus menerus) / 2, kita mendapatkan XOR bagus untuk mendapatkan baris berikutnya.

Sebagai contoh,

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

XOR bitwise ini memberi kita

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

yang merupakan baris berikutnya (baris 3).
Menerapkan proses yang sama untuk saluran 3, bergeser 2 ke kiri dan kami ...

0000111100001111
0011110000111100

XOR'ed memberi

0011001100110011

yaitu baris 2.
Perhatikan bahwa jumlah yang kita alihkan menjadi separuh setiap kali.
Sekarang kita cukup memanggil fungsi ini secara rekursif, dengan 2 argumen. Nilai integer dari baris ini, dan N, yang merupakan seberapa banyak kita perlu bergeser. Ketika kita melakukan berulang hanya lulus dalam nilai XOR'ed bergeser dan n / 2.

"0".repeat(n)

adalah untuk memasukkan 0 ke awal setiap baris karena toString mengeluarkan 0 yang terkemuka.

J, 21 karakter

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

• i.16 adalah daftar 0..15
• 2^i.4 adalah daftar (1,2,4,8)
• %~/ menghasilkan tabel pembagian di mana argumen kiri membentuk baris tetapi merupakan argumen yang tepat untuk pembagian
• 2| menghitung sisanya setelah membagi [setiap sel] dengan dua
• <. lantai yang bernilai 0 atau 1
• 1": memformat tabel dengan satu karakter per sel

GolfScript, 19 karakter

Pendekatan GolfScript lainnya

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

Ruby (44)

Membosankan dan panjang: Hanya mencetak representasi biner 0-angka dari angka-angka.

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

Nota bene 108 177 126 77 74 70

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

Membalikkan nilai untuk metode mod- off yang lebih sederhana .

151 131 119

Menerapkan pendekatan APL- is lebih banyak . sunting: penggantian talenan string dan ritsleting dengan pengindeksan dan for-loop.

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

Bertakuk:

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

Menerapkan kembali fungsi yang digunakan dalam jawaban J yang mengarah ke ini (dengan banyak kode dukungan ).

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

idi sini adalah vektor berbasis 1 yang dijelaskan dalam Fungsi Dasar Iverson , maka -1 ... +untuk menghasilkan 0 .. 15.

Perl (36 +1)

+1 untuk say, seperti biasa. dobel 0bukan kesalahan ketik :)

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

JavaScript (ECMA6), 108

Mencoba pendekatan yang berbeda di sini. Meskipun didorong untuk menggunakan operator biner, saya membiarkan diri saya untuk mengirimkan solusi ini karena tantangannya juga kolmogorov-kompleksitas dan saya berpikir - bagaimana saya bisa mengurangi jumlah kode yang mewakili nilai-nilai itu ...? Basa .

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

(Line break untuk kenyamanan).

Sayang sekali saya harus mengacaukan padding dengan angka nol di depan, tetapi poin dari kode ini hanya mewakili hasil biner target pada Basis 36, yang merupakan gut, a43, 2z3, 73nilai - nilai itu.

Catatan: Saya menyadari itu tidak akan mendekati jawaban yang menang, tetapi hanya demi ide ...

Sprects , 44 byte

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

Jawaban Cedric diangkut ke Sprects.

MATL ( non-bersaing ), 8 byte

16:qYB!P

Cobalah online!

Penjelasan

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 ( non-bersaing ), 10 9 byte

Terima kasih kepada @ Dennis untuk 1 byte off!

Y4m*zW%N*

Cobalah online!

Penjelasan

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

Membangun string secara rekursif.

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

Bagaimana itu bekerja

Rekursi ini didasarkan pada fakta bahwa pola dibuat dari representasi biner vertikal dari camilan 0x0 hingga 0xF:

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

Oleh karena itu, setiap posisi (X, Y) dalam pola ini dapat dinyatakan sebagai Y-th bit dari X: X & (1 << Y). Kami juga dapat mengisolasi bit ini dengan: (X >> Y) & 1. Daripada melacak X dan Y, kita iterate pada variabel tunggal nmulai dari 0 sampai 63. Jadi, rumus menjadi: (n >> (n >> 4)) & 1. Sebenarnya lebih mudah untuk beralih dari 63 ke 0, jadi string dibuat dalam urutan terbalik. Dengan kata lain, karakter n-1 ditambahkan di sebelah kiri karakter n .

Sebagai catatan, rekursi tidak membawa apa pun di sini kecuali kode yang lebih pendek.

Tanpa linebreak, kodenya panjangnya 35 byte:

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

Kami membutuhkan 17 byte lagi untuk menyisipkan linebreak. Ini bisa dipersingkat menjadi 14 byte jika linebreak terkemuka dapat diterima.

Demo

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

console.log(f());

Bash + coreutils, 65 byte

Bukan yang terpendek, tapi juga yang terpanjang:

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

(Karakter terakhir adalah spasi)

Cobalah online .

NARS2000 APL, 22

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

Berasal dari jawaban APL marinus, yang sepertinya tidak bekerja pada NARS2000.

Hasilkan vektor

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

Ubah ke berbasis nol

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

Hasilkan bentuk untuk disandikan

      (4⍴2)
2 2 2 2

Menyandi

      (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

Sesuaikan untuk pengindeksan berbasis 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

Membalikkan poros utama

      ⊖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

Indeks

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

C, 73 karakter

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

Ini hanyalah solusi umum untuk menghasilkan 64 bit dalam empat blok 16-bit; Anda hanya perlu mengubah nomor 0xFF0F0F33335555untuk menampilkan urutan bit lainnya.

disederhanakan & ungolfed:

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

Astaga, 73 karakter! Aku tidak bisa karena cinta tuhan mendapatkan ini lebih kecil.

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

Bagian sedih yang sebenarnya tentang ini adalah bahwa jika Anda menggemakan output menggunakan bash, Anda hanya perlu 74 karakter.

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

Ini berdasarkan jawaban Jan Dvorak . inca2 dapat menjalankan ini pada perbaikan bug kemarin. Secara teknis tidak valid karena bahasa ditemukan setelah pertanyaan, tetapi penemuan bahasa adalah bagian dari tujuan saya dalam mengajukan pertanyaan. Jadi, inilah balasannya untuk jawaban yang lain. :)

Penjelasan:

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

Beberapa tanda kurung seharusnya tidak perlu, tetapi tampaknya ada beberapa masalah yang tersisa dengan interpretasi saya tentang tata bahasa. Dan "ravel => map => membentuk kembali" benar-benar canggung: peta harus lebih pintar. Sunting: perbaikan bug memungkinkan penghapusan parens.

Anjak konversi basis menjadi fungsi terpisah N:x|y%.x^~1+[]/x.ymenghasilkan ini19 16 versi char.

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

Dan sementara saya curang di sini, saya sudah maju dan menjadikan ini fungsi bawaan. Tapi, meskipun itu fungsi niladik (tidak memerlukan argumen), tidak ada dukungan untuk fungsi niladik, dan itu harus dilengkapi dengan argumen dummy.

inca2, 2

U0

Pyth 24/26

Metode terpendek adalah jawaban grc yang diterjemahkan ke Pyth yang menurut saya murah, jadi saya lakukan metode saya sendiri:

Milik saya: 26 karakter

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

grc's: 24 karakter

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

C ++ 130

Mengubah hex menjadi biner

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

Agak curang karena menggunakan transpose dari Data.List dan replicateM dari Control.Monad, namun keduanya dimuat secara default dari Lambdabot.

Juga, saya yakin ada ruang untuk perbaikan, hanya ingin berbagi ide

Julia (39 Bytes)

Naskah kedua yang pernah saya tulis dalam Julia, harus mengakui bahwa saya menyukai Julia, dia binatang buas yang cantik.

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

Kembali

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

Penjelasan:

• bin(x,4) - Konversi int ke biner integer dengan padding hingga 4 karakter.
• collect(_) - Split string menjadi array char.
• map(x->_,0:15) - Lakukan ini selama 16 digit pertama dalam kisaran.
• hcat(_...) - Gambar percikan dan mendatar secara horizontal menjadi sebuah matriks.

C 83 77 76 74 71

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

Cukup mudah.

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

R, 53 41 byte

Terjemahan dari jawaban python @ grc Memotong 12 byte dari terjemahan asli melalui penggunaan rep()'s eachdan lengthargumen (dan pencocokan argumen parsial), dan dengan mengingat bahwa 0:1itu setara dengan 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))

Anda juga dapat mencoba terjemahan dari @ Gareth's J answer, kira-kira seperti ini (34 byte):

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

Namun, ia menggunakan fungsi yang bukan bagian dari basis R, dan mengeluarkan matriks yang sulit untuk diformat menjadi teks yang dicetak persis seperti dalam spesifikasi.