एक सरणी की गहराई का निर्धारण करें

31

आपकी सोमवार की शाम (दुनिया के दूसरे भाग में मंगलवार या मंगलवार की सुबह के लिए एक सरल चुनौती ...)

आपको इनपुट एक नेस्टेड के रूप में दिया जाता है, सकारात्मक पूर्णांक के संभावित रूप से दांतेदार सरणी:

[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]

आपका काम इसकी गहराई को निर्धारित करना है, जो सूची में किसी भी पूर्णांक की सबसे बड़ी घोंसले की गहराई है। इस मामले में, की गहराई 11है 6, सबसे बड़ा है।

आप मान सकते हैं कि कोई भी एरे खाली नहीं होगा।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

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

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

मानक कोड-गोल्फ नियम लागू होते हैं।

परीक्षण के मामलों

[1]                                                               -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7
code-golf  array-manipulation  counting 
— मार्टिन एंडर
स्रोत
2
चैट में चर्चा करने के बाद, मैंने लंबाई बिल्ट-इन की अनुमति देने का फैसला किया है, क्योंकि कुछ भाषाओं के लिए उन्हें एक सरणी पर सफाई से पुनरावृति की आवश्यकता होती है।
— मार्टिन एंडर
2
बस सामान्य शिक्षा के लिए: ≡एपीएल के लिए निर्मित आदिम है वास्तव में यह ।
— 16
@ MartinBüttner मैंने एक छोटी सी समस्या में भाग लिया है। मैंने जावा में ऐसा करना शुरू कर दिया, जब इनपुट का परीक्षण करते हुए कॉमा इसे कई कमांड लाइन तर्कों में इनपुट विभाजित करने के लिए पैदा कर रहे हैं, बल्कि तब। क्या मैं \ इनपुट में बच चरित्र का उपयोग कर सकता हूं ? संपादित करें: कभी नहीं सिर्फ यह इस तरह की कोशिश की। वह भी काम नहीं करता है। क्या मैं CMD आर्ग्स का उपयोग नहीं कर सकता?
— अश्विन गुप्ता
@AshwinGupta क्या आप उद्धरणों में कमांड लाइन तर्क को लपेट नहीं सकते हैं? आप एसटीडीआईएन से इनपुट भी पढ़ सकते हैं या एक फ़ंक्शन सबमिट कर सकते हैं जो एक वास्तविक सरणी ऑब्जेक्ट को पैरामीटर के रूप में लेता है।
— मार्टिन एंडर
@ मार्टिनबटनर ओह मुझे यह नहीं पता था कि मैं जिस चीज की कोशिश करता हूं, वह उसे आजमाता है। वर्तमान में सिर्फ स्कैनर का उपयोग कर। (System.in)। मेरा मानना ​​है कि यह STDIN का एक रूप है?
— अश्विन गुप्ता

जवाबों:

20

के, 4 बाइट्स

#,/\

K में, ,/एक सूची के सभी तत्वों में शामिल हो जाएगा। आम मुहावरा ,//एक निश्चित बिंदु पर पुनरावृत्ति करता है, एक मनमाने ढंग से नेस्टेड सूची को पूरी तरह से समतल करता है। ,/\एक समान तरीके से एक निश्चित बिंदु पर पुनरावृत्ति करेगा, लेकिन मध्यवर्ती परिणामों की एक सूची इकट्ठा करेगा। निर्धारित बिंदु तक पहुंचने से पहले हम कितने मध्यवर्ती परिणाम देखते हैं, यह गिनकर ( #), हमें वह उत्तर मिलता है जो हम चाहते हैं: अधिकतम घोंसले का शिकार गहराई।

"फिक्स्ड-पॉइंट स्कैन में शामिल होने की गणना करें"।

कार्रवाई में:

 (#,/\)'(,1
        1 2 3
        ,1 2 3
        (3;(3;,3;3);3)
        ,((,1;2);(3;,4)))
1 1 2 3 4
— JohnE
स्रोत
15

रेटिना , १०

  • @ ByП 1 को 1 बाइट धन्यवाद दिया गया
  • @ मार्टिनबटनर के लिए 14 अतिरिक्त बाइट्स धन्यवाद
+ `\ W |} {

{

यहां इनपुट फॉर्मेट थोड़ा सा कंट्रास्ट किया गया है - _लिस्ट विभाजकों के लिए उपयोग किया जाता है, इसलिए एक इनपुट इस तरह दिखेगा{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

  • स्टेज 1 - बार-बार हटाने }{और अन्य सभी\w वर्ण। इसका प्रभाव a) सभी स्तरों पर सभी सूचियों को बनाने में केवल एक तत्व से बना है और b) सभी गैर-सूची-संरचनात्मक वर्णों को हटा रहा है।
  • स्टेज 2 - शेष गणना {। इससे घोंसले के गहरे स्तर का पता चलता है।

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

यदि यह बहुत अधिक खिंचाव है, तो पिछला उत्तर था:

रेटिना , १३

मान लें कि सूची घुंघराले ब्रेसिज़ में निहित हैं {}।

+ `[^} {] |} {

{

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

— डिजिटल आघात
स्रोत
1
आपका कोड 13 बाइट्स तक छोटा हो सकता है (11 यदि आप इनपुट प्रारूप को थोड़ा बढ़ाते हैं)। यदि आप एक संकेत चाहते हैं तो मुझे बताएं। :) (मैं वास्तव में इसे स्वयं पोस्ट नहीं करना चाहता, क्योंकि यह वास्तव में एक ही समाधान है।)
— मार्टिन एंडर
यह दो चीजें हैं। a) आप इनपुट प्रारूप को थोड़ा मोड़कर एक बाइट या तो बचा सकते हैं । ख) आप उस पर ध्यान दिए बिना बहुत सारे बाइट्स बचा सकते हैं ... यदि आप एक ही बार में कई परीक्षण मामलों को संभालने की कोशिश नहीं करते हैं, तो क्या आप एक छोटा (और अधिक सरल) समाधान पा सकते हैं?
— मार्टिन एंडर
मैंने ऐसा सोचा भी नहीं था। उस समय बाइट बच गई। इनपुट प्रारूप में मेरा बदलाव और भी कमजोर रहा होगा। बी के बारे में) याद रखें कि रेटिना के ऑपरेशन का सबसे पहला और सरल तरीका क्या था?
— मार्टिन एंडर
1
हां। मेरे क) हालांकि इनपुट से रिक्त स्थान को हटाने की बात कर रहा था। और आप _इसके बजाय का उपयोग करके दो और बाइट्स बचा सकते हैं , ,लेकिन यह थोड़ा खिंचाव हो सकता है।
— मार्टिन एंडर
@ मार्टिनबटनर अच्छा विचार है! सहमत - _विभाजक बहुत अधिक वंचित हो सकते हैं। इसलिए मैं उत्तर में दोनों संस्करणों को छोड़ रहा हूं
— डिजिटल ट्रामा
12

पायथन 2, 33 बाइट्स

f=lambda l:l>{}and-~max(map(f,l))

संख्या की गहराई को 0 कहकर गहराई से परिभाषित करता है, और एक सूची की गहराई उसके तत्वों की अधिकतम गहराई से एक है। नंबर बनाम सूची को खाली शब्दकोश की तुलना करके जांचा जाता है {}, जो संख्याओं से ऊपर आता है, लेकिन पायथन 2 के बिल्ट-इन प्रकारों के मनमाने आदेशों की सूचियों के नीचे है।

— XNOR
स्रोत
यदि यह मदद करता है तो लंबाई में निर्मित इन्स की अनुमति है।
— मार्टिन एंडर
6

पायथ - 11 10 7 बाइट्स

1 बाइट्स @ डेनिस की बदौलत बच गई

4 बाइट्स ने @Thomas Kwa को धन्यवाद दिया

eU.usNQ

इसे यहाँ ऑनलाइन आज़माएँ ।

सरणी को तब तक समेटता रहता है जब तक कि यह बदलना बंद न हो जाए, जिसका अर्थ है इसकी मात्र एक संख्या, यह सभी मध्यवर्ती परिणामों को बचाने के लिए संचयी रूप से करता है और सूची के रूप में एक ही लंबाई के साथ एक urange बनाकर और अंतिम तत्व लेकर लंबाई प्राप्त करता है।

— Maltysen
स्रोत
m!!dबन सकता है &R1।
— डेनिस
@ डेनिस कूल, स्मार्ट है
— माल्टीसेन
@ThomasKwa lओपी में अनुमति नहीं है।
— माल्टसेन
@ThomasKwa जो वास्तव में स्मार्ट है, धन्यवाद!
— माल्टसेन
यदि यह मदद करता है तो लंबाई में निर्मित इन्स की अनुमति है।
— मार्टिन एंडर
6

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

'['#x=x-1
']'#x=x+1
_#x=x
maximum.scanr(#)0

उपयोग उदाहरण: maximum.scanr(#)0 $ "[1, [[3]], [5, 6], [[[[8]]]], 1]"->5।

हास्केल की मिश्रित सूची नहीं है ( Integerमिश्रित के साथ)List of Integer ), इसलिए मैं कुछ सूची का पता लगाने के कार्यों का शोषण नहीं कर सकता और मुझे स्ट्रिंग को पार्स करना होगा।

Im दाईं ओर शुरू होता है 0और प्रत्येक के लिए 1 जोड़ता है ], प्रत्येक के लिए 1 घटाएं [और अन्यथा मूल्य रखें। scanrसभी मध्यवर्ती परिणाम रखता है, तो maximumक्या यह काम कर सकता है।

— nimi
स्रोत
5

जावास्क्रिप्ट (ईएस 6), 35 बाइट्स

f=a=>a[0]?Math.max(...a.map(f))+1:0

व्याख्या

पुनरावर्ती फ़ंक्शन जो किसी सरणी की अधिकतम गहराई लौटाता है, या 0यदि कोई संख्या उत्तीर्ण होती है।

var solution =

f=a=>
  a[0]?                   // if a is an array
    Math.max(...a.map(f)) // return the maximum depth of each element in the array
    +1                    // add 1 to increase the depth
  :0                      // if a is a number, return 0

// Test cases
result.textContent =
`[1]                                                              -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7`
.split`\n`.map(t=>(c=t.split`->`.map(p=>p.trim()),c[0]+" == "+c[1]+": "+(solution(eval(c[0]))==c[1]?"Passed":"Failed"))).join`\n`
<input type="text" id="input" value="[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]" />
<button onclick="result.textContent=solution(eval(input.value))">Go</button>
<pre id="result"></pre>
स्निपेट का विस्तार करें

— user81655
स्रोत
यदि यह मदद करता है तो लंबाई में निर्मित इन्स की अनुमति है।
— मार्टिन एंडर
4

MATL , 11 14 15 बाइट्स

'}{'!=dYsX>

इस प्रकार के सरणियों के लिए MATL में घुंघराले ब्रेसिज़ का उपयोग किया जाता है। वैसे भी, इनपुट को एक स्ट्रिंग के रूप में लिया और संसाधित किया जाता है, इसलिए वर्ग कोष्ठक समान रूप से उपयोग किए जा सकते हैं, कोड में दो वर्णों को संशोधित करते हैं।

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

          % implicitly take input as a string (row array of chars)
'}{'!     % 2x1 (column) char array with the two curly brace symbols
=         % 2-row array. First / second row contains 1 where '}' / '{' is found
d         % second row minus first row
Ys        % cumulative sum of the array
X>        % maximum of the array
          % implicitly display result
— लुइस मेंडो
स्रोत
यदि यह मदद करता है तो लंबाई में निर्मित इन्स की अनुमति है।
— मार्टिन एंडर
4

ऑक्टेव, 29 बाइट्स

@(a)max(cumsum(92-(a(a>90))))

[1 और ]-1 से मैप्स , फिर अधिकतम संचयी राशि लेता है।

इनपुट फॉर्म की एक स्ट्रिंग है

S6 = '[1, [[3]], [5, 6], [[[[8]]]], 1]';

नमूना विचारधारा पर चलता है ।

— बीकर
स्रोत
आप का उपयोग करना चाहिए {, }? ओपी में सरणियों के बराबर ऑक्टेव सेल सरणियां हैं, मुझे लगता है
— लुइस मेंडो
@LuisMendo नहीं, क्योंकि यह 2 अतिरिक्त बाइट्स है :) प्लस, क्योंकि मैं वास्तव में कभी भी एरी नहीं बनाता, बस इनपुट स्ट्रिंग को पार्स करता हूं, मुझे नहीं लगता कि यह मायने रखता है। लेकिन आपने मुझे अपने उत्तर में अपेक्षित इनपुट जोड़ने के लिए याद दिलाया है।
— बीकर
सच! लंबे समय तक ASCII कोड
— लुइस मेंडो
@LuisMendo वास्तव में, 1 बाइट लंबे समय तक। उस दूसरी तुलना को केवल '9' से बड़ा होना चाहिए। लेकिन आपको यह विचार मिलता है: D
— बीकर
4

जूलिया, 55 26 बाइट्स

f(a)=0a!=0&&maximum(f,a)+1

यह एक पुनरावर्ती कार्य है जो एक प्रकार की सामग्री के साथ एक आयामी सरणी को स्वीकार करता है Anyऔर एक पूर्णांक देता है। फ़ंक्शन के लिए एक सरणी पास करते समय, सभी कोष्ठक के साथ उपसर्ग करें Any, अर्थात f(Any[1,Any[2,3]])।

दृष्टिकोण बहुत सरल है। एक इनपुट के लिए एक है, हम गुणा एक 0 और से जाँच करें कि क्या परिणाम अदिश 0. है यदि नहीं, तो हम जानते हैं कि एक एक सरणी है, इसलिए हम के प्रत्येक तत्व के लिए समारोह लागू एक हैं, अधिकतम लेते हैं और 1 जोड़ते हैं।

डेनिस के लिए 29 बाइट्स बचाए गए!

— एलेक्स ए।
स्रोत
2
डाट गोल्फ। <भराव>
— एल'एंडिया स्ट्रैटन
3

रूबी, 53 बाइट्स

i=0;p gets.chars.map{|c|i+=('] ['.index(c)||1)-1}.max

STDIN से इनपुट, STDOUT में आउटपुट।

i=0;                 initialize counter variable
p                    output to STDOUT...
gets                 get line of input
.chars               enumerator of each character in the input
.map{|c|             map each character to...
i+=                  increment i (and return the new value) by...
('] ['.index(c)||1)  returns 0 for ], 2 for [, 1 for anything else
-1                   now it's -1 for ], 1 for [, 0 for anything else
                     therefore: increment i on increase in nesting, decrement i
                       on decrease, do nothing otherwise
}.max                find the highest nesting level that we've seen
— Doorknob
स्रोत
यदि यह मदद करता है तो लंबाई में निर्मित इन्स की अनुमति है।
— मार्टिन एंडर
3

जेली, 10 7 बाइट्स

¬;/SпL

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

¬;/SпL  Main link. Input: A (list)

¬        Negate all integers in A. This replaces them with zeroes.
    п   Cumulative while loop.
   S       Condition: Compute the sum of all lists in A.
                      If the sum is an integer, it will be zero (hence falsy).
 ;/        Body:      Concatenate all lists in A.
      L  Count the number of iterations.

अद्यतन करें

इस उत्तर को लिखते समय, मैंने देखा कि रागी सूचियों के लिए जेली अजीब तरह से व्यवहार करती है, क्योंकि मैंने एक सूची की गहराई की गणना उसके वस्तुओं की गहराई की न्यूनतम वृद्धि के रूप में की है ।

यह नवीनतम संस्करण में संबोधित किया गया है, इसलिए निम्न कोड ( 6 बाइट्स ) अब काम करेगा।

¬SSпL

यह उन्हें समवर्ती करने के बजाय सरणी की पंक्तियों को दर्शाता है।

— डेनिस
स्रोत
शायद, ŒḊचुनौती से नया है?
— caird coinheringaahing
आपको सरणियों के आकार से संबंधित किसी भी बिल्ट-इन का उपयोग नहीं करना चाहिए (बिल्ट-इन शामिल है जो इस चुनौती को हल करते हैं, जिससे आपको एक नेस्टेड सरणी के आयाम मिलते हैं)।
— डेनिस
3

गणितज्ञ, 27 20 बाइट्स

Max[#0/@#]+1&[0#]-1&

सरल पुनरावर्ती कार्य।

— LegionMammal978
स्रोत
If7 बाइट्स को सहेजना शून्य करना संभव है । (मुझे पता है कि क्या आप एक संकेत चाहते हैं।)
— मार्टिन एंडर
@ मार्टिनबटनर मैं हार मान लेता हूं ... एक- Replaceआधारित समाधान कम से कम जब तक यह एक है ...
— LegionMammal978
1
Mapएक पूर्णांक पर पिंग एक सेशन नहीं है Max[#0/@#]+1&[0#]-1&:। -1भी तरह भीतरी कॉल के अंदर जा सकते हैं ...&[0#-1]&।
— मार्टिन एंडर
3

PHP, 61 बाइट्स

function d($a){return is_array($a)?1+max(array_map(d,$a)):0;}

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

— टाइटस
स्रोत
मैंने अभी देखा: जेएस में एक ही चीज केवल 35 बाइट्स है। अभी भी php में सुंदर है।
— टाइटस
अच्छा लगा, आपने मुझे हरा दिया। लेकिन मैं अद्यतन मेरा और तुम वापस हरा :)
— aross
3

PHP, 84 72 64 63 60 बाइट्स

नोट: संयुक्त तुलना ऑपरेटर के लिए PHP 7 की आवश्यकता है। इसके अलावा IBM-850 एन्कोडिंग का उपयोग करता है

for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;

इस तरह से चलाएं:

php -r 'for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;' "[1, [[3]], [5, 6], [[[[8]]]], 1]"
  • इसके बजाय स्ट्रिंग प्रतिनिधित्व के ब्रेसिज़ की गिनती करके 12 बाइट्स सहेजे गए
  • स्ट्रिंग तुलनाओं को सरल बनाने और के मामले में चार की क्रमिक संख्या का उपयोग करके 8 बाइट्स बचाए [ और]
  • कास्टिंग नहीं करके एक बाइट को बचाया $i को इंट में बचे। स्ट्रिंग ऑफ़सेट्स को अंतर्निहित रूप से एक इंट में डाला जाता है
  • क्रमिक संख्या के बजाय संयुक्त तुलना ऑपरेटर का उपयोग करके 3 बाइट्स सहेजे गए
— aross
स्रोत
अच्छा विचार, महान गोल्फ! मेरी जाँच करें ।
— टाइटस
2

सी, 98 69 बाइट्स

29 बाइट्स धन्यवाद @DigitalTrauma !!

r,m;f(char*s){for(r=m=0;*s;r-=*s++==93)r+=*s==91,m=r>m?r:m;return m;}

एक तार लेता हैइनपुट के रूप में और पूर्णांक के रूप में परिणाम लौटाता है।

लाइव उदाहरण में: http://ideone.com/IC23Bc

— हटा दिया
स्रोत
2

पायथन 3, 42 39 बाइट्स

-3 बाइट्स Sp3000 के लिए धन्यवाद

यह अनिवार्य रूप से xnor के पायथन 2 समाधान का एक बंदरगाह है :

f=lambda l:"A"<str(l)and-~max(map(f,l))

दुर्भाग्य से, [] > {}एक unorderable typesत्रुटि देता है , ताकि xnor की विशेष चतुर चाल का उपयोग न किया जा सके। इसके स्थान पर, -0123456789ASCII मूल्य से Aकम हैं, जो कि तुलना में कम है [], इसलिए स्ट्रिंग तुलना कार्य करता है।

— एलेंडिया स्ट्राटन
स्रोत
2

CJam (15 बाइट्स)

q~{__e_-M*}h],(

ऑनलाइन डेमो

विच्छेदन

q~      e# Read line and parse to array
{       e# Loop...
  _     e#   Leave a copy of the array on the stack to count it later
  _e_-  e#   Remove a flattened version of the array; this removes non-array elements from
        e#   the top-level array.
  M*    e#   Remove one level from each array directly in the top-level array
}h      e# ...until we get to an empty array
],(     e# Collect everything together, count and decrement to account for the extra []

एक ही लंबाई के लिए बल्कि बदसूरत हैक क्षेत्र में अधिक,

q'[,-{:~_}h],2-
— पीटर टेलर
स्रोत
s/ugly/beautiful/
— डेनिस
@ डेनिस, मैं विशेष रूप से '[,-स्ट्रिंग को स्ट्रिप डाउन करने के लिए उपयोग करने की बात कर रहा था [], जो कि सीमित होने वाली सामग्री पर निर्भर करता है। एरे की सामग्री की परवाह किए बिना, जो दृष्टिकोण समतल होता है।
— पीटर टेलर
दूसरा वाला प्रिटियर है। पहले एक में दो प्रकार के बेमेल ब्रेसेस होते हैं
— साइओस
2

सिड, 40 अक्षर

(39 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प।)

s/[^][]+//g
:;s/]\[//;t
s/]//g
s/\[/1/g

इनपुट: स्ट्रिंग, आउटपुट: यूनिरी नंबर।

नमूना रन:

bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;s/]//g;s/\[/1/g' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111

सेड, 33 वर्ण

(32 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प।)

यदि आउटपुट में अनुगामी रिक्त स्थान की अनुमति है।

s/[^][]+//g
:;s/]\[//;t
y/[]/1 /

इनपुट: स्ट्रिंग, आउटपुट: यूनिरी नंबर।

नमूना रन:

bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;y/[]/1 /' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111
— आदमी काम पर है
स्रोत
2

Hexagony , 61 बाइट्स

संपादित करें : धन्यवाद #Martin एंडर ♦ मुझे 1 बाइट बचाने के लिए अद्भुत -1 ट्रिक से!

|/'Z{>"-\..(.."/'&<'..{>-&,=+<$.{\$._{..><.Z=/...({=Z&"&@!-"

परीक्षण मामलों को सत्यापित करने के लिए इसे ऑनलाइन आज़माएं!

नीचे दी गई छवियों को संशोधित नहीं किया गया है, लेकिन प्रवाह मूल रूप से समान है। यह भी ध्यान दें कि यह वापस आ जाएगा-1 यदि इनपुट एक सरणी नहीं है (यानी बिना[] ) ।

मेरे पास षट्कोण के अंदर बहुत सारे ऑप्स हैं ... मुझे लगता है कि यह निश्चित रूप से अधिक गोल्फ हो सकता है।

व्याख्या

संक्षेप में, यह जोड़ता है -1जब एक का सामना करता है [और जोड़ता है 1जब एक का सामना करता है] । अंत में यह उसके द्वारा प्राप्त अधिकतम प्रिंट करता है।

आइए टेस्ट केस 5 के साथ चलें इसके व्यवहार को देखने के लिए जब यह स्ट्रिंग के साथ चलता है [1, [[3]], [5, 6], [[[[8]]]], 1]:

यह शुरुआत में शुरू होता है और W कोने में इसका इनपुट लेता है:

कोष्ठक

चूंकि अभी भी इनपुट है (शून्य वर्ण \0या ईओएल नहीं), यह शीर्ष पर लपेटता है और क्रिमसन पथ शुरू करता है।

यहाँ क्या होता है जब वहाँ से प्यारा तक ><:

,पढ़ता [बफर में, और {और Zलगातार जेड सेट 90. होने के लिए 'Diff पर ले जाता है और -अंतर की गणना करता है। के लिए [और ]अंतर होगा 1और 3क्रमशः। संख्या और स्थान और अल्पविराम के लिए यह नकारात्मक होगा।

एम 1 M2

फिर हम चलाने (प्राप्त करने के लिए (लाल पथ, हरी पथ पर रैपिंग के बाद शुरू में एक के अंत में एक बार) दो बार -1और 1के लिए resp [और ]। यहाँ हम के नामकरण को बदलने Diffके लिए Value। इस मान को गहराई में जोड़ें। (मैं Z&यह सुनिश्चित करना चाहता था कि यह सही पड़ोसी की नकल करे)। फिर हमने गणना की lastMin - Depthऔर मेमोरी किनारे पर एक नंबर मिला minLR।

फिर हम लागू करते हैं &(हरे रंग के पथ के अंत में) minLR: यदि संख्या <= 0 है, तो यह बाएं मान को कॉपी करता है (यानीlastMin - Depth <= 0 => lastMin <= Depth ) की , अन्यथा यह सही मान लेता है।

हम क्षैतिज नीले रास्ते से लपेटते हैं और हम Z&फिर से देखते हैं जो कॉपी करता है minLR। फिर हमने "&गणना की गई मिन की एक प्रति बनाई। कोष्ठक संतुलित माना जाता है, इसलिए न्यूनतम <= 0 होना चाहिए। लपेटने के बाद, नीला रास्ता बाएं और हिट हो जाता है (, जिससे प्रतिलिपि 1वास्तविक न्यूनतम से कम हो जाती है। पुन: उपयोग करते हुए -, हमने बफ़र के पड़ोसी के रूप में एक और 1-ऑफ कॉपी बनाई:

एम 3

ध्यान दें: copy रूप में नाम दिया गया है1-off

जब नीला रास्ता हिट हुआ \और एक अच्छा मिला" और <उसे मुख्य लूप में वापस पकड़ा जाता है।

जब लूप हिट होता है 1, ,या इनपुट के रूप में अन्य नंबर:

अन्य लोगएम 4

डिफ नेगेटिव हो जाएगा और यह अगले इनपुट के लिए मुख्य लूप में वापस परिलक्षित हो गया।

जब सब कुछ मुख्य लूप के माध्यम से चला गया है, तो हम ईओएल तक पहुंचते हैं जो बफर बनाता है -1और यह अंत में निचले किनारे पर जाता है:

M5

'सांसद को इसमें ले जाता है 1-off copyऔर )इसे बढ़ाता है, और ~नकारात्मकता के साथ इसे सही मैक्स डेप्थ मान मिला जो इसके साथ छपा है!

और कहानी एक के साथ समाप्त होती है @।

मुझे लगता है कि मुझे चीजों को थोड़ा उलझा देना चाहिए। अगर मुझे वेतन वृद्धि और नकार के बिना केवल "मूव बैक" और "प्रिंट" करना पड़ा है, तो मैंने पूर्ण हेक्सागोन का उपयोग किए बिना 2 बाइट्स को अच्छी तरह से बचाया होगा।

करने के लिए बहुत धन्यवाद Timwi के लिए गूढ़ आईडीई और Hexagony Colorer !

— सनी पुं ०
स्रोत
आप का उपयोग करके एक बाइट बचा सकता -1से ,: करने के लिए अंतिम पंक्ति बदलकर @!-".(हालांकि मैं मानता हूँ कि इसे और अधिक एक बहुत बंद दाढ़ी बनाने के लिए या यहां तक कि कुछ पुनर्गठन के साथ कंधे-लंबाई 4 में इस फिट शायद संभव है)।
— मार्टिन एंडर
-1 का उपयोग करने के बारे में सोचा नहीं था! एक बार जब मुझे मेरा कंप्यूटर मिल जाएगा तो मैं उसे संपादित करूंगा। यदि अस्थायी बाएं पड़ोसी पर है, तो मैंने Zउपयोग करने से काफी कुछ बचाया होगा Z&। और अगर निहित के साथ कार्यक्रम शुरू करने के लिए बेहतर तरीके होने चाहिए।
— सनी पुण
2

ब्रेनफक, 48 बाइट्स

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

प्रारूपित:

,
[
  <++[>-<------]>++
  [
    not close paren
    +
    [
      not open paren
      <
    ]
    >>[-]
  ]
  +<,
]
-[<[>+<-]>>]
<.

इनपुट को स्वरूपित करता है (1, ((3)), (5, 6), ((((8)))), 1)और बाइट मान को आउटपुट करता है ।

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

यह मेमोरी लोकेशन द्वारा गहराई को स्टोर करता है, पॉइंटर को दाएं (और बाएं )घुमाता है और अन्य पात्रों की अनदेखी करता है। देखे गए सेल को एक 1ध्वज के साथ चिह्नित किया जाता है , इसलिए मुख्य लूप के अंत में depth + 1वर्तमान सेल के दाईं ओर ध्वज होंगे । फिर अंतिम परिणाम प्रिंट करने के लिए इन्हें जोड़ा जाता है।

एक अलग दृष्टिकोण का उपयोग करके पिछले 69-बाइट समाधान:

,
[
  >>++[<<->>------]<-<++
  [
    not close paren
    >++<+
    [
      not open paren
      >-<[-]
    ]
  ]
  <
  [
    [>+>]
    <[<-<]
    >
  ]
  >>[<+> >+<-]
  ,
]
<.

इस संस्करण में, गहराई और अधिकतम गहराई को कोशिकाओं में स्पष्ट रूप से संग्रहीत किया जाता है।

— मिच श्वार्ट्ज
स्रोत
1

पायथ, 15 13 बाइट्स

-2 बाइट्स बाय @Mtytysen

eSm-F/Ld`Y._z

के संचयी मायने रखता है [और ], और अधिकतम लेता है। Yखाली सरणी है, और इसका स्ट्रिंग प्रतिनिधित्व ( `) सुविधाजनक है []।

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत
यदि यह मदद करता है तो लंबाई में निर्मित इन्स की अनुमति है।
— मार्टिन एंडर
1

CJam, 19 22 23 बाइट्स

0l{_91=\93=-+_}%:e>

मेरे MATL उत्तर के समान विचार।

3 बाइट्स निकालने के लिए पीटर टेलर का धन्यवाद

इसे यहाँ आज़माएँ

0                            push a 0
l                            read line as string
{            }%              map this block on the string
  _91=\93=-                  1 if it's an opening bracket, -1 if closing
           +_                cumulative sum
               :e>           fold maximum function
— लुइस मेंडो
स्रोत
1

पर्ल 5, 34 बाइट्स

32, प्लस टू के लिए -p

{s&]\[|[^][]&&g&&redo}$_=@a=/]/g

डिजिटल ट्रामा के रेटिना उत्तर से चोरी ... जो इस से 26% कम है।:-)

या, समान रूप से:

{s&]\[|[^][]&&g&&redo}$_=y///c/2
— msh210
स्रोत
@ कैस, क्यों? ]कोष्ठक को छोड़कर, भागने की आवश्यकता नहीं है।
— msh210
@ कोको, s&...&...&gप्रतिस्थापन ऑपरेटर है। देखें perldoc.perl.org/perlop.html
— msh210
1

रूबी, 51 वर्ण

( Doorknob के रूबी जवाब के लिए सुधार सुझाव के रूप में शुरू किया गया था, लेकिन अलग-अलग समाप्त हो गया। इसलिए मैंने इसे अलग उत्तर के रूप में पोस्ट किया। गहराई की गिनती के विचार के लिए संकेत। ( ?\\<=>$&से उतरकर '] ['.index(c)) मूल उत्तर पर जाना चाहिए।)

m=i=0
gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max}
p m

इनपुट: स्ट्रिंग, आउटपुट: संख्या।

नमूना रन:

bash-4.3$ ruby -e 'm=i=0;gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max};p m' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
6
— आदमी काम पर है
स्रोत
1

पर्ल 6, 53 बाइट्स

समापन:

{my ($m,$d);/[\[{$d++;$m=max $m,$d}|\]{$d--}|.]*/;$m}

एक तर्क की जरूरत है, उदाहरण के लिए:

{my ($m,$d);/[\[{$d++;$m=max $m,$d}|\]{$d--}|.]*/;$m}("[[[3]][2]]")
3

स्पष्टीकरण:

{ my ($m,$d);                 # start closure, declare variables    

  /                           # start regex match

   [                          # start (non-capturing) group

     \[ {$d++;$m=max $m,$d} | # match [ and track depth; OR

     \] {$d--}              | # match ] and track depth; OR

     .                        # match one character

   ]*                         # repeat group

  /;                          # end regex

  $m                          # return max depth
}
— raiph
स्रोत
1

मिंकोलंग 0.15 , 31 29 24 बाइट्स

लुइस मेंडो के सीजाम के उत्तर से प्रेरणा पर मेरे एल्गोरिथ्म को ओवरहॉल किया और 5 बाइट्स बचाए!

od5&j$ZN.d"["=$r"]"=~++d

यहाँ कोशिश करो!

व्याख्या

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

od           Take character from input and duplicate it (0 if input is empty)
  5&         Pop top of stack and skip the following five spaces if 0
    j$Z      Push the maximum value of the stack
       N.    Output as number and stop.

  d                  Duplicate top of stack for character tests
   "["=              +1 if the character is [
       $r            Swap top two items of stack
         "]"=~       -1 if the character is ]
              ++     Add twice
                d    Duplicate top of stack for the running total
— एलेंडिया स्ट्राटन
स्रोत
1

रूबी, 41 अक्षर

f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}

पैरामीटर: सरणी, वापसी: संख्या।

नमूना रन:

2.1.5 :001 > f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}
 => #<Proc:0x0000000214d258@(irb):1 (lambda)> 

2.1.5 :002 > f[[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]]
 => 6
— आदमी काम पर है
स्रोत
1

Oracle SQL 11.2, 133 बाइट्स

SELECT MAX(d)FROM(SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL)d FROM DUAL CONNECT BY LEVEL<=LENGTH(:1));

संयुक्त राष्ट्र के golfed

SELECT MAX(d)
FROM   (
         SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL) d 
         FROM   DUAL 
         CONNECT BY LEVEL<=LENGTH(:1)
       );

कनेक्ट BY इनपुट स्ट्रिंग में प्रति पंक्ति एक पंक्ति बनाता है।

SUBSTR पंक्ति संख्या के अनुरूप वर्ण को अलग करता है।

DECODE प्रत्येक '[' को 1, प्रत्येक ']' -1 और हर दूसरे वर्ण को 0 में अनुवादित करता है।

विश्लेषणात्मक SUM पूर्ववर्ती पंक्तियों में से प्रत्येक 1, -1 और 0 को सम्‍मिलित करता है, जिसमें वर्तमान पंक्ति भी शामिल है;

MAX रकम की गहराई है।

— Jeto
स्रोत
1

जावा 8, 95

यह एक लंबोदर अभिव्यक्ति है a ToIntFunction<String>। इनपुट को Stringओपी के उदाहरण स्वरूप में लिया जाता है ।

s->{int d=e=-1;for(String t:s.split("[")){d=++e>d?e:d;e-=t.split("]",-1).length()-1;}return d;}

एकदम सीधा। [सीमांकक के रूप में उपयोग करके स्ट्रिंग को विभाजित करें। उनमें से प्रत्येक के लिए, काउंटर को बढ़ाएँ eऔर काउंटर के साथ तुलना करें d, उनमें से बड़े को रखते हुए d। फिर वर्तमान पुनरावृत्ति के स्ट्रिंग ]को इस बार सीमांकक के रूप में विभाजित करें और अतिरिक्त विभाजन की संख्या को घटाएं e।

— जैक अम्मो
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.