A014486'dan esinlenilmiştir .

Meydan okuma

10 tabanındaki bir tamsayı girişi göz önüne alındığında, girişe karşılık gelen ikili orman için bir gösterim oluşturun. Temsiller iç içe dizileri ve dizeleri içerir, ancak bunlarla sınırlı değildir.

Nasıl?

Girişi ikiliye dönüştürün. 1s dalları temsil eder ve 0s yaprakları temsil eder.

Bunu anlamayı kolaylaştırmak için, 834bir örnek olarak kullanalım (ikili olarak 1101000010).

İlk rakam ile başlıyoruz. İlk hane a 1, yani dalları çizeriz:

\ /
 1

veya bir dizi olarak {{1}}

Bir sonraki rakam, 1daha fazla dal çizeriz (soldan sağa gideriz):

\ /
 1
  \ /
    1

veya bir dizi olarak {{1, {1}}}

Bir sonraki rakam ise 0, bir yaprak yerleştiririz:

0
 \ /
  1
   \ /
     1

veya bir dizi olarak {{1, {1, 0}}}

Bir sonraki hane a 1, bu yüzden bir dal koyalım:

     \ /
0 1
 \ /
   1
      \ /
         1

veya bir dizi olarak {{1, {1, 0, {1}}}}

İşlemi tekrarlayarak 8. basamaktan sonra aşağıdaki ağacı elde ediyoruz:

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

veya bir dizi olarak {{1, {1, 0, {1, 0, 0}}, 0}}

Kalan rakamlar için daha fazla ağaç çizeriz:

9. hane a 0, bu yüzden bir yaprak yerleştiririz (aww, genç bir çekim!)

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

veya bir dizi olarak {{1, {1, 0, {1, 0, 0}}, 0}, 0}

Tüm rakamları kullandığımızda, bununla sonuçlanır:

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

veya bir dizi olarak {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0}}

Bu çok garip görünüyor, bu yüzden ağacı tamamlamak için bir sıfır atarız:

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

veya bir dizi olarak {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0, 0}}

Diziyi yassılaştırmanın orjinal sayıyı ikili olarak verdiğini, ancak yastıklı sıfır bulunduğunu unutmayın.

Kriterler

• Çıktı, ağaçların ve dalların ayrımını açıkça göstermelidir (iç içe geçmiş bir dizi değilse, lütfen çıktı biçiminizi açıklayın).
• Tüm basamakların çıkıştan alınması, girişin ikili gösterimi ile aynı olmalıdır (yukarıdaki işlemden doldurulmuş sıfır (lar) ile).

Test durumları

Çıktı, kriterleri karşıladığı sürece farklı olabilir.

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

puanlama

Bu kod golf , yani en düşük bayt kazanır!

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

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İç içe bir dizi döndüren işlevi tanımlar . HTML kodu sadece test içindir.

Befunge, 138 117 104 bayt

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

Çevrimiçi deneyin!

açıklama

Satır 1, stdin'den bir sayı okur ve satır 2, bu sayıyı 10. satırdaki playfield'de depoladığı bir ikili diziye dönüştürür. Satırlar 3 ila 5, daha sonra her bir rakam işlenirken uygun ağaç gösterimini veren bu ikili basamaklar üzerinde yinelenir. Befunge yığını, ağaçtaki derinliği ve her seviyede ne kadar yaprak boşluğu kaldığını takip etmek için kullanılır, böylece ne zaman yeni bir dal oluşturulacağını biliriz. Satır 6 ve 7, 0boş yaprakları doldurmak için son dolguyu kullanır.

Bu mümkün olduğunca golf oynamak için, dış virgüllerin yanı sıra çıkıştan virgüller çıkardı. Bu hala Mathematica çözümünü geçmedi, ancak denemek eğlenceli oldu.

Orijinal ayrıntılı çıktı biçimiyle nasıl göründüğünü görmek istiyorsanız, kodun daha eski bir sürümünü buraya (131 bayt) kaydettim.

Mathematica, 167 161 bayt

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

Anonim işlev Girdi olarak bir sayı alır ve isteğe bağlı olarak yuvalanmış bir sayı listesini çıktı olarak döndürür. Netlik için satır sonları eklendi. Sürekliliği içeren bazı mekanizmalar kullanır, ancak artık düşünmek için çok yoruldum.

Mathematica, 115 109 108 104 98 bayt

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

Güvenli bir şekilde göz ardı edilebilecek hata mesajları oluşturur. İkili bir orman çıkarır. Çünkü örnek çıkışından biraz farklı 1bir olduğunuHead bir listenin, değil ilk öğesi. (örneğin 1[0, 0]yerine {1, 0, 0})

Hatasız versiyon (104 bayt)

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

açıklama

i=#~IntegerDigits~2;

Girişi bir baz-2 listesine dönüştürün. İçinde saklayın i.

f:=

SetDelay fAşağıdakiler (ne zaman fçağrılırsa değerlendirilir ):

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

Switch Beyan.

İlk olarak, eğer iboşsa, çıktı 0. Değilse, ilk elemanın çıktısını ialın ve listeden çıkarın. Çıktıyı kontrol değişkeni olarak kullanın.

Kontrol değişkeni ise 0, çıktı 0. Eğer öyleyse 1, çıktı 1[f, f](özyinelemeli).

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

İken iboş değil, aramaya devam f. Sonuçla sarılmış olarak yazdırın List.

Örnek

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

Alternatif çözüm (120 bayt)

104 baytlık çözümümle özdeştir, ancak çıktıyı soruda verilen formata dönüştürür.

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

Kısmen özyinelemeli, kısmen yinelemeli. Bir tamsayı kullanmaya çalıştım, ancak ağaç en önemli bitlerle başlıyor, bu yüzden buna değeceğini sanmıyorum.

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

Çevrimiçi deneyin

Java 8, 367 bayt

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 bayt (82 karakter)

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

Golf nedeniyle dış kıvrımlı parantezlerden ve virgüllerden kurtuldum çünkü ağaçları yeniden inşa etmek için gerekli değillerdi.

Örnek çıktılar:

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}

Açıklama:

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'daki çevrimiçi Javascript DUP tercümanı ile deneyin veya Julia'da yazılmış DUP tercümanım GitHub deposunu klonlayın .