_{Jest to stycznie związane z moim dążeniem do wynalezienia ezoterycznego języka programowania .}

Tabela liczb binarnych 0 .. 15 może być wykorzystana do implementacji Universal Binary Function przy użyciu operacji indeksowania. Biorąc pod uwagę dwa 1-bitowe wejścia X i Y, wszystkie 16 możliwych funkcji można zakodować w 4-bitowym kodzie operacyjnym.

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

Tak więc ten zestaw 16 funkcji można zastosować do wejść binarnych jako funkcję

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

lub

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

lub z indeksowaniem lub partycjonowaniem macierzy.

Przydatna będzie znajomość najbardziej kompaktowego sposobu reprezentowania lub generowania takiej tabeli wartości dla dowolnych języków, które można zbudować na tego typu operacji binarnej.

Cel:

Wygeneruj ten dokładny wynik tekstowy:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

Otóż ​​to! Zwycięża najkrótszy kod.

J, 10 (13?) Znaków

|.|:#:i.16

Lista numerów:

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

do binarnego:

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

Transponować:

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

Rewers:

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

Czy musimy usunąć spacje? Patrząc na drugą odpowiedź J, wydaje się, że to robimy, więc będziemy musieli dodać 3 znaki i pożyczyć odpowiedź 1":od Jana .

Python 2, 40

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

APL (14)

Zakładając ⎕IO=0(to ustawienie):

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

Wyjaśnienie:

• ⍳16: liczby [0,16)
• (4⍴2)⊤: zakoduj każdy numer w bazie 2 za pomocą 4 cyfr
• ⊖: rewers poziomy (więc MSB kończy się na górze)
• ⎕D[... ]: wybierz te wartości, z ⎕Dktórych jest ciąg 0123456789. (Macierz numeryczna jest wyświetlana ze spacjami między wartościami, matryca znaków nie. Więc to konwertuje każdy bit numeryczny na jeden z znaków '0' '1').

Galaretka , 42 7 bajtów (niekonkurencyjna)

⁴ḶBUz0Y

Wypróbuj online!

Dzięki Dennisowi za pomoc. Oto pierwsza wiadomość, tutaj ostatnia (odbyły się również inne dyskusje). Z jego pomocą najwyraźniej (prawie) zrootowałem wynik.

/// , 51 bajtów

Wypróbuj online

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

GolfScript ( 18 17 15 znaków)

(Dzięki dzięki Howardowi)

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

Nie rozumiem, dlaczego 10-char

16,zip{n}/

nie działa; Podejrzewam, że błąd standardowego interpretera powoduje nieobsługiwane typy na stosie.

Alternatywą dla 18 znaków, które w pełni rozumiem, jest:

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

Bardziej matematyczne podejście jest nieco dłuższe, przy 28 znakach:

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

Wiele z nich dotyczy konwersji podstawowej i zerowania. Bez nich spada do 19 znaków,

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

z wyjściem

21845
13107
3855
255

CJam - 16

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

Równoważny kod Java (jako wyjaśnienie):

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

Aby z tego skorzystać, zadzwoń

s(255,8)

Bitshift!
A także XOR i trochę rekurencji.

Pierwszą rzeczą, na którą należy zwrócić uwagę, jest to, że jeśli weźmiemy jakąkolwiek linię i przesuniemy ją (# ciągłych zer) / 2 w lewo, otrzymamy niezły XOR, aby uzyskać następną linię w górę.

Na przykład,

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

XOR te bitowe dają nam

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

która jest następną linią w górę (linia 3).
Stosując ten sam proces dla linii 3, przesuń 2 w lewo i otrzymamy ...

0000111100001111
0011110000111100

XOR'ed daje

0011001100110011

czyli wiersz 2.
Zauważ, że kwota, którą przesuwamy za każdym razem o połowę.
Teraz po prostu wywołujemy tę funkcję rekurencyjnie, z 2 argumentami. Wartość całkowita tej linii oraz N, czyli o ile musimy przesunąć. Kiedy wykonujemy rekurencję, po prostu podaj przesuniętą wartość XOR i n / 2.

"0".repeat(n)

polega na wstawianiu zer na początku każdej linii, ponieważ toString usuwa początkowe 0.

J, 21 znaków

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

• i.16 to lista 0..15
• 2^i.4 jest listą (1,2,4,8)
• %~/ tworzy tabelę podziałów, w której lewy argument tworzy wiersze, ale jest prawym argumentem do dzielenia
• 2| oblicza resztę po podzieleniu [każdej komórki] przez dwa
• <. podłogi o wartości 0 lub 1
• 1": formatuje tabelę za pomocą jednego znaku na komórkę

GolfScript, 19 znaków

Kolejne podejście do GolfScript

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

Rubin (44)

Nudne i długie: wystarczy wydrukować binarne reprezentacje liczb wypełnione zerami.

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

Postscriptum 108 177 126 77 74 70

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

Odwrócono wartości dla prostszej metody mod- off.

151 131 119

Stosując podejście bardziej APL . edycja: zastąpiono przerywanie ciągów i kompresowanie tablic indeksowaniem i pętlami 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

Zębaty:

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

Reimplementacja funkcji użytych w zwycięskiej odpowiedzi J prowadzi do tego (z dużą ilością kodu pomocniczego ).

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

itutaj jest wektor oparty na 1, opisany w elementarnych funkcjach Iversona , stąd -1 ... +do wytworzenia 0 .. 15.

Perl (36 + 1)

+1 za say, jak zwykle. podwójne 0nie jest literówką :)

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

JavaScript (ECMA6), 108

Spróbuj tutaj innego podejścia. Mimo że zachęcano mnie do korzystania z operatorów binarnych, pozwoliłem sobie na przesłanie tego rozwiązania, ponieważ wyzwaniem jest także złożoność kolmogorowa i zastanawiałem się - jak mogę zmniejszyć ilość kodu reprezentującego te wartości ...? Bazy .

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

(Podział linii dla wygody).

Szkoda, że ​​musiałem zadzierać z wypełnianiem zerami wiodącymi, ale celem tego kodu jest po prostu reprezentowanie docelowego wyniku binarnego w bazie 36, które są dokładnie tymi gut, a43, 2z3, 73wartościami.

Uwaga: zdaję sobie sprawę, że nie będzie blisko zwycięskiej odpowiedzi, ale tylko ze względu na pomysł ...

Szpary , 44 bajty

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

Odpowiedź Cedrica została przeniesiona do Sprects.

MATL ( niekonkurencyjny ), 8 bajtów

16:qYB!P

Wypróbuj online!

Wyjaśnienie

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 ( niekonkurencyjny ), 10 9 bajtów

Dzięki @Dennis za 1 bajt off!

Y4m*zW%N*

Wypróbuj online!

Wyjaśnienie

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 bajtów

Tworzy ciąg rekurencyjnie.

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

Jak to działa

Ta rekurencja opiera się na fakcie, że wzorzec składa się z pionowej reprezentacji binarnej skórek od 0x0 do 0xF:

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

Dlatego, każde stanowisko (X, Y), w układ ten może być wyrażony jako Y-tego bitu X: X & (1 << Y). Możemy również izolowanie tego bitu z: (X >> Y) & 1. Zamiast śledzenie X i Y, możemy iterate na pojedynczej zmiennej nw zakresie od 0 do 63. Tak więc, wzór przyjmuje postać: (n >> (n >> 4)) & 1. W rzeczywistości łatwiej jest iterować od 63 do 0, więc łańcuch jest budowany w odwrotnej kolejności. Innymi słowy, znak n-1 jest dołączany na lewo od znaku n .

Na marginesie, rekurencja nie przynosi tu niczego oprócz krótszego kodu.

Bez podziałów liniowych kod ma długość 35 bajtów:

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

Potrzebujemy jeszcze 17 bajtów, aby wstawić podziały wierszy. Można to skrócić do 14 bajtów, jeśli dopuszczalny jest wiodący podział linii.

Próbny

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

console.log(f());

Bash + coreutils, 65 bajtów

Nie najkrótszy, ale też nie najdłuższy:

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

(Ostatnia postać to spacja)

Wypróbuj online .

NARS2000 APL, 22

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

Wywodzi się z odpowiedzi APL marinusa, która nie działa na NARS2000.

Generuj wektor

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

Zmień na zero

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

Wygeneruj kształt do kodowania

      (4⍴2)
2 2 2 2

Kodować

      (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

Dostosuj do indeksowania 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

Odwróć oś pierwotną

      ⊖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 znaki

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

Jest to tylko ogólne rozwiązanie do wysyłania 64 bitów w czterech 16-bitowych blokach; wystarczy zmienić liczbę, 0xFF0F0F33335555aby wyprowadzić inną sekwencję bitów.

uproszczony i nie golfowy:

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

Yikes, 73 znaki! Nie mogę, na miłość boską, zmniejszyć tego.

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

Naprawdę smutne jest to, że jeśli chcesz echa wyniku za pomocą bash, potrzebujesz tylko 74 znaków.

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

Jest to oparte na odpowiedzi Jana Dvoraka . inca2 jest w stanie wykonać to od wczorajszych poprawek błędów. Technicznie nieważne, ponieważ język został wymyślony po pytaniu, ale wymyślenie języka było częścią mojego celu postawienia pytania. Oto niektóre zwroty wdzięczności za inne odpowiedzi. :)

Wyjaśnienie:

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

Niektóre nawiasy powinny być niepotrzebne, ale najwyraźniej pozostały pewne problemy z moją interpretacją gramatyki. A „ravel => mapa => zmiana kształtu” jest naprawdę niezdarna: mapa musi być mądrzejsza. Edycja: poprawki błędów pozwalają na eliminację parens.

Faktyczne przekształcenie podstawy w osobną funkcję N:x|y%.x^~1+[]/x.ydaje to19 Wersja 16 znaków.

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

Mimo że i tak tutaj oszukuję, poszedłem do przodu i uczyniłem to funkcją wbudowaną. Ale chociaż jest to funkcja niladyczna (nie wymagająca argumentu), nie ma wsparcia dla funkcji niladycznych i musi być dostarczona z fikcyjnym argumentem.

inca2, 2

U0

Pyth 24/26

Najkrótszą metodą była odpowiedź grc przetłumaczona na Pyth, która moim zdaniem była tania, więc zrobiłem własną metodę:

Mój: 26 znaków

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

grc's: 24 znaki

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

C ++ 130

Konwertuje liczbę szesnastkową na dwójkową

#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 bajtów

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

Trochę cheaty, ponieważ używa transpozycji z Data.List i replicateM z Control.Monad, jednak oba są ładowane domyślnie z Lambdabot.

Jestem też pewien, że jest miejsce na ulepszenia, chciałem tylko podzielić się tym pomysłem

Julia (39 bajtów)

Drugi scenariusz, który napisałem w Julii, muszę przyznać, że lubię Julię, ona jest ładną bestią.

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

Zwroty

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

Wyjaśnienie:

• bin(x,4) - Konwertuj liczbę całkowitą na binarną z dopełnieniem do 4 znaków.
• collect(_) - Podziel ciąg znaków na tablicę znaków.
• map(x->_,0:15) - Zrób to dla pierwszych 16 cyfr z zakresu.
• hcat(_...) - Ikona i konkatenacja pozioma w matrycę.

do 83 77 76 74 71

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

Całkiem proste.

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

R, 53 41 bajtów

Tłumaczenie odpowiedzi python @ grc. Ogolił 12 bajtów z oryginalnego tłumaczenia dzięki zastosowaniu rep()„s eachi lengthargumentów (i częściowego dopasowania argument) i pamiętając, że 0:1jest równoważny 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))

Możesz także spróbować przetłumaczyć odpowiedź J @ Garetha, mniej więcej tak (34 bajty):

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

Wykorzystuje jednak funkcję, która nie jest częścią podstawy R, i wyświetla matrycę, którą trudno sformatować w dokładnie wydrukowany tekst, jak w specyfikacji.