A014486に触発されました。

チャレンジ

基数10の整数入力が与えられた場合、入力に対応するバイナリフォレストの表現を作成します。表現には、ネストされた配列と文字列が含まれますが、これらに限定されません。

どうやって？

入力をバイナリに変換します。1sは枝を表し、0sは葉を表します。

これを理解しやすくするために834、例として（バイナリで1101000010）を使用しましょう。

最初の数字から始めます。最初の数字は1なので、枝を描きます：

\ /
 1

または配列として、 {{1}}

次の数字は1なので、さらに枝を描画します（左から右に進みます）。

\ /
 1
  \ /
    1

または配列として、 {{1, {1}}}

次の数字は0なので、葉を配置します。

0
 \ /
  1
   \ /
     1

または配列として、 {{1, {1, 0}}}

次の桁は1なので、ブランチを配置します。

     \ /
0 1
 \ /
   1
      \ /
         1

または配列として、 {{1, {1, 0, {1}}}}

このプロセスを繰り返して、8桁目以降に次のツリーを取得します。

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

または配列として、 {{1, {1, 0, {1, 0, 0}}, 0}}

残りの数字については、さらに木を描画します。

9桁目はa 0なので、葉を置きます（aww、それは若い芽です！）

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

または配列として、 {{1, {1, 0, {1, 0, 0}}, 0}, 0}

すべての数字を使用すると、次のようになります。

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

または配列として、 {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0}}

それは奇妙に見えるので、ゼロを埋めてツリーを完成させます。

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

または配列として、 {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0, 0}}

配列を平坦化すると、元の数値がバイナリで得られますが、ゼロが埋め込まれます。

基準

• 出力は、ツリーとブランチの分離を明確に示す必要があります（ネストされた配列でない場合は、出力形式を説明してください）。
• 出力からすべての数字を抽出することは、入力のバイナリ表現と同じである必要があります（上記のプロセスでゼロが埋め込まれています）。

テストケース

基準を満たす限り、出力は異なる場合があります。

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

得点

これはcode-golfなので、最低バイトが勝ちです！

JavaScript（ES6）、96 89 80 79 74 73バイト

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>

fネストされた配列を返す関数を定義します。HTMLコードはテスト用です。

Befunge、138の 117 104バイト

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

オンラインでお試しください！

説明

1行目はstdinから数値を読み取り、2行目はその数値を10行目のプレイフィールドに格納するバイナリシーケンスに変換します。3行目から5行目までは、これらの2進数を反復処理し、各桁が処理されるたびに適切なツリー表現を出力します。Befungeスタックは、ツリーの深さと各レベルで残されたリーフスペースの量を追跡するために使用されるため、新しいブランチを作成するタイミングがわかります。6行目と7行目は、最後の0パディングを処理して空の葉を埋めます。

これをできる限りゴルフするために、出力からコンマと外部の外部ブレースを削除しました。これはまだMathematicaソリューションに勝るものではありませんが、試してみるのは楽しかったです。

元の詳細な出力形式でどのように見えるかを確認したい場合は、ここに以前のバージョンのコード（131バイト）を保存しました。

Mathematica、167バイト

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

匿名関数。入力として数値を受け取り、出力として任意にネストされた数値のリストを返します。明確にするために改行が追加されました。継続を伴う何らかのメカニズムを使用しますが、私はもうそれについて考えるにはあまりにも疲れています。

Mathematica、115 109 108 104 98バイト

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

安全に無視できるエラーメッセージを生成します。バイナリフォレストを出力します。リストの最初の要素ではなくであるため、サンプル出力と1は少し異なりHeadます。（例えば1[0, 0]代わりに{1, 0, 0}）

エラーのないバージョン（104バイト）

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

説明

i=#~IntegerDigits~2;

入力を基数2のリストに変換します。に保管しiます。

f:=

SetDelay f以下（f呼び出されるたびに評価）：

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

Switch ステートメント。

最初に、iが空の場合、output 0。そうでない場合は、の最初の要素を出力iし、リストから削除します。出力を制御変数として使用します。

制御変数がの場合0、出力します0。の場合1、出力1[f, f]（再帰的）。

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

iが空でない間、を呼び出し続けfます。でラップされた結果を出力しListます。

例

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

代替ソリューション（120バイト）

104バイトのソリューションと同じですが、出力を質問で指定された形式に変換します。

(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バイト

部分的に再帰的、部分的に反復的。整数を使ってみましたが、ツリーは最上位ビットから始まるので、それだけの価値はないと思います。

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

オンラインで試す

Java 8、367バイト

ゴルフ：

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

ゴルフをしていない：

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バイト（82文字）

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

ゴルフの理由で、木を再構成するのに必要ないため、外側の中括弧とコンマを取り除きました。

出力例：

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}

説明：

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

quirkster.comのオンラインJavascript DUPインタープリターで試してみるか、ジュリアで書かれたDUPインタープリターのGitHubリポジトリーを複製してください。