Ispirato da A014486 .

Sfida

Dato un input intero in base 10, costruisci una rappresentazione per la foresta binaria corrispondente all'input. Le rappresentazioni includono, ma non sono limitate a, matrici e stringhe nidificate.

Come?

Converti l'input in binario. 1s rappresentano i rami e 0s rappresentano le foglie.

Per renderlo più facile da capire, usiamo 834(1101000010 in binario) come esempio.

Iniziamo con la prima cifra. La prima cifra è a 1, quindi disegniamo i rami:

\ /
 1

o come un array, {{1}}

La cifra successiva è 1, quindi disegniamo più rami (andiamo da sinistra a destra):

\ /
 1
  \ /
    1

o come un array, {{1, {1}}}

La cifra successiva è 0, quindi posizioniamo una foglia:

0
 \ /
  1
   \ /
     1

o come un array, {{1, {1, 0}}}

La cifra successiva è a 1, quindi posizioniamo un ramo:

     \ /
0 1
 \ /
   1
      \ /
         1

o come un array, {{1, {1, 0, {1}}}}

Ripetendo il processo, otteniamo il seguente albero dopo l'ottava cifra:

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

o come un array, {{1, {1, 0, {1, 0, 0}}, 0}}

Per le cifre rimanenti, disegniamo più alberi:

La nona cifra è una 0, quindi posizioniamo una foglia (aww, è un giovane germoglio!)

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

o come un array, {{1, {1, 0, {1, 0, 0}}, 0}, 0}

Quando usiamo tutte le cifre, finiamo con questo:

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

o come un array, {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0}}

Sembra strano, quindi inseriamo uno zero per completare l'albero:

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

o come un array, {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0, 0}}

Si noti che l'appiattimento dell'array produce il numero originale in binario, ma con uno zero imbottito.

criteri

• L'output deve mostrare chiaramente la separazione di alberi e rami (se non è un array nidificato, spiegare il formato di output).
• L'estrazione di tutte le cifre dall'output deve essere identica alla rappresentazione binaria dell'ingresso (con lo zero (i) imbottito del processo sopra).

Casi test

L'output può differire se soddisfa i criteri.

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

punteggio

Questo è code-golf , quindi vince il byte più basso!

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>

Definisce una funzione fche restituisce un array nidificato. Il codice HTML è solo per il test.

Befunge, 138 117 104 byte

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

Provalo online!

Spiegazione

La riga 1 legge un numero dallo stdin e la riga 2 converte quel numero in una sequenza binaria che memorizza nel campo di gioco sulla riga 10. Le righe da 3 a 5 quindi ripetono quelle cifre binarie, producendo la rappresentazione dell'albero appropriata mentre ogni cifra viene elaborata. Lo stack di Befunge viene utilizzato per tenere traccia della profondità dell'albero e della quantità di spazio foglia a ciascun livello in modo da sapere quando creare un nuovo ramo. Le righe 6 e 7 gestiscono l' 0imbottitura finale per riempire eventuali foglie vuote.

Per golfare il più possibile, ho rimosso le virgole dall'output e le parentesi esterne esterne. Questo non ha ancora battuto la soluzione Mathematica, ma è stato divertente provare.

Se si vuole vedere ciò che sembrava con il formato di output dettagliato originale, ho salvato una versione precedente del codice qui (131 byte).

Mathematica, 167 161 byte

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]&,
{}]&

Funzione anonima. Accetta un numero come input e restituisce un elenco di numeri nidificati arbitrariamente come output. Le interruzioni di riga sono state aggiunte per maggiore chiarezza. Utilizza alcuni meccanismi che comportano continuazioni, ma sono troppo stanco per pensarci ancora.

Mathematica, 115 109 108 104 98 byte

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

Genera messaggi di errore che possono essere tranquillamente ignorati. Emette una foresta binaria. È leggermente diverso dall'output di esempio perché 1è un Head, non il primo elemento di un elenco. (ad es. 1[0, 0]invece di {1, 0, 0})

Versione senza errori (104 byte)

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

Spiegazione

i=#~IntegerDigits~2;

Converti l'input in un elenco di base 2. Conservalo in i.

f:=

SetDelay fil seguente (valutato ogni volta che fviene chiamato):

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

Switch dichiarazione.

Innanzitutto, se iè vuoto, output 0. In caso contrario, genera il primo elemento di ie rilascialo dall'elenco. Utilizzare l'output come variabile di controllo.

Se la variabile di controllo è 0, output 0. Se lo è 1, output 1[f, f](ricorsivo).

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

Mentre inon è vuoto, continua a chiamare f. Stampa il risultato, avvolto con List.

Esempio

(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]}

Soluzione alternativa (120 byte)

Identico alla mia soluzione da 104 byte ma converte l'output nel formato indicato nella domanda.

(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 byte

Parzialmente ricorsivo, parzialmente iterativo. Ho provato a utilizzare un numero intero, ma l'albero inizia con i bit più significativi, quindi non credo ne valga la pena.

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

Provalo online

Java 8, 367 byte

golfed:

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 byte (82 caratteri)

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

Per motivi di golf, mi sono sbarazzato delle parentesi graffe esterne e delle virgole perché non sono necessarie per ricostruire gli alberi.

Esempi di output:

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}

Spiegazione:

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

Provalo con l' interprete DUP Javascript online su quirkster.com o clona il mio repository GitHub del mio interprete DUP scritto in Julia.