แรงบันดาลใจจากA014486

ท้าทาย

กำหนดอินพุตจำนวนเต็มในฐาน 10 สร้างการแสดงสำหรับฟอเรสต์ไบนารีที่สอดคล้องกับอินพุต การเป็นตัวแทนรวมถึง แต่ไม่ จำกัด เพียงอาร์เรย์และสตริงที่ซ้อนกัน

อย่างไร?

แปลงอินพุตเป็นไบนารี 1s เป็นตัวแทนของสาขาและ0เป็นตัวแทนของใบ

เพื่อให้ง่ายต่อการเข้าใจลองใช้834(1101000010 เป็นไบนารี่) เป็นตัวอย่าง

เราเริ่มต้นด้วยหลักแรก ตัวเลขแรกคือ a 1ดังนั้นเราจึงวาดกิ่ง:

\ /
 1

หรือเป็นอาร์เรย์ {{1}}

ตัวเลขถัดไปคือ1เราจึงดึงกิ่งก้านสาขาเพิ่มเติม (จากซ้ายไปขวา):

\ /
 1
  \ /
    1

หรือเป็นอาร์เรย์ {{1, {1}}}

หลักถัดไปคือ0ดังนั้นเราวางใบไม้:

0
 \ /
  1
   \ /
     1

หรือเป็นอาร์เรย์ {{1, {1, 0}}}

ตัวเลขถัดไปคือ a 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}}

โปรดทราบว่าการทำให้อาร์เรย์แบนราบทำให้ตัวเลขดั้งเดิมเป็นเลขฐานสอง แต่มีค่าเป็นศูนย์

เกณฑ์

• ผลลัพธ์จะต้องแสดงการแยกของต้นไม้และกิ่งอย่างชัดเจน (หากไม่ใช่อาเรย์ซ้อนกันโปรดอธิบายรูปแบบผลลัพธ์ของคุณ)
• การแยกตัวเลขทั้งหมดออกจากผลลัพธ์จะต้องเหมือนกับการแทนค่าแบบไบนารี่ของอินพุต (โดยมีศูนย์ padded จากกระบวนการข้างต้น)

กรณีทดสอบ

เอาท์พุทอาจแตกต่างกันตราบเท่าที่มันเป็นไปตามเกณฑ์

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

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟดังนั้นไบต์ที่ต่ำที่สุดจึงชนะ!

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 แปลงตัวเลขนั้นเป็นลำดับเลขฐานสองซึ่งเก็บไว้ใน playfield ที่บรรทัดที่ 10 บรรทัดที่ 3 ถึง 5 จากนั้นวนซ้ำไปตามเลขฐานสองเหล่านั้น Befunge stack ใช้เพื่อติดตามความลึกของต้นไม้และจำนวนพื้นที่ใบไม้ที่เหลือในแต่ละระดับเพื่อให้เรารู้ว่าจะสร้างสาขาใหม่เมื่อใด บรรทัดที่ 6 และ 7 จะจัดการกับการ0เติมสุดท้ายเพื่อเติมเต็มใบที่ว่างเปล่า

เพื่อที่จะตีกอล์ฟให้มากที่สุดเท่าที่จะเป็นไปได้ฉันลบเครื่องหมายจุลภาคออกจากขาออกรวมทั้งเครื่องหมายปีกกาภายนอก สิ่งนี้ยังไม่สามารถเอาชนะโซลูชัน Mathematica ได้ แต่มันสนุกดีที่ได้ลอง

หากคุณต้องการดูว่ามันมีรูปแบบเอาต์พุต verbose ดั้งเดิมฉันบันทึกรหัสรุ่นก่อนหน้าไว้ที่นี่ (131 ไบต์)

Mathematica, 167 161 ไบต์

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

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 ไบต์ (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

ลองใช้กับล่าม Javascript DUPออนไลน์บน quirkster.comหรือโคลนที่เก็บ GitHubของฉันของล่าม DUP ของฉันที่เขียนใน Julia