_{Dies hängt tangential mit meiner Suche nach einer esoterischen Programmiersprache zusammen .}

Eine Tabelle der Binärzahlen 0 .. 15 kann verwendet werden, um eine universelle Binärfunktion unter Verwendung von Indexierungsoperationen zu implementieren. Bei zwei 1-Bit-Eingängen X und Y können alle 16 möglichen Funktionen in einem 4-Bit-Opcode codiert werden.

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

Dieser Satz von 16 Funktionen kann also als Funktion auf Binäreingänge angewendet werden

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

oder

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

oder mit Indexierung oder Matrixpartitionierung.

Es ist nützlich, die kompakteste Methode zu kennen, um eine solche Wertetabelle für alle möglichen Sprachen darzustellen oder zu generieren, die auf dieser Art von Binäroperation aufbauen.

Das Ziel:

Generieren Sie genau diese Textausgabe:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

Das ist es! Kürzester Code gewinnt.

J, 10 (13?) Zeichen

|.|:#:i.16

Nummernliste:

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

zu binär:

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

Transponieren:

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

Umkehren:

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

Müssen wir die Leerzeichen entfernen? Wenn wir uns die andere Antwort ansehen, müssen wir 3 Zeichen hinzufügen und die Antwort1": von Jan ausleihen .

Python 2, 40

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

APL (14)

Vorausgesetzt ⎕IO=0(das ist eine Einstellung):

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

Erläuterung:

• ⍳16: Zahlen [0,16)
• (4⍴2)⊤: Kodieren Sie jede Zahl in Basis 2 mit 4 Ziffern
• ⊖: horizontale Umkehrung (so landet das MSB oben)
• ⎕D[... ]: Wählen Sie diese Werte aus, aus ⎕Ddenen die Zeichenfolge besteht 0123456789. (Eine numerische Matrix wird mit Leerzeichen zwischen den Werten angezeigt, eine Zeichenmatrix nicht. Dadurch wird jedes numerische Bit in eines der Zeichen konvertiert '0' '1'.)

Jelly , 42 7 Bytes (nicht konkurrierend)

⁴ḶBUz0Y

Probieren Sie es online!

Vielen Dank an Dennis für seine Hilfe. Hier ist die erste Nachricht, hier ist die letzte (andere Diskussionen haben auch stattgefunden). Mit seiner Hilfe habe ich die Partitur anscheinend (fast) verwurzelt.

/// , 51 Bytes

Probieren Sie es online aus

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

GolfScript ( 18 17 15 Zeichen)

(Mit Dank an Howard)

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

Ich verstehe nicht, warum die 10-Zeichen

16,zip{n}/

funktioniert nicht; Ich vermute, dass ein Fehler im Standardinterpreter zu nicht unterstützten Typen auf dem Stack führt.

Eine Alternative mit 18 Zeichen, die ich vollständig verstehe, ist:

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

Ein mathematischer Ansatz ist mit 28 Zeichen etwas länger:

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

Vieles davon ist für die Basisumwandlung und das Null-Auffüllen. Ohne diese sinkt es auf 19 Zeichen,

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

mit Ausgabe

21845
13107
3855
255

CJam - 16

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

Äquivalenter Java-Code (als Erklärung):

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

Rufen Sie dazu an

s(255,8)

Bitverschiebung!
Und auch XOR und ein bisschen Rekursion.

Das Erste, was wir bemerken müssen, ist, dass wir, wenn wir eine Zeile nehmen und Sie diese verschieben (Anzahl der fortlaufenden Nullen) / 2 nach links, ein nettes XOR erhalten, um die nächste Zeile zu bilden.

Beispielsweise,

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

XOR diese bitweise geben uns

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

Das ist die nächste Zeile (Zeile 3).
Wenden Sie den gleichen Prozess für Zeile 3 an, verschieben Sie 2 nach links und wir erhalten ...

0000111100001111
0011110000111100

XOR'ed gibt

0011001100110011

Das ist Zeile 2.
Beachten Sie, dass sich der Betrag, den wir verschieben, jedes Mal halbiert.
Jetzt rufen wir diese Funktion einfach rekursiv mit 2 Argumenten auf. Der ganzzahlige Wert dieser Zeile und N, um wie viel verschoben werden muss. Wenn wir rekursiv arbeiten, geben Sie einfach den verschobenen XOR-Wert und n / 2 ein.

"0".repeat(n)

ist, die Nullen an den Anfang jeder Zeile zu setzen, weil toString führende Nullen entfernt.

J, 21 Zeichen

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

• i.16 ist eine Liste von 0..15
• 2^i.4 ist eine Liste (1,2,4,8)
• %~/ Erzeugt die Tabelle der Unterteilungen, in der das linke Argument Zeilen bildet, aber das rechte Argument für die Unterteilung ist
• 2| berechnet den Rest nach dem Teilen [jeder Zelle] durch zwei
• <. Etagen, die den Wert 0 oder 1 haben
• 1": formatiert die Tabelle mit einem Zeichen pro Zelle

GolfScript, 19 Zeichen

Ein weiterer GolfScript-Ansatz

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

Rubin (44)

Langweilig und langweilig: Drucken Sie einfach die mit 0 aufgefüllten Binärdarstellungen der Zahlen.

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

Nachsatz 108 177 126 77 74 70

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

Vertauscht die Werte für eine einfachere Mod- Off-Methode.

151 131 119

Anwendung eines APL- ähnlichen Ansatzes. edit: String-Chopping und Array-Zipping wurden durch Indexing und For-Loops ersetzt.

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

Eingerückt:

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

Das erneute Implementieren der Funktionen, die in der erfolgreichen J-Antwort verwendet wurden, führt dazu (mit viel Support-Code ).

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

iHier ist ein 1-basierter Vektor in Iversons Elementarfunktionen beschrieben , daher der -1 ... +zu erzeugende 0 .. 15.

Perl (36 + 1)

+1 für saywie gewohnt. Das Double 0ist kein Tippfehler :)

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

JavaScript (ECMA6), 108

Ich versuche hier einen anderen Ansatz. Obwohl die Verwendung von Binäroperatoren empfohlen wurde , habe ich mir erlaubt, diese Lösung einzureichen, da die Herausforderung auch kolmogorov-komplex ist, und ich dachte: Wie kann ich die Menge des Codes reduzieren, der diese Werte darstellt? Grundlagen .

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

(Zeilenumbruch zur Vereinfachung).

Es ist eine Schande, dass ich mich mit dem Auffüllen mit führenden Nullen herumschlagen musste, aber der Punkt dieses Codes repräsentiert einfach das binäre Zielergebnis in Base 36, das genau das ist gut, a43, 2z3, 73 Werte sind.

Hinweis: Mir ist klar, dass es nicht annähernd die Gewinner-Antwort sein wird, sondern nur der Idee zuliebe ...

Korrigiert , 44 Bytes

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

Cedric's Antwort wurde auf Sprects portiert.

MATL ( nicht konkurrierend ), 8 Bytes

16:qYB!P

Probieren Sie es online!

Erläuterung

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 ( nicht konkurrierend ), 10 9 Bytes

Vielen Dank an @Dennis für 1 Byte!

Y4m*zW%N*

Probieren Sie es online!

Erläuterung

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

Erstellt die Zeichenfolge rekursiv.

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

Wie es funktioniert

Diese Rekursion basiert auf der Tatsache, dass das Muster aus der vertikalen Binärdarstellung der Halbbytes 0x0 bis 0xF besteht:

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

Daher kann jede Position (X, Y) in diesem Muster als das Y-te Bit von X: ausgedrückt werden X & (1 << Y). Wir können auch dieses Bit - Isolat mit: (X >> Y) & 1. Anstatt von X und Y, wir Iterierte auf eine einzige Variable die Verfolgung im nBereich von 0 bis 63. So wird die Formel: (n >> (n >> 4)) & 1. Es ist tatsächlich einfacher, von 63 auf 0 zu iterieren, sodass die Zeichenfolge in umgekehrter Reihenfolge erstellt wird. Mit anderen Worten, das Zeichen n-1 wird links vom Zeichen n angehängt .

Als Randnotiz bringt die Rekursion hier nichts außer kürzeren Code.

Ohne die Zeilenumbrüche ist der Code 35 Byte lang:

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

Wir brauchen 17 weitere Bytes, um die Zeilenumbrüche einzufügen. Dies kann auf 14 Byte verkürzt werden, wenn ein Zeilenumbruch zulässig ist.

Demo

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

console.log(f());

Bash + Coreutils, 65 Bytes

Nicht die kürzeste, aber auch nicht die längste:

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

(Das letzte Zeichen ist ein Leerzeichen)

Probieren Sie es online aus .

NARS2000 APL, 22

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

Abgeleitet von der APL-Antwort von Marinus, die auf NARS2000 nicht zu funktionieren scheint.

Vektor generieren

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

Wechseln Sie auf Nullbasis

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

Form für die Codierung generieren

      (4⍴2)
2 2 2 2

Kodieren

      (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

Passen Sie die 1-basierte Indizierung an

      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

Hauptachse umkehren

      ⊖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

Index

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

C 73 Zeichen

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

Dies ist nur eine allgemeine Lösung für die Ausgabe von 64 Bit in vier 16-Bit-Blöcken. Sie müssen nur die Nummer ändern0xFF0F0F33335555 um eine andere Bitfolge auszugeben.

vereinfacht & 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

Huch, 73 Zeichen! Ich kann es aus Liebe zu Gott nicht kleiner machen.

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

Das wirklich traurige daran ist, dass Sie nur 74 Zeichen benötigen, wenn Sie die Ausgabe mit bash wiedergeben würden.

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

Dies basiert auf der Antwort von Jan Dvorak . inca2 kann dies ab den Bugfixes von gestern ausführen. Technisch ungültig, da die Sprache nach der Frage erfunden wurde, aber Erfindung einer Sprache war ein Teil meines Ziels, die Frage zu stellen. Wir danken Ihnen für die anderen Antworten. :)

Erläuterung:

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

Einige der Klammern sollten unnötig sein, aber anscheinend gibt es noch einige Probleme mit meiner Interpretation der Grammatik. Und "ravel => map => reshape" ist wirklich umständlich: map muss schlauer sein. Edit: Bugfixes ermöglichen die Beseitigung von Parens.

Die Basenumwandlung in eine separate Funktion zu N:x|y%.x^~1+[]/x.yfaktorisieren, ergibt dies19 16 char version.

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

Und während ich hier sowieso betrüge, habe ich dies zu einer eingebauten Funktion gemacht. Aber auch wenn es eine ist niladic- Funktion handelt (für die kein Argument erforderlich ist), werden niladic-Funktionen nicht unterstützt, und es muss ein Dummy-Argument angegeben werden.

inca2, 2

U0

Pyth 24/26

Die kürzeste Methode war die Antwort von grc in Pyth übersetzte , die ich für billig hielt, also habe ich meine eigene Methode gemacht:

Meins: 26 Zeichen

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

grc's: 24 zeichen

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

C ++ 130

Konvertiert hexadezimal in binär

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

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

Ein bisschen schummelig, weil es transponiert von Data.List und replicateM verwendet von Control.Monad verwendet, jedoch werden beide standardmäßig von Lambdabot geladen.

Ich bin mir auch sicher, dass es Raum für Verbesserungen gibt, ich wollte nur die Idee teilen

Julia (39 Bytes)

Zweites Drehbuch, das ich jemals in Julia geschrieben habe, muss zugeben, dass ich Julia mag, sie ist ein hübsches Biest.

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

Kehrt zurück

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

Erläuterung:

• bin(x,4) - Konvertieren Sie int in eine binäre Ganzzahl mit einem Abstand von 4 Zeichen.
• collect(_) - String in char-Array aufteilen.
• map(x->_,0:15) - Tun Sie dies für die ersten 16 Stellen des Bereichs.
• hcat(_...) - Splat und horizontal zu einer Matrix verketten.

C 83 77 76 74 71

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

Ziemlich einfach.

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

R 53 41 Bytes

Eine Übersetzung von @ grcs Python-Antwort. 12 Bytes der ursprünglichen Übersetzung wurden durch Verwendung von rep()'s' eachund ' lengtharguments' (und partieller Argumentübereinstimmung) und durch Erinnerung daran, dass dies 0:1äquivalent zu ist, entfernt 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))

Sie können auch versuchen, eine Übersetzung von @ Gareths J-Antwort zu erstellen, etwa so (34 Bytes):

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

Es verwendet jedoch eine Funktion, die nicht Teil der Basis R ist, und gibt eine Matrix aus, die sich wie in der Spezifikation nur schwer in exakten gedruckten Text formatieren lässt.