बी यू मे ल दान ई एस टी

Question

चुनौती सरल है: एक प्रोग्राम या फ़ंक्शन लिखें, जो एक परिमित गैर-नकारात्मक पूर्णांक दिए जाने पर, एक नेस्टेड सरणी को आउटपुट करता है।

नियम

• आपके कोड को प्रत्येक पूर्णांक 0 n ³¹ <2 ^{31 के} लिए एक अद्वितीय मान्य नेस्टेड सरणी का उत्पादन करना चाहिए ।
• इस श्रेणी के भीतर 16 खुले कोष्ठकों के साथ हर संभव नेस्टेड सरणी को आउटपुट किया जाना चाहिए। (इसका मतलब यह नहीं है कि आपका कोड कभी भी नेस्टेड सरणी को 16 से अधिक खुले ब्रैकेट के साथ आउटपुट नहीं कर सकता है।)
• आपका कोड वास्तविक सरणी (कॉमा के साथ या बिना) के बजाय नेस्टेड सरणी का एक स्ट्रिंग प्रतिनिधित्व आउटपुट कर सकता है।

एक संभव मानचित्रण:

0 -> []
1 -> [[]]
2 -> [[[]]]
3 -> [[], []]
4 -> [[[[]]]]
5 -> [[[], []]]
6 -> [[[]], []]
7 -> [[], [[]]]
8 -> [[], [], []]
9 -> [[[[[]]]]]
etc.

स्कोरिंग

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

Comments

क्या कोई समय / स्मृति प्रतिबंध हैं?

— डेनिस

@ डेनिस क्या 1 घंटे एक समय के प्रतिबंध के लिए उचित लगता है? मेरे पास कोई सुराग नहीं है कि स्मृति के लिए क्या उचित है।

— ETHproductions

यदि समय सीमा है, तो मेमोरी कोई बड़ी बात नहीं है। एक घंटा बहुत उदार लगता है। यदि मेरा कोड पर्याप्त तेज़ है, तो मैं सत्यापित करने के लिए पूरे एक घंटे का इंतजार नहीं करना चाहूंगा।

— डेनिस

मैं कोई समय प्रतिबंध नहीं पसंद करूंगा। यह मौलिकता के लिए अधिक गुंजाइश देता है

— टन हास्पेल

@ टोनहोम आप कॉमा के बिना आउटपुट कर सकते हैं। मुझे लगता है कि कोई भी समय प्रतिबंध ठीक नहीं होगा, जब तक आप यह साबित कर सकते हैं कि आपका प्रवेश वैध है।

— ETHproductions

Answer 1

पायथन 2.7, 172 149 124 118 बाइट्स

x=input();y="";z=0
for b in bin(x)[2+(x<1):]:y+="[]"[b<"1"];z+=b>"0"or-1;z+=99*(z<0)
print"["+(y,"[]"*(x+16))[z>0]+"]"

स्पष्टीकरण:

[Bi 1और ]ine द्वारा एक आक्षेप को परिभाषित करें 0। कोष्ठक में से कोई व्यवस्था तो एक द्विआधारी संख्या और इसके विपरीत, उदाहरण के लिए के रूप में लिखा जा सकता है [][]↔ 1010(10) और [[][]]↔ 110100(52)। 15 खुले ब्रैकेट (कुल 30 ब्रैकेट) तक की सभी वैध व्यवस्थाएं 30 बिट्स (अग्रणी शून्य की अनदेखी) के साथ संख्याओं द्वारा कवर की जाती हैं, जो ठीक 2 ³¹ से कम संख्या में हैं ।

पहला फॉर-लूप इस बायजेक्शन का विलोम देता है, संख्या को कोष्ठक की व्यवस्था में परिवर्तित करता है, जबकि जाँच करता है कि व्यवस्था मान्य है।

टकराव से बचने के लिए लंबे समय के क्रम में ब्रैकेट्स के प्रिंट स्टेटमेंट के भीतर अमान्य व्यवस्था को बदल दिया जाता है। उदाहरण के लिए 11(3) ↔ [[मान्य नहीं है, इसलिए हम इसके बजाय 3 + 16 कोष्ठक को बदलते हैं। यह सुनिश्चित करता है कि सभी व्यवस्थाएं अद्वितीय हैं।

परिणामी व्यवस्था को नेस्टेड सरणी बनाने के लिए कोष्ठक की एक जोड़ी के भीतर रखा जाता है, ताकि 1010(10) बन जाए [[][]]और 110100(52) बन जाए [[[][]]]। अतिरिक्त खुले ब्रैकेट का मतलब है कि हमने अब सभी ऐरो को 16 ओपन ब्रैकेट के साथ कवर किया है।

---

निम्नलिखित कार्यक्रम का उपयोग 16 कोष्ठक के साथ दिए गए सरणी के लिए संख्या का पता लगाने के लिए किया जा सकता है।

s=raw_input();o="";
for c in s[1:-1]:
 if c=="[":o+="1"
 if c=="]":o+="0"
print int(o,2)

Comments

जब वह "अद्वितीय" निर्दिष्ट करता है तो

— ऑप्स

वह सिर्फ प्रतिभा है। बहुत बढ़िया। (और एक अल्पविराम प्रारूप की अनुमति है।)

— ETHproductions

Answer 2

पायथन, 153 128 बाइट्स

s=l=0;r="";n=input()
for d in bin(n)[2:]*(n>0):c=d<"1";l=[l,s>1][c];r+="]"*c+(1-l*c)*"[";s+=1-c-l*c
print"["+r+"["*l+"]"*(s+l+1)

हम अपने बाइनरी अंकों को बाएं-से-दाएं देखकर एक नेस्टेड सूची में एक नंबर n मैप करते हैं । यह एल्गोरिथ्म किसी भी संख्या के लिए काम करता है, न कि केवल 2 ^{32 के} तहत ।

1. यदि वर्तमान बाइनरी अंक 1, आउटपुट है [।
2. अन्यथा, यदि हम अब तक आउटपुट किए गए ब्रैकेट का क्रम एकल क्लोजिंग ब्रैकेट, आउटपुट से संतुलित करते हैं ][।
3. अन्यथा, यदि यह बाइनरी नंबर, आउटपुट में अंतिम 0 है ][।
4. अन्यथा उत्पादन ]।

अंत में, हम किसी भी खुले हुए कोष्ठक को बंद कर देते हैं।

Answer 3

चम्मच , 63 बाइट्स (501 बिट्स)

000001001001001011001101001010011011111001010001000000101010
101101100110100101101001000101100010001000000100011000010000
000000000000001110111110010000001110110110010100100100100100
000110011010001000000110110000010000001010110011011011011001
000000011010010010010001000000111011011011101001001001000110
110110010100100101011001000100000011010001000000111011011001
010010010010010001101101101001000110110010110001101101101101
100100010001010010001010011011001000000011001101001001010010
000001100101001000111

यह निम्नलिखित ब्रेनफक प्रोग्राम है जिसे चम्मच में बदल दिया गया है:

-[+[+<]>>+]<+++.[->+>+<<]>>++>>,[>-[<->-----]+<+++[-<+<<.>>>>-<]>[-<<-[->+<]<<<[-]>>>>[-<+<<<+>>>>]<<.>>+<[>-]>[-<+<<.>>>>]<<>>]<,]<<<<[>.>.<<[-]]>>>+[-<.>]+

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

पठनीय संस्करण:

-[+[+<]>>+]<+++.           push open bracket and print it
[->+>+<<]                  dup
>>++                       increment to close bracket

>>,[                       read input loop
    >-[<->-----]+<+++          subtract 48 and set up if/else
    [-                         if c == 1
        <+                         increment s
        <<.>>>                     output open bracket
    >-<]>[-<                   else
        <-[->+<]                   decrement and move s
        <<<[-]                     zero l
        >>>>[-<+<<<+>>>>]          l = s and restore s
        <<.>                       output close bracket
        >+<[>-]>[-                 if s == 0
            <+                         undo s decrement
            <<.                        output open bracket
        >>>>]<<
    >>]<
,]

<<<<[                      if l
    >.>.                   output pair
<<[-]]
>>>+[-<.>]                 output close bracket s+1 times

Comments

हमने हाल ही में एक और उत्तर पर यह चर्चा की है, और ऐसा कोई वास्तविक परिचय नहीं है जो 63-बाइट फ़ाइल को संभालने में सक्षम हो। संदर्भ कार्यान्वयन ने बाइट्स 0x30 और 0x31 का उपयोग किया, इसलिए इस उत्तर के लिए 501 बाइट फ़ाइल की आवश्यकता होगी ।

— डेनिस

Answer 4

जेली , 28 बाइट्स

ḃ2-*µSN;+\>-Ạ
1Ç#Ṫḃ2ṭ2;1ị⁾][

यह पात्रों के सभी तारों पर निर्भर करता है [और ]जो एक के साथ शुरू [और अंत होता है ], सत्यापित करता है कि कोष्ठक मेल खाते हैं, और n ^वें मैच को प्रिंट करते हैं ।

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

Answer 5

पर्ल, 80 79 बाइट्स

फिर से orlp के एल्गोरिथ्म का उपयोग करता है, लेकिन इस बार मैंने पहली बार जाँच की कि क्या यह काम करता है ...

के लिए +1 शामिल है -p

STDIN पर इनपुट नंबर दें

nest.pl <<< 8

nest.pl:

#!/usr/bin/perl -p
($_=sprintf"%b",$_).=2x(s^.^$&or++$n-pos&&/.0/g?++$n%1:$`&&21^eg-$n);y;102;();

लिनुस का घोल 64 बाइट प्रति पर्ल में है:

#!/usr/bin/perl -p
$_=sprintf"%b",/.+/g;$_=10x($&&&$&+16)if!/^(1(?1)*0)+$/;y;10;()

डेनिस का समाधान 59 बाइट प्रति पर्ल (बड़ी संख्या के लिए तेजी से धीमा) है:

#!/usr/bin/perl -p
1while$_-=(sprintf"%b",$n++)=~/^(1(?1)*0)+$/;$_=$&;y;10;()

Comments

मुझे ऐसा लगता है कि आपको इसे केवल 65 बाइट्स के रूप में स्कोर करना चाहिए, (क्या यह वास्तव में 64 नहीं है)?

— लाइनस

@ लिनुस जबकि आपके नियम चकमा देने वाले हैं और इसके सभी उत्थान के हकदार हैं, मैं इसे थोड़ा धोखा मानता हूं। स्कोरिंग के लिए -p1 अतिरिक्त बाइट के रूप में गिना जाता है

— टन हास्पेल

Answer 6

पायथन 3, 120 114 बाइट्स

def f(n,k=0):
 while~n:
  k+=1
  try:r=eval(bin(k).translate({48:'],',49:'['})[3:-1])+[];n-=1
  except:0
 print(r)

Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

परिभाषित फ़ंक्शन f इनपुट n लेता है और k को 0 से प्रारंभ करता है । हम k को तब तक बढ़ाते रहेंगे जब तक n + 1 का k मान मान्य आउटपुट में नहीं हो जाता। हर बार जब हम k का ऐसा मान पाते हैं , तो n -1 , एक बार ~nउपज 0 और सूची r तक पहुंचने के बाद घटाया जाता है k के अंतिम मान से मेल प्रिंट हो जाती है।

सकारात्मक पूर्णांकों से नेस्टेड सूचियों (यानी, ↦ r) के लिए आंशिक मानचित्रण ) के लिए होना चाहिए, लेकिन कोई अन्य बाधाएं नहीं हैं। इस उत्तर में प्रयुक्त एक निम्नानुसार संचालित होता है।

1. कन्वर्ट कश्मीरबाइनरी स्ट्रिंग प्रतिनिधित्व में को , 0b के साथ घूर ।

   उदाहरण के लिए, 44 ↦ "0b101100" ।

2. स्ट्रिंग के साथ स्ट्रिंग प्रतिनिधित्व में सभी 0 के (कोड बिंदु 48 ) को प्रतिस्थापित करें "]," और सभी 1 के कोड ( 49 के साथ कोड ) [ ।

   उदाहरण के लिए, "0b101100" ↦ "], b [], [[],]," ।

3. पहले तीन वर्णों को निकालें (वे अनुरूप हैं "0b" के ) और अनुगामी चरित्र (उम्मीद है कि अल्पविराम)।

   उदाहरण के लिए, "], बी [], [[],", "]" [], [[],] " ।

4. उत्पन्न कोड का मूल्यांकन करने का प्रयास करें। यदि यह एक त्रुटि का परिणाम है, k को किसी भी सूची में मैप नहीं किया जाता है।

   उदाहरण के लिए, "[], [[]," "] ([], [[]]) ।

5. रिक्त सूची के साथ परिणाम (यदि कोई हो) को फिर से लिखें। यदि यह एक त्रुटि का परिणाम है, k को किसी भी सूची में मैप नहीं किया जाता है।

   उदाहरण के लिए, ([], [[]]) + [] त्रुटियों के बाद से + कर सकते हैं CONCATENATE सूचियों और tuples नहीं।

Answer 7

हास्केल, 71 बाइट्स

p 1=["[]"]
p n=['[':h++t|k<-[1..n-1],h<-p k,_:t<-p$n-k]
((p=<<[1..])!!)

अंतिम पंक्ति अनुक्रमणिका पर मुख्य कार्य सभी नेस्टेड सरणियों की सूची में होता है, जो आकार (खुले ब्रैकेट की संख्या) द्वारा क्रमबद्ध होता है। इसलिए, अधिकतम 16 पर आकार के सभी सरणियों को पहले सूचीबद्ध किया गया है।

आइए पहले उस कोड को देखें जो अच्छे और छोटे हैं, लेकिन हास्केल का टाइपसेकर स्वीकार करने से इनकार कर देता है।

p 1=[[]]
p n=[h:t|k<-[1..n-1],h<-p k,t<-p$n-k]
((p=<<[1..])!!)

pइनपुट पर फ़ंक्शन nआकार n(खुले कोष्ठक) के सभी नेस्टेड सरणियों की एक सूची देता है । यह पुनरावर्ती रूप से किया जाता है। इस तरह के प्रत्येक सरणी hमें आकार के कुछ सिर (पहले सदस्य) और आकार के kकुछ पूंछ t(अन्य सदस्य) होते हैं n-k, दोनों आकार नॉनजरो होते हैं। या, यह आकार के लिए खाली सरणी है n==1।

p=<<[1..]तब अभिव्यक्ति p(1), p(2), ...आकार द्वारा क्रमबद्ध सभी सरणियों की एक अनंत सूची में समतल हो जाती है

[ [], [[]], [[],[]], [[[]]], [[],[],[]], [[],[[]]], [[[]],[]], [[[],[]]], ...

और इसमें मुख्य कार्य अनुक्रमित होते हैं।

... या, यह होगा, अगर हास्केल ने "निर्माण [आईएनजी] अनंत प्रकार: टी ~ [टी]" के बारे में नहीं कहा। हास्केल उस अनंत सूची का प्रतिनिधित्व नहीं कर सकता है जिसके तत्व मनमाने ढंग से गिरफ्तार किए गए हैं। इसके सभी तत्वों में एक ही प्रकार होना चाहिए, लेकिन एक प्रकार t t की सूची के समान नहीं हो सकता है। वास्तव में, फ़ंक्शन pको केवल निर्भर टाइपिंग के बिना एक सुसंगत प्रकार नहीं सौंपा जा सकता है, जिसमें हास्केल का अभाव है।

इसलिए, इसके बजाय हम कोष्ठक के तारों पर काम करते हैं, पात्रों [और ]पात्रों पर अभिनय करके ऑपरेशन को अनुकरण करते हैं । यह एक अतिरिक्त 9 बाइट्स लेता है। एक सुरक्षित भाषा में गोल्फ की परिधि।

Answer 8

हास्केल, 87 82 बाइट्स

0#0=[""]
n#m=['[':x|n>0,x<-(n-1)#m]++[']':x|n<m,x<-n#(m-1)]
(([0..]>>= \y->y#y)!!)

सरणी तत्वों को आउटपुट करता है। प्रयोग उदाहरण: (([0..]>>= \y->y#y)!!) 3-> "[][]"।

फ़ंक्शन #सभी नेस्टेड सरणियों को nखुले और mबंद कोष्ठक के लिए स्ट्रिंग्स के रूप में बनाता है , प्रत्येक के कितने हिस्से को छोड़ दिया जाता है। हमेशा से शुरू होता है n == m। मुख्य फ़ंक्शन y # yप्रत्येक के लिए कॉल करता है y <- [0,1,...]और इनपुट द्वारा दिए गए सूचकांक में तत्व को चुनता है।

Answer 9

MATL , 31 बाइट्स

O`@BEqXJYs0&)0>w~hA+tG>~]x92J-c

इसे ऑनलाइन आज़माएं! या पहले कुछ परीक्षण मामलों को सत्यापित करें (कुछ सेकंड लगते हैं)।

उत्पादित मैपिंग है:

0 -> []
1 -> [[]]
2 -> [[][]]
3 -> [[[]]]
4 -> [[][][]]
5 -> [[][[]]]
6 -> [[[]][]]
7 -> [[[][]]]
...

व्याख्या

कोड द्विआधारी संख्या का परीक्षण करता रहता है, इसके 0स्थान पर अंकों की संख्या होती है -1; वह है, उपयोग करना 1और -1अंकों के रूप में। अंक 1प्रतिनिधित्व करेंगे '['और -1प्रतिनिधित्व करेंगे ']'।

प्रोग्राम तब तक गिना जाता है जब तक n +1 मान्य नंबर प्राप्त नहीं हो जाते। एक संख्या मान्य है यदि निम्न दो स्थितियाँ हैं:

1. अंकों का योग शून्य है (अर्थात, की संख्या बराबर है 1और -1)
2. अंकों का संचयी योग हमेशा सकारात्मक होता है (अर्थात, 1अंकों की संचित संख्या हमेशा उस से अधिक होती है -1) सिवाय अंत में (जहां यह स्थिति 1 से शून्य है)।

एक बार n +1 वैध संख्या प्राप्त किये गए हैं, पिछले एक बदलकर लिप्यंतरण है 1में [और -1में ], और फिर इसे प्रदर्शित होता है।

कोड:

O          % Push 0: initial count of valid numbers
`          % Do...while
  @        %   Push iteretation index k, starting at 1
  B        %   Convert to binary. For example, k=6 gives [1 1 0 0]
  Eq       %   Multiply by 2, subtract 1: transforms [1 1 0 0] into [1 1 -1 -1]
  XJ       %   Copy that to clipboard J, without popping it
  Ys       %   Cumulative sum: gives [1 2 1 0]
  0&)      %   Split array into its final element and the rest. Gives 0, [1 2 1]
  0>       %   Yields 1 for positive entries (condition 2). So in this case it
           %   gives [1 1 1]
  w        %   Swap: moves second-top element in the stack (0 in this case) to top
  ~        %   Negate: yields 1 if input is 0 (condition 1). Gives 1 in this case
  h        %   Concatenate horizontally. Gives [1 1 1 1]
  A        %   All: gives 1 if all elements are 1. Gives 1 in this case, meaning
           %   that this k is valid
  +        %   Add the result (0 or 1) to the count of valid numbers
  t        %   Duplicate
  G        %   Push input n
  >~       %   Loop condition: false (exit loop) if count exceeds input n
]          % End loop. At this point the result is in clipboard J, in 1/-1 format
x          % Delete count
92         % Push 92. Will be used to convert 1, -1 to '[', ']' (ASCII 91, 93)
J          % Push result in 1/-1 format
-          % Subtract: converts 1 to 91, -1 to 93
c          % Convert to char. Implicitly display