Inspiriert von A014486 .

Herausforderung

Erstellen Sie bei einer Ganzzahleingabe in Basis 10 eine Darstellung für den Binärwald, der der Eingabe entspricht. Darstellungen umfassen, ohne darauf beschränkt zu sein, verschachtelte Arrays und Zeichenfolgen.

Wie?

Konvertieren Sie die Eingabe in eine Binärdatei. 1s stehen für Zweige und 0s für Blätter.

Zum besseren Verständnis verwenden 834wir als Beispiel (1101000010 in binär).

Wir beginnen mit der ersten Ziffer. Die erste Ziffer ist a 1, also zeichnen wir Zweige:

\ /
 1

oder als Array, {{1}}

Die nächste Ziffer ist 1, also zeichnen wir mehr Zweige (wir gehen von links nach rechts):

\ /
 1
  \ /
    1

oder als Array, {{1, {1}}}

Die nächste Ziffer ist 0, also platzieren wir ein Blatt:

0
 \ /
  1
   \ /
     1

oder als Array, {{1, {1, 0}}}

Die nächste Ziffer ist a 1, also platzieren wir einen Zweig:

     \ /
0 1
 \ /
   1
      \ /
         1

oder als Array, {{1, {1, 0, {1}}}}

Wenn wir den Vorgang wiederholen, erhalten wir nach der achten Ziffer den folgenden Baum:

    0 0
     \ /
0 1
 \ /
   1 0
      \ /
         1

oder als Array, {{1, {1, 0, {1, 0, 0}}, 0}}

Für die restlichen Ziffern zeichnen wir weitere Bäume:

Die 9. Ziffer ist a 0, also platzieren wir ein Blatt (aww, es ist ein junger Trieb!)

    0 0
     \ /
0 1
 \ /
   1 0
      \ /
         1 0

oder als Array, {{1, {1, 0, {1, 0, 0}}, 0}, 0}

Wenn wir alle Ziffern verwenden, erhalten wir Folgendes:

    0 0
     \ /
0 1
 \ /
   100
      \ / \ /
         1 0 1

oder als Array, {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0}}

Das sieht komisch aus, also füllen wir eine Null auf, um den Baum zu vervollständigen:

    0 0
     \ /
0 1
 \ /
   1 0 0 0
      \ / \ /
         1 0 1

oder als Array, {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0, 0}}

Beachten Sie, dass die Abflachung des Arrays die ursprüngliche Zahl in binärer Form ergibt, jedoch mit einer aufgefüllten Null.

Kriterien

• Die Ausgabe muss deutlich die Trennung der Bäume und Zweige zeigen (wenn es sich nicht um ein verschachteltes Array handelt, erläutern Sie bitte Ihr Ausgabeformat).
• Das Extrahieren aller Ziffern aus der Ausgabe muss mit der binären Darstellung der Eingabe identisch sein (mit den aufgefüllten Nullen aus dem obigen Prozess).

Testfälle

Die Ausgabe kann unterschiedlich sein, solange sie die Kriterien erfüllt.

0 -> {0}
1 -> {{1, 0, 0}}
44 -> {{1, 0, {1, {1, 0, 0}, 0}}}
63 -> {{1, {1, {1, {1, {1, {1, 0, 0}, 0}, 0}, 0}, 0}, 0}}
404 -> {{1, {1, 0, 0}, {1, 0, {1, 0, 0}}}
1337 -> {{1, 0, {1, 0, 0}}, {1, {1, {1, 0, 0}, {1, 0, 0}}, 0}}

Wertung

Das ist Code-Golf , also gewinnt das niedrigste Byte!

JavaScript (ES6), 96 89 80 79 74 73 Byte

f=($,_=~Math.log2($))=>0>_?[(g=f=>$&1<<~_++&&[1,g(),g()])(),...f($,_)]:[]

<input type="number" value="1337" oninput="document.querySelector('#x').innerHTML=JSON.stringify(f(+this.value))"/><br/><pre id="x"></pre>

Definiert eine Funktion f, die ein verschachteltes Array zurückgibt. Der HTML-Code dient nur zu Testzwecken.

Befunge, 138 117 104 Bytes

p&1v
%2:_v#:/2p9p00+1:g00
3\9g<>$\:!v!:<
9g!v ^,"}"_1-\1-:
"0"_2\"1{",,:|:,
`#@_\:#v_"}",>$\:8
,"0":-1<^

Probieren Sie es online!

Erläuterung

Zeile 1 liest eine Zahl aus stdin und Zeile 2 konvertiert diese Zahl in eine Binärsequenz, die in Zeile 10 im Spielfeld gespeichert wird. Die Zeilen 3 bis 5 durchlaufen dann diese Binärziffern und geben die entsprechende Baumdarstellung aus, wenn jede Ziffer verarbeitet wird. Der Befunge-Stapel wird verwendet, um die Tiefe des Baums und den auf jeder Ebene verbleibenden Blattraum zu verfolgen, damit wir wissen, wann ein neuer Zweig erstellt werden muss. In den Zeilen 6 und 7 wird die endgültige 0Polsterung ausgeführt, um leere Blätter aufzufüllen.

Um so viel wie möglich Golf zu spielen, entfernte ich die Kommas von der Ausgabe sowie die äußeren Klammern. Dies hat die Mathematica-Lösung immer noch nicht übertroffen, aber es hat Spaß gemacht, es zu versuchen.

Wenn Sie sehen wollen , wie es mit dem ursprünglichen ausführlichen Ausgabeformat sah, sparte ich eine frühere Version des Codes hier (131 Bytes).

Mathematica, 167 161 Bytes

b=Append;a=If[#&@@#>0,a[Rest@#~b~0,a[#,#3[#,{1,#4,#2},##5]&,#3,#2,##4]&,#2,##3],
#2[Rest@#~b~0,0,##3]]&;a[#~IntegerDigits~2,If[c=#3~b~#2;Tr@#>0,a[#,#0,c],c]&,
{}]&

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine willkürlich verschachtelte Liste von Zahlen als Ausgabe zurück. Zeilenumbrüche zur Verdeutlichung hinzugefügt. Benutzt einen Mechanismus mit Fortsetzungen, aber ich bin zu müde, um länger darüber nachzudenken.

Mathematica, 115 109 108 104 98 Bytes

(i=#~IntegerDigits~2;f:=Switch[If[i=={},0,i={##2};#]&@@i,0,0,1,f~1~f];NestWhileList[f&,f,i!={}&])&

Erzeugt Fehlermeldungen, die ignoriert werden können. Gibt eine binäre Gesamtstruktur aus. Es unterscheidet sich geringfügig von der Beispielausgabe, da 1es sich Headnicht um das erste Element einer Liste handelt. (zB 1[0, 0]statt {1, 0, 0})

Fehlerfreie Version (104 Bytes)

(i=#~IntegerDigits~2;f:=Switch[If[i=={},i={0}];(i={##2};#)&@@i,0,0,1,f~1~f];NestWhileList[f&,f,i!={}&])&

Erläuterung

i=#~IntegerDigits~2;

Konvertieren Sie die Eingabe in eine Basis-2-Liste. Speichern Sie es in i.

f:=

SetDelay fFolgendes (wird immer dann ausgewertet, wenn fes aufgerufen wird):

Switch[If[i=={},0,i={##2};#]&@@i,0,0,1,f~1~f]

Switch Aussage.

Erstens, wenn ileer, wird ausgegeben 0. Wenn nicht, geben Sie das erste Element von aus iund löschen Sie es aus der Liste. Verwenden Sie den Ausgang als Steuervariable.

Wenn die Steuervariable ist 0, wird ausgegeben 0. Wenn ja 1, Ausgabe 1[f, f](rekursiv).

NestWhileList[f&,f,i!={}&]

Während inicht leer ist, ruf weiter an f. Ausgabe des Ergebnisses, verpackt mit List.

Beispiel

(i=#~IntegerDigits~2;f:=Switch[If[i=={},0,i={##2};#]&@@i,0,0,1,f~1~f];NestWhileList[f&,f,i!={}&])&[1337]

{1[0, 1[0, 0]], 1[1[1[0, 0], 1[0, 0]], 0]}

Alternative Lösung (120 Bytes)

Identisch mit meiner 104-Byte-Lösung, konvertiert aber die Ausgabe in das in der Frage angegebene Format.

(i=#~IntegerDigits~2;f:=Switch[If[i=={},i={0}];(i={##2};#)&@@i,0,0,1,f~1~f];NestWhileList[f&,f,i!={}&]//.1[a__]:>{1,a})&

Python 2, 133 118 117 Bytes

Teilweise rekursiv, teilweise iterativ. Ich habe versucht, eine Ganzzahl zu verwenden, aber der Baum beginnt mit den höchstwertigen Bits, daher denke ich, dass es sich nicht lohnt.

def t():global b;a=b[:1];b=b[1:];return a and'0'<a and[1,t(),t()]or 0
b=bin(input())[2:]
L=[]
while b:L+=t(),
print L

Probieren Sie es online aus

Java 8, 367 Bytes

Golf gespielt:

class f{static String r="";static int p=0;static void g(char[]s,int k){if(p>=s.length||s[p]=='0'){r+="0";p++;return;}else{r+="{1";p++;g(s,k+1);g(s,k+1);r+="}";}if(k==0&&p<s.length)g(s,0);}public static void main(String[]a){java.util.Scanner q=new java.util.Scanner(System.in);r+="{";g(Integer.toBinaryString(q.nextInt()).toCharArray(),0);r+="}";System.out.print(r);}}

Ungolfed:

class f{
    static String r="";
    static int p=0;
    static void g(char[]s,int k){
        // if there's empty space in last tree or current character is a 0
        if(p>=s.length || s[p]=='0'){
            r+="0";
            p++;
            return;
        }
        // if current character is a 1
        else{
            r+="{1";
            p++;
            // left branch
            g(s,k+1);
            // right branch
            g(s,k+1);
            r+="}";
        }
        // if they're still trees that can be added
        if(k==0 && p<s.length)g(s,0);
    }
    public static void main(String[]a){
        java.util.Scanner q=new java.util.Scanner(System.in);
        r+="{";
        g(Integer.toBinaryString(q.nextInt()).toCharArray(),0);
        r+="}";
        System.out.print(r);
    }
}

DUP , 84 Bytes (82 Zeichen)

0[`48-$1_>][\10*+]#%1b:[$1>][2/b;1+b:]#[['{,1.b;1-b:FF'},][0.b;1-b:]?]⇒F[b;0>][F]#

Aus Golfgründen habe ich die äußeren geschweiften Klammern und die Kommas entfernt, da sie für die Rekonstruktion der Bäume nicht erforderlich sind.

Beispielausgaben:

0      → 0
1      → {100}
44     → {10{1{100}0}}
63     → {1{1{1{1{1{100}0}0}0}0}0}
404    → {1{100}{10{100}}}
1023   → {1{1{1{1{1{1{1{1{1{100}0}0}0}0}0}0}0}0}0}
1024   → {100}00000000
1025   → {100}0000000{100}
1026   → {100}000000{100}
1027   → {100}000000{1{100}0}
1028   → {100}00000{100}
1337   → {10{100}}{1{1{100}{100}}0}
4274937288 → {1{1{1{1{1{1{10{1{100}{1{1{100}{10{1{1{10{1{1{100}{100}}0}}0}0}}}0}}}0}0}0}0}0}0}
4294967297 → {100}00000000000000000000000000000{100}

Erläuterung:

0[`48-$1_>][\10*+]#           While loop to read in the characters and convert them into a
                              base-10 integer.
0                             Push 0 (temporary value)
 [`48-$0>]       #            While input character-48 (digit)>-1
          [     ]
           \                      Swap top values
            10                    Push 10
              *                   Multiply (temporary value by 10)
               +                  Add to input value
%                                 Pop stack (EOL)
1b:                           Variable b=1 (bit count)
[$1>][2/b;1+b:]#              While loop to convert the number to base-2 digits on the
                              data stack, MSB on top. Each iteration increments bit count b.
[$1>]          #              While (DUP>1)
     [        ]#
      2                           Push 2
       /                          MOD/DIV (pushes both mod and div on the stack)
        b;1+b:                    Fetch b, increment, store b


[['{,1.b;1-b:FF'},][0.b;1-b:]?]⇒F     
[                             ]⇒F     Define operator F:
                                      pop top stack value
 [                ]          ?        if value != 0:
  '{,1.                                   print '{1'
       b;1-b:                             fetch b, decrement b, store b
             F                            execute operator F
              F                           execute operator F again
               '},                        print '}'
                   [        ]?        if value == 0:
                    0.                    print '0'
                      b;1-b:              fetch b, decrement b, store b
[b;0>][F]#
[b;0>]   #                            While (fetch b, b>0==true)
      [F]#                                execute operator F

Probieren Sie es mit dem Online- Javascript-DUP-Interpreter auf quirkster.com aus oder klonen Sie mein GitHub-Repository meines in Julia geschriebenen DUP-Interpreters.