एक बाइनरी जंगल लगाओ!

Question

A014486 से प्रेरित ।

चुनौती

बेस 10 में एक पूर्णांक इनपुट को देखते हुए, इनपुट के अनुरूप बाइनरी वन के लिए एक प्रतिनिधित्व का निर्माण करें। प्रतिनिधियों में शामिल हैं, लेकिन सीमित एरेड और तार तक सीमित नहीं हैं।

कैसे?

इनपुट को बाइनरी में बदलें। 1एस शाखाओं का प्रतिनिधित्व करते हैं, और 0पत्तियों का प्रतिनिधित्व करते हैं।

इसे समझने में आसान बनाने के लिए, आइए 834एक उदाहरण के रूप में (1101000010 बाइनरी में) का उपयोग करें ।

---

हम पहले अंक से शुरू करते हैं। पहला अंक एक है 1, इसलिए हम शाखाओं को आकर्षित करते हैं:

\ /
 1

या एक सरणी के रूप में, {{1}}

---

अगला अंक है 1, इसलिए हम अधिक शाखाएँ खींचते हैं (हम बाएं से दाएं जाते हैं):

\ /
 1
  \ /
    1

या एक सरणी के रूप में, {{1, {1}}}

---

अगला अंक है 0, इसलिए हम एक पत्ता रखते हैं:

0
 \ /
  1
   \ /
     1

या एक सरणी के रूप में, {{1, {1, 0}}}

---

अगला अंक एक है 1, इसलिए हम एक शाखा रखते हैं:

     \ /
० १
 \ /
   1
      \ /
         1

या एक सरणी के रूप में, {{1, {1, 0, {1}}}}

---

इस प्रक्रिया को दोहराते हुए, हम 8 वें अंक के बाद निम्नलिखित पेड़ प्राप्त करते हैं:

    ० ०
     \ /
० १
 \ /
   १ ०
      \ /
         1

या एक सरणी के रूप में, {{1, {1, 0, {1, 0, 0}}, 0}}

---

शेष अंकों के लिए, हम अधिक पेड़ लगाते हैं:

9 वां अंक एक है 0, इसलिए हम एक पत्ता (aww, यह एक युवा शूट है!)

    ० ०
     \ /
० १
 \ /
   १ ०
      \ /
         १ ०

या एक सरणी के रूप में, {{1, {1, 0, {1, 0, 0}}, 0}, 0}

---

जब हम सभी अंकों का उपयोग करते हैं, तो हम इसे समाप्त करते हैं:

    ० ०
     \ /
० १
 \ /
   १ ० ०
      \ / \ /
         १ ० १

या एक सरणी के रूप में, {{1, {1, 0, {1, 0, 0}}, 0}, 0, {1, 0}}

---

यह अजीब लग रहा है, इसलिए हम पेड़ को पूरा करने के लिए एक शून्य लगाते हैं:

    ० ०
     \ /
० १
 \ /
   १ ० ० ०
      \ / \ /
         १ ० १

या एक सरणी के रूप में, {{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,}}, {1, {1, {1, 0, 0}, {1, 0,}}, 0}}।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स जीतती हैं!

Comments

मैं बोनस का उपयोग करने से बचूंगा - यह आम तौर पर चुनौती में सुधार नहीं करता है।

— सांचेस

@Sanchises मैंने विज़ुअलाइज़ेशन के साथ उत्तर देखने के लिए बोनस जोड़ा ... मैं आउटपुट के रूप में विज़ुअलाइज़ेशन बनाने की कोशिश करने के लिए लोगों को कैसे प्रोत्साहित कर सकता हूं?

— जुंगह्वान मिन

(अपनी टिप्पणी पुनः) इसकी आवश्यकता है?

— msh210

@JungHwanMin मैं और अधिक विस्तार से क्या देखा (विशेषकर टिप्पणियाँ); या, एक ही मेटा प्रश्न में, यह उत्तर। आपका वर्तमान प्रश्न पोस्टरों को 2 ^ 2 = 4 प्रोग्राम बनाने के लिए कहता है, और सबसे अच्छा स्कोरिंग प्रोग्राम सबमिट करने से पहले प्रत्येक प्रोग्राम के स्कोर की गणना करता है। या तो आपको इसकी आवश्यकता होती है जब आपको लगता है कि यह एक बेहतर चुनौती के लिए बनाता है, या यदि आपको लगता है कि यह एक बदतर चुनौती है तो इसे हटा दें।

— Sanchises

@ जुंगह्वेन मेला काफी उन्हें 3 प्रोग्राम को गोल्फ करना चाहिए और एक जवाब प्रस्तुत करने से पहले प्रत्येक व्यक्तिगत स्कोर की गणना करना चाहिए। आपके पास यहां क्या है, तीन चुनौतियां एक में लिपटी हैं। मैं विज़ुअलाइज़ेशन को एक अलग चुनौती के रूप में पोस्ट करने की सलाह दूंगा।

— सांचेस 19

Answer 1

जावास्क्रिप्ट (ईएस 6), 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 कोड सिर्फ परीक्षण के लिए है।

Comments

एक सेकंड के लिए मैं सोच रहा था "बिल्ली $&बिना .replaceक्या कर रही है ?" : P

— ETHproductions

@ETHproductions मैं थोड़े ऊब गया और चर नामों को मान लिया। बहुत बुरा जेएस अन्य एकल-प्रतीक वाले के लिए अनुमति नहीं देता है: D

— PurkkaKoodari

Answer 2

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 स्टड से एक संख्या को पढ़ता है, और लाइन 2 उस संख्या को एक द्विआधारी अनुक्रम में परिवर्तित करता है जिसे वह लाइन 10 में प्लेफील्ड में संग्रहीत करता है। रेखा 3 से 5 फिर उन बाइनरी अंकों पर पुनरावृति करता है, प्रत्येक अंक के रूप में उपयुक्त ट्री प्रतिनिधित्व को आउटपुट करता है। बेफुंज स्टैक का उपयोग पेड़ में गहराई का ट्रैक रखने के लिए किया जाता है और प्रत्येक स्तर पर कितना पत्ती स्थान बचा है इसलिए हम जानते हैं कि एक नई शाखा कब बनाई जाए। लाइन्स 6 और 7 0किसी भी खाली पत्तियों को भरने के लिए अंतिम पैडिंग को संभालती है ।

जितना संभव हो उतना गोल्फ करने के लिए, मैंने आउटपुट से कॉमा के साथ-साथ बाहरी बाहरी ब्रेसिज़ को हटा दिया। यह अभी भी Mathematica समाधान को हरा नहीं है, लेकिन यह मजेदार कोशिश कर रहा है।

यदि आप यह देखना चाहते हैं कि यह मूल क्रिया आउटपुट फॉर्मेट के साथ कैसा दिखता है, तो मैंने यहां कोड का एक पुराना संस्करण (131 बाइट्स) सहेजा है ।

Comments

(यह पर्याप्त upvotes नहीं है: D)

— Addison Crump

Answer 3

गणितज्ञ, 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]&,
{}]&

अनाम फ़ंक्शन। संख्या को इनपुट के रूप में लेता है, और आउटपुट के रूप में संख्याओं की एक मनमाने ढंग से नेस्टेड सूची देता है। स्पष्टता के लिए लाइन ब्रेक जोड़े गए। निरंतरता वाले कुछ तंत्र का उपयोग करता है, लेकिन मैं अब इसके बारे में सोचने के लिए बहुत थक गया हूं।

Comments

#[[1]]करने के लिए #&@@#एक बाइट को बचाने चाहिए। !#~FreeQ~1इसके बजाय #~MemberQ~1एक बाइट भी बचाता है।

— जुंगवान मिन

Answer 4

गणितज्ञ, 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})&

Answer 5

पायथन 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

इसे ऑनलाइन आज़माएं

Answer 6

जावा 8, 367 बाइट्स

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

Answer 7

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

इसे ऑनलाइन ऑनलाइन जावास्क्रिप्ट DUP दुभाषिया quirkster.com पर देखें या जूलिया में लिखे गए मेरे DUP दुभाषिया के GitHub रिपॉजिटरी को क्लोन करें ।