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 번째 숫자는입니다 0. 그래서 우리는 잎을 놓습니다.

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

또는 배열로 {{1, {1, 0, {1, 0, 0}}, 0}, 0}

모든 숫자를 사용하면 다음과 같이 끝납니다.

    0 0
     \ /
0 1
 \ /
   1,000
      \ / \ /
         10 1

또는 배열로 {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0}}

이상하게 보이므로 트리를 완성하기 위해 0을 채 웁니다.

    0 0
     \ /
0 1
 \ /
   1,000
      \ / \ /
         10 1

또는 배열로 {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0, 0}}

배열을 평탄화하면 원래 숫자가 2 진수로 표시되지만 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 이므로 가장 낮은 바이트가 이깁니다!

자바 스크립트 (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 코드는 테스트 용입니다.

비 펀지, 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 행은이 이진수를 반복하여 각 숫자가 처리 될 때 적절한 트리 표현을 출력합니다. Befunge 스택은 나무의 깊이와 각 레벨에 남은 리프 공간을 추적하는 데 사용되므로 새 분기를 언제 만들 수 있는지 알 수 있습니다. 6 번 줄과 7 번 줄은 마지막 0패딩을 처리하여 빈 잎을 채 웁니다.

이것을 최대한 많이 골프하기 위해 나는 외부 괄호뿐만 아니라 출력에서 ​​쉼표를 제거했습니다. 이것은 여전히 ​​Mathematica 솔루션을 능가하지는 못했지만 재미있는 시도였습니다.

원래의 자세한 출력 형식으로 표시되는 모양을 보려면 여기에 이전 버전의 코드 (131 바이트)를 저장했습니다.

매스 매 티카, 167161 바이트

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

익명의 기능. 숫자를 입력으로 취하고 임의로 중첩 된 숫자 목록을 출력으로 반환합니다. 명확성을 위해 줄 바꿈이 추가되었습니다. 연속과 관련된 메커니즘을 사용하지만 더 이상 생각하기에 너무 피곤합니다.

매쓰, 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!={}&])&

안전하게 무시할 수있는 오류 메시지를 생성합니다. 이진 포리스트를 출력합니다. 때문에 샘플 출력으로부터 약간 다르다 1A는 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})&

파이썬 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

온라인으로 사용해보십시오

자바 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 인터프리터로 사용해 보거나 Julia로 작성된 DUP 인터프리터의 GitHub 저장소 를 복제하십시오 .