Inspiré par A014486 .

Défi

Étant donné une entrée entière dans la base 10, construisez une représentation pour la forêt binaire correspondant à l'entrée. Les représentations incluent, mais sans s'y limiter, les tableaux et chaînes imbriqués.

Comment?

Convertissez l'entrée en binaire. 1s représentent des branches et 0s représentent des feuilles.

Pour rendre cela plus facile à comprendre, utilisons 834(1101000010 en binaire) comme exemple.

Nous commençons par le premier chiffre. Le premier chiffre est un 1, nous dessinons donc des branches:

\ /
 1

ou comme un tableau, {{1}}

Le chiffre suivant est 1, donc nous dessinons plus de branches (nous allons de gauche à droite):

\ /
 1
  \ /
    1

ou comme un tableau, {{1, {1}}}

Le chiffre suivant est 0, nous plaçons donc une feuille:

0
 \ /
  1
   \ /
     1

ou comme un tableau, {{1, {1, 0}}}

Le chiffre suivant est un 1, nous plaçons donc une branche:

     \ /
0 1
 \ /
   1
      \ /
         1

ou comme un tableau, {{1, {1, 0, {1}}}}

En répétant le processus, nous obtenons l'arbre suivant après le 8ème chiffre:

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

ou comme un tableau, {{1, {1, 0, {1, 0, 0}}, 0}}

Pour les chiffres restants, nous dessinons plus d'arbres:

Le 9ème chiffre est un 0, donc nous plaçons une feuille (aww, c'est une jeune pousse!)

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

ou comme un tableau, {{1, {1, 0, {1, 0, 0}}, 0}, 0}

Lorsque nous utilisons tous les chiffres, nous nous retrouvons avec ceci:

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

ou comme un tableau, {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0}}

Cela a l'air bizarre, nous avons donc ajouté un zéro pour terminer l'arborescence:

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

ou comme un tableau, {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0, 0}}

Notez que l'aplatissement du tableau donne le nombre d'origine en binaire, mais avec un zéro complété.

Critères

• La sortie doit clairement montrer la séparation des arbres et des branches (s'il ne s'agit pas d'un tableau imbriqué, veuillez expliquer votre format de sortie).
• L'extraction de tous les chiffres de la sortie doit être identique à la représentation binaire de l'entrée (avec le ou les zéros remplis du processus ci-dessus).

Cas de test

La sortie peut différer tant qu'elle répond aux critères.

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

Notation

Il s'agit de code-golf , donc les octets les plus bas gagnent!

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

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>

Définit une fonction fqui renvoie un tableau imbriqué. Le code HTML est juste pour les tests.

Befunge, 138 117 104 octets

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

Essayez-le en ligne!

Explication

La ligne 1 lit un nombre à partir de stdin, et la ligne 2 convertit ce nombre en une séquence binaire qu'elle stocke dans le champ de jeu sur la ligne 10. Les lignes 3 à 5 parcourent ensuite ces chiffres binaires, produisant la représentation d'arbre appropriée à mesure que chaque chiffre est traité. La pile Befunge est utilisée pour garder une trace de la profondeur dans l'arbre et de la quantité d'espace foliaire restant à chaque niveau afin que nous sachions quand créer une nouvelle branche. Les lignes 6 et 7 gèrent le 0rembourrage final pour remplir les feuilles vides.

Afin de jouer au golf autant que possible, j'ai supprimé les virgules de la sortie ainsi que les accolades externes. Cela n'a toujours pas battu la solution Mathematica, mais ça a été amusant d'essayer.

Si vous voulez voir à quoi il ressemblait avec le format de sortie détaillé original, j'ai enregistré une version antérieure du code ici (131 octets).

Mathematica, 167 161 octets

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

Fonction anonyme. Prend un nombre en entrée et renvoie une liste de nombres arbitrairement imbriqués en sortie. Sauts de ligne ajoutés pour plus de clarté. Utilise un mécanisme impliquant des continuations, mais je suis trop fatigué pour y penser plus longtemps.

Mathematica, 115 109 108 104 104 98 octets

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

Génère des messages d'erreur qui peuvent être ignorés en toute sécurité. Génère une forêt binaire. Il est légèrement différent de l'exemple de sortie car il 1s'agit d'un Head, et non du premier élément d'une liste. (par exemple 1[0, 0]au lieu de {1, 0, 0})

Version sans erreur (104 octets)

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

Explication

i=#~IntegerDigits~2;

Convertissez l'entrée en une liste de base 2. Conservez-le i.

f:=

SetDelay fles éléments suivants (évalués à chaque fappel):

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

Switch déclaration.

Tout d'abord, si iest vide, affichez 0. Sinon, sortez le premier élément de iet supprimez-le de la liste. Utilisez la sortie comme variable de contrôle.

Si la variable de contrôle est 0, sortie 0. Si c'est le cas 1, sortie 1[f, f](récursive).

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

Bien qu'il ine soit pas vide, continuez d'appeler f. Sortez le résultat, enveloppé avec List.

Exemple

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

Solution alternative (120 octets)

Identique à ma solution de 104 octets mais convertit la sortie au format donné dans la question.

(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 117 octets

Partiellement récursif, partiellement itératif. J'ai essayé d'utiliser un entier, mais l'arborescence commence par les bits les plus significatifs, donc je ne pense pas que cela en vaille la peine.

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

Essayez-le en ligne

Java 8, 367 octets

Golfé:

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

Non golfé:

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 octets (82 caractères)

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

Pour des raisons de golf, je me suis débarrassé des accolades extérieures et des virgules car elles ne sont pas nécessaires à la reconstruction des arbres.

Exemples de sorties:

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}

Explication:

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

Essayez-le avec l' interpréteur Javascript DUP en ligne sur quirkster.com ou clonez mon référentiel GitHub de mon interprète DUP écrit en Julia.