आइए निम्नलिखित नियमों द्वारा uकिसी नेस्टेड सूची l(केवल सूचियों वाले) के "अनकैप्ड आकार" फ़ंक्शन को परिभाषित करें :

अगर lखाली है, तो u(l)1 है।
यदि lगैर-रिक्त है, u(l)तो प्रत्येक तत्व के अलिखित आकार के योग के बराबर है l, प्लस एक।

आपका कार्य एक प्रोग्राम (या फ़ंक्शन) लिखना है जो एक सूची को इनपुट और आउटपुट (या रिटर्न) के रूप में सूची के अलिखित आकार के रूप में लेता है।

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

[]                                           ->  1
[[[]],[]]                                    ->  4
[[[]],[[[[]],[]]],[[[]],[[[[]],[[],[[]]]]]]] -> 19
[[[[]]]]                                     ->  4

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

— फल तोड़ना
स्रोत

2

क्या इनपुट को स्ट्रिंग के रूप में लिया जा सकता है, अर्थात उद्धरण चिह्नों को संलग्न करने के साथ? क्या हम ()इसके बजाय उपयोग कर सकते हैं []?

— लुइस मेंडू

क्या हम इस प्रारूप में [[[]][]]इसके बजाय [[[]],[]]आपके दूसरे उदाहरण में इनपुट ले सकते हैं ?

— मुकुल कुमार

का आकार क्या है ["This is some text [with square brackets in] ...[& maybe more than one pair]"]?

— जोनाथन एलन

5

एक इनपुट स्ट्रिंग में एक चरित्र की घटनाओं

— जेम्स

2

@DrMcMoylex मैं असहमत हूं। जबकि गिनती की संख्या ]कई भाषाओं में सबसे छोटा समाधान लगती है, वहाँ भी बहुत सारे उत्तर हैं जो वास्तव में सूची हेरफेर के माध्यम से इस चुनौती को हल करते हैं, और कम से कम एसोलैंग्स में एक निश्चित चरित्र की घटनाओं को गिनना भी गिनती से काफी अलग है एक इनपुट चरित्र की घटनाएँ।

— मार्टिन एंडर

23

रेटिना , 1 बाइट

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

डिफ़ॉल्ट रूप से, रेटिना इनपुट में दिए गए रेगेक्स के मैचों की संख्या को गिनता है। अलिखित आकार []इनपुट में जोड़े की संख्या के बराबर है और इसलिए की संख्या के बराबर है ]।

— मार्टिन एंडर
स्रोत

1

नौकरी के लिए सही उपकरण!

— साइओस

@MartinEnder क्या आप कभी किसी कोडगॉल्फ प्रश्न में बाइट्स को बचाने के लिए अपनी भाषा में नए फ़ंक्शन जोड़ते हैं?

— lois6b

5

@ lois6b पूर्वव्यापी नहीं है, लेकिन मैं भविष्य में उपयोग के लिए इसे और अधिक शक्तिशाली बनाने के लिए कभी-कभी भाषा में सुधार करता हूं। उस ने कहा, इस उत्तर ने रेटिना के पहले संस्करण में पीछे से काम किया होगा जब यह सिंटैक्टिक ओवरहेड के बिना इनपुट के खिलाफ एक एकल रेगेक्स (/ प्रतिस्थापन) को चलाने का एक तरीका था।

— मार्टिन एंडर

11

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

LeafCount

पता चला कि इसके लिए एक अंतर्निहित है ...

ध्यान दें कि यदि सूची में वास्तव में गैर-सूची तत्व शामिल हैं तो यह काम नहीं करेगा। LeafCountवास्तव में क्या करता है परमाणु उपपदों की संख्या की गणना करता है। इनपुट के लिए {{}, {{}}}, अभिव्यक्ति वास्तव में पढ़ती है:

List[List[], List[List[]]]

यहां परमाणु उप-विभाजन वास्तव में प्रमुख हैं List ।

— मार्टिन एंडर
स्रोत

1

Mathematica में हर चीज के लिए एक अंतर्निहित ...

— kirbyfan64sos

2

@ चैलेंजर 5 ओए, साहित्यिक चोरी। : पी

— मार्टिन एंडर

7

ब्रेनफक, 71 61 59 बाइट्स

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

प्रश्न में दिए गए प्रारूप में एसटीडीआईएन से इनपुट लेता है, और उस चरित्र को आउटपुट करता है जिसका एएससीआईआई कोड सूची का "अलिखित आकार" है।

मैं अभी भी ब्रेनफक में एक पूर्ण शौकिया हूं, इसलिए सबसे अधिक संभावनाएं हैं जो अभी भी बनाई जा सकती हैं।

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

Ungolfed:

read input to tape
>>+[>,]<
current tape: (0 0 1 a b *c)
where abc represents input and * is IP

now we loop over each character (from the end)
this loops assumes we are starting on the (current) last char
and it zeroes the entire string by the time it finishes
[

  subtract 91 from this character
  technically we only subtract 85 here and correct the answer
  with the 6 minus signs below
  >-[<->---]
  current tape: (0 0 1 a b cminus91 *0)

  invert the result and put that in the next cell
  +<------[->[-]<]>
  current tape: (0 0 1 a b 0 *c==91)

  move that result back to the original cell
  [-<+>]<
  current tape: (0 0 1 a b *c==91)

  if the result is true we found a brace
  increment the very first cell if so
  [-<[<]<+>>[>]]<
  current tape: (count 0 1 a *b)

]
current tape: (count *0)

<.

— Doorknob
स्रोत

5

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

f=([x,...a])=>x?f(x)+f(a):1

मैं इसे प्यार करता हूँ जब एक पुनरावृत्ति इस सफाई से बाहर निकलता है। यह मूल रूप से इनपुट की एक गहराई से पहली खोज है, जब भी किसी सरणी के अंत तक 1 को जोड़ा जाता है।

यदि कोई खाली सरणी JS में झूठी थी, तो यह 24 बाइट्स हो सकती है:

f=a=>a?f(a.pop())+f(a):1

लेकिन अफसोस, यह नहीं है। अन्य प्रयास:

f=a=>a.reduce((n,x)=>n+f(x),1) // Works, but 3 bytes longer
f=a=>a.map(x=>n+=f(x),n=1)&&n  // Works, but 2 bytes longer
f=a=>(x=a.pop())?f(x)+f(a):1   // Works, but 1 byte longer
f=a=>a[0]?f(a.pop())+f(a):1    // Works, but same byte count
f=a=>a+a?f(a.pop())+f(a):1     // Doesn't work on any array containing 1 sub-array
f=a=>a-1?f(a.pop())+f(a):1     // Same

— ETHproductions
स्रोत

चाहेंगे f=a=>a[0]?f(a.pop())+f(a):1काम करते हैं? (एक ही बाइट गिनती हालांकि।)

— नील

@ नील, हाँ, यह उन समाधानों में से एक है जो मैंने पहले ही आजमाए हैं। मुझे नहीं लगता कि किसी भी छोटे को प्राप्त करना संभव है ...

— ETHproductions

(वैसे, मैं फालतू के लिए गया था f=a=>a.reduce((n,a)=>n+f(a),1)। अब, f=(n,a)=>n+a.reduce(f,1)केवल 24 बाइट्स हैं, लेकिन दुख की बात है कि पैरामीटर गलत क्रम में हैं।)

— नील

@ नील मैंने वास्तव में 1 बाइट को छोटा करने के अलावा पहले किया था:f=a=>a.map(a=>n+=f(a),n=1)&&n

— ETHproductions

आह, क्षमा करें, मैंने संपादित इतिहास ब्राउज़ करने के लिए नहीं सोचा था।

— नील

4

पर्ल, 9 8 7 + 1 = 8 बाइट्स

-pध्वज की आवश्यकता है

$_=y;[;

@ बडा दो बाइट के लिए धन्यवाद बचाता है (मैं इस अर्धविराम कारनामे btw से प्यार कर रहा हूँ)

— गेब्रियल बेनामी
स्रोत

1

-p1 बाइट को बचाने के लिए;)

— दादा

आप y;[;एक और बाइट बचाने के लिए उपयोग कर सकते हैं

— दादा

4

CJam , 7 5 बाइट्स

2 बाइट्स निकालने के लिए पीटर टेलर का धन्यवाद! (के e=बजाय f=:+)

r'[e=

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

r         e# Read input
 '[       e# Push open bracket char
   e=     e# Count occurrences. Implicit display

— लुइस मेंडो
स्रोत

3

05AB1E , 4 बाइट्स

I'[¢

I    Get input as a string
 '[¢ Count the opening square brackets and implicitly print them

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

मुझे लगता है कि इसे और अधिक गढ़ा जा सकता है लेकिन यह 'मैं' अनिवार्य है, अन्यथा इनपुट को एक स्ट्रिंग के बजाय एक वास्तविक सरणी माना जाता है

— Osable
स्रोत

2

"[[[]],[[[[]],[]]],[[[]],[[[[]],[[],[[]]]]]]]"इनपुट में उस Iआवश्यकता को हटा दिया जाता है, हालांकि मुझे नहीं पता कि क्या इसकी अनुमति है।

— मैजिक ऑक्टोपस Urn

1

@carusocomputing: वर्तमान में इसकी अनुमति नहीं है, लेकिन यह बदल सकता है (मैं लुइस को ओपी से यही प्रश्न पूछते हुए देखता हूं)

— एमिग्ना

डांग, मुझसे 14 घंटे पहले।

— ओलिवर नी

3

भूलभुलैया , 8 बाइट्स

&-
#,(/!

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

व्याख्या

यह बिटकॉइन जादू के माध्यम से उद्घाटन कोष्ठक को गिनता है। अगर हम बिटवाइज़ की और के चरित्र कोड के परिणामों पर विचार [, ,और ]साथ 2, हम पाते हैं:

[ , ]
2 0 0

इसलिए यदि हम प्रत्येक वर्ण के लिए इस ऑपरेशन के परिणाम को जोड़ते हैं, तो हमें वह मूल्य मिलता है जो हम चाहते हैं।

कोड के लिए ही, शुरुआत में 2x2 ब्लॉक एक छोटा लूप है। पहली पुनरावृत्ति पर &-वास्तव में कुछ भी नहीं होता सिवाय इसके कि वे स्टैक के नीचे निहित लोगों के ऊपर एक स्पष्ट शून्य डालते हैं। यह चलने वाला कुल होगा (और बाद में बाइट को बचाने के लिए यह वास्तव में नकारात्मक होगा)। फिर लूप इस प्रकार है:

,   Read character. At EOF this gives -1 which causes the instruction pointer to
    leave the loop. Otherwise, the loop continues.
#   Push the stack depth, 2.
&   Bitwise AND.
-   Subtract from running total.

एक बार जब हम लूप छोड़ देते हैं, तो निम्न रैखिक बिट निष्पादित होता है:

(   Decrement to turn the -1 into a -2.
/   Divide negative running total by -2 to get desired result.
!   Print.

आईपी फिर एक मृत हिट और चारों ओर मुड़ता है। जब यह /फिर से निष्पादित करने का प्रयास करता है , तो कार्यक्रम शून्य से प्रयास विभाजन के कारण समाप्त हो जाता है।

— मार्टिन एंडर
स्रोत

3

पायथन 3 2, 36 23 बाइट्स

lambda x:`x`.count("[")

मैंने देखा कि स्ट्रिंग के प्रतिनिधित्व में u(l)संख्या के बराबर है , इसलिए यह कार्यक्रम ऐसा करने की कोशिश करता है। यह शायद यह करने के लिए एक और रास्ता खोजने के द्वारा आगे गोल्फ हो सकता है, हालांकि ...[l

— फल तोड़ना
स्रोत

6

23 बाइट्स:lambda x:`x`.count("[")

— acrolith

2

पायथन, 26 बाइट्स

f=lambda a:sum(map(f,a))+1

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

— ETHproductions
स्रोत

2

सी #, 46 41 बाइट्स

int u(string l){return l.Count(c=>c=='[');}

l नेस्टेड सूची की स्ट्रिंग है। इसका परीक्षण यहां करें ।

— एवेन्यू
स्रोत

एक कोड ब्लॉक में प्रारूपण के लिए 4 रिक्त स्थान (कोड से पहले) का उपयोग करें

— user41805

@KritiiLithos ओह, मैं सही ढंग से करना भूल गया। इसे इंगित करने के लिए धन्यवाद :)

— Ave

और यह एक कार्यक्रम या एक समारोह होना चाहिए, यह न तो है।

— user41805

@KritiiLithos उफ़, इसे इंगित करने के लिए धन्यवाद, बस इसे ठीक कर दिया।

— Ave

2

आप घुंघराले ब्रेसिज़ को गिरा सकते हैं और returnएक अभिव्यक्ति शारीरिक फ़ंक्शन का उपयोग करके। इसके अलावा charनिहित रूप से intआप इसके 91बजाय का उपयोग कर सकते हैं '[': int u(string l)=>l.Count(c=>c==91);इसके अलावा, आप फ़ंक्शन हस्ताक्षर को छोड़ सकते हैं और एक लैम्ब्डा विधि का उपयोग कर सकते हैं l=>l.Count(c=>c==91);:।

— दूध

2

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

ß€S‘

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

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

ß€S‘  Main link. Argument: A (array)

ß€    Map the main link over A.
  S   Sum. For empty arrays, this yields zero.
   ‘  Increment.

— डेनिस
स्रोत

2

रूबी, 13 (+1) बाइट्स

p $_.count ?[

-nतर्क के साथ कहा जाता है:

ruby -ne 'p $_.count ?['

संपादित करें: वास्तव में उत्तर को प्रिंट करने के लिए बदल दिया गया है

— ली डब्ल्यू
स्रोत

यह कुछ भी नहीं लगता है। (जब तक कि यह एक REPL उत्तर न हो, जिस स्थिति में भाषा को Ruby REPL के रूप में निर्दिष्ट किया जाना चाहिए।)

— मार्टिन एंडर

@ मर्टिन एंडर allowed विनिर्देश ने इसे प्रिंट करने के बजाय मूल्य वापस करने की अनुमति दी।

— ली डब्ल्यू

यह फ़ंक्शन सबमिशन को संदर्भित करता है। उदाहरण के ->s{s.count ?[}लिए एक वैध जमा करना होगा।

— मार्टिन एंडर

क्या यह एक सामान्य नियम है?

— ली डब्ल्यू

1

स्वीकार्य I / O विधियों के लिए यह पोस्ट देखें।

— मार्टिन एंडर

2

रेगेक्स, 1 बाइट

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

— ओलिवर नी
स्रोत

मुझे यकीन नहीं है कि रेगेक्स एक प्रोग्रामिंग भाषा है, लेकिन भले ही यह हो, पहले से ही एक समान रेटिना का उत्तर है ।

— डेनिस

2

ब्रेन-फ्लैक , 63 , 61 बाइट्स

{({}[(((()()()){}){}()){({}[()])}{}]){{}(<>{}())(<>)}{}}<>

इसे ऑनलाइन आज़माएं! कोड के 58 बाइट्स, और +3 के लिए-a ASCII इनपुट को सक्षम करने झंडे के ।

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

#While non-empty:
{

    #subtract
    ({}[

    #91
    (((()()()){}){}()){({}[()])}{}

    ])

    #if non-zero
    {

        # Remove the difference
        {}

        #Increment the counter on the other stack
        (<>{}())

        #Push a zero onto the main stack
        (<>)
    }

    #pop the left-over zero
    {}

#endwhile
}

#Move back to the stack with the counter, implicitly display
<>

— जेम्स
स्रोत

2

Befunge , 22 18 16 बाइट्स

~:0#@`#.!#$_3%!+

TryItOnline!

संपादित करें: 4 बाइट्स बंद करने के लिए मार्टिन एंडर का धन्यवाद !

Edit2: दो और अधिक अनुकूलन के लिए डेविड होल्डरनेस को श्रेय

— ब्रायन ग्रैडिन
स्रोत

1

///, 13 बाइट्स

/[/0//]///,//

उत्पादन में एकता

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

स्पष्टीकरण:

/[/0/          Replace every [ with 0
     /]///,//  Remove every ] and ,

— acrolith
स्रोत

आप उच्चारण कैसे करते हैं ///?

— डकैत

@ रोपटा स्लैश

— एक्रोलिथ

1

PHP, 35 बाइट्स

<?=preg_match_all('/\[/',$argv[1]);

preg_match_all नियमित अभिव्यक्ति के सभी मिलान उदाहरणों को खोजता है और एक नंबर देता है, यही कारण है कि लघु इको टैग की आवश्यकता होती है।

अधिकांश उत्तरों की तरह, यह [इनपुट में संख्या को गिनता है और उस संख्या को आउटपुट करता है

— gabe3886
स्रोत

1

यदि आप ]इसके बजाय उपयोग करते हैं [, तो आपको इससे बचना नहीं पड़ेगा।

— मार्टिन एंडर

2

count_chars()[91];बहुत कुछ करता है लेकिन कम है।

— user59178

1

रैकेट 82 बाइट्स

(define n 0)(let p((l l))(if(null? l)(set! n(+ 1 n))(begin(p(car l))(p(cdr l)))))n

Ungolfed:

(define (f l)
  (define n 0)
  (let loop ((l l))
    (if (null? l)
        (set! n (add1 n))
        (begin (loop (first l))
               (loop (rest l)))))
  n)

परिक्षण:

(f '[]) 
(f '[[[]] []]) 
(f '[[[]] [[[[]] []]] [[[]] [[[[]] [[] [[]]]]]]]) 
(f '[[[[]]]])

आउटपुट:

— rnso
स्रोत

1

वी , 10 बाइट्स

ÓÛ
ÒC0@"

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

इसमें कुछ अनपेक्षित वर्ण हैं, यहाँ पठनीय संस्करण है:

ÓÛ
Ò<C-a>C0<esc>@"

<C-a>"ctrl-a" (ASCII 0x01) का <esc>प्रतिनिधित्व करता है और भागने की कुंजी (ASCII 0x1b) का प्रतिनिधित्व करता है ।

ÓÛ              " Remove all '['s
                "
Ò<C-a>          " Replace what's left with '<C-a>' (the increment command)
      C         " Delete this line
       0<esc>   " And replace it with a '0'
             @" " Run what we just deleted as V code (A bunch of increment commands

अधिक मजेदार, कम गोल्फ संस्करण:

o0kòf]m`jòd

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

o0<esc>                     " Put a '0' on the line below us
       k                    " Move back up a line
        ò               ò   " Recursively:
         f]                 "   Move to a right-bracket
           m`               "   Add this location to our jumplist
             j              "   Move down a line
              <C-a>         "   Increment this number
                   <C-o>    "   Move to the previous location
                         d  " Delete the bracket line
                            " Implicitly display

— जेम्स
स्रोत

1

स्काला, 15 बाइट्स

s=>s.count(92<)

Ungolfed:

s=>s.count(c=>92<c)

countमायने रखता है कि कितने तत्व एक विधेय को संतुष्ट करते हैं, इस मामले में 92<, जो विधि <है 92।

— corvus_192
स्रोत

1

ओ , 15 बाइट्स

i~{1\{nJ+}d}J;J

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

इनपुट में, किसी भी कॉमा को या तो हटा दिया जाना चाहिए या रिक्त स्थान द्वारा प्रतिस्थापित किया जाना चाहिए।

व्याख्या

i~{1\{nJ+}d}J;J
i                Read a line of input.
 ~               Evaluate it.
  {        }J;   Define a function and save it into the `J` variable.
                 Currently, the input array is at the top of the stack.
   1\            Push 1 and swap it with the input array.
     {   }d      For each element in the array...
                 Because the array was popped by `d`, 1 is at the TOS.
      nJ+        Recurse and add the result to 1.
              J  Initiate the function call.
                 The result is printed implicitly.

यदि हमें एक स्ट्रिंग पर काम करने की अनुमति है: 10 बाइट्स

ie\']-e@-p

— kirbyfan64sos
स्रोत

1

> <> , 21 20 18 बाइट्स

0i:0(90.;n?|3%0=+!

संपादित करें: गोटो बयानों के लिए स्कोर 1!

संपादित करें 2: स्पष्ट रूप से> <> Befunge से अलग है कि यह रैपिंग के बाद गैर-शून्य IP ऑफ़सेट की अनुमति देता है (दूसरे शब्दों में, एक trampoline निर्देश का उपयोग करके, मैं (0, 0) के बजाय 1 (0, 0) पर लपेट सकता हूं)। दिलचस्प।

TryItOnline!

— ब्रायन ग्रैडिन
स्रोत

1

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

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

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

यह इनपुट वर्णों की संख्या को 3 से विभाज्य करता है, अर्थात की संख्या ] वर्णों ।

वैकल्पिक 34-बाइट समाधान [सीधे वर्णों की गिनती और 8-बिट कोशिकाओं पर निर्भर करता है:

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

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

1

सी, 48 46 बाइट्स

दो बाइट्स kirbyfan64sos के लिए धन्यवाद सहेजा गया

i;f(char*v){for(i=0;*v;i+=*v++==91);return i;}

i;f(char*v){for(i=0;*v;*v++^91?0:i++);return i;}

टेस्ट कोड

main()
{
    printf("%d\n", f("[]"));
    printf("%d\n", f("[[[]] []]"));
    printf("%d\n", f("[[[]] [[[[]] []]] [[[]] [[[[]] [[] [[]]]]]]]"));
}

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

a.exe
1
4
19

— cleblanc
स्रोत

3 बाइट्स को बचाने के *v++^91?0:i++लिए बदलें i+=*v==91।

— kirbyfan64sos

@ kirbyfan64sos धन्यवाद! मुझे अभी भी वी बढ़ाने की आवश्यकता है लेकिन मैं i+=*v++==91दो बाइट्स को बचाने के लिए उपयोग कर सकता हूं ।

— क्लेब्लांक

1

टिनिइलिस उत्तर , 39 बाइट्स

(d u(q((L)(i L(s(u(h L))(s 0(u(t L))))1

एक फ़ंक्शन को परिभाषित करता uहै जिसे पसंद किया जा सकता है(u (q ((())()) )) (दूसरे परीक्षण मामले के लिए) । उत्तर में ऐसा करने से ऑटो-बंद कोष्ठक के कारण 4 बाइट बचती हैं।

व्याख्या

(d u                                      )  Define u as
    (q                                   )    the following, unevaluated
      (                                 )     list (which acts as a function in tinylisp):
       (L)                                   Given arglist of one element, L, return:
          (i L                         )     If L (is nonempty):
              (s(u(h L))             )        Call u on head of L and subtract
                        (s 0        )          0 minus
                            (u(t L))           call u on tail of L
                                      1      Else, 1

x-(0-y)क्योंकि tinylisp एक अंतर्निहित इसके अलावा समारोह, केवल घटाव नहीं है निर्माण आवश्यक है।

— DLosc
स्रोत

1

बेगुंज -98 , 12 11 10 9 बाइट्स

~3%!+2j@.

TryItOnline!

संपादित करें: बाइट को हटाने के लिए मार्टिन एंडर को धन्यवाद

— ब्रायन ग्रैडिन
स्रोत

1

हास्केल, 20 19 17 बाइट्स

f s=sum[1|']'<-s]

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

सूची को स्ट्रिंग के रूप में लेता है और 1प्रत्येक के लिए एक सूची में रखता है ], फिर सभी 1s को पूरा करता है ।

पॉइंटफ्री संस्करण: (19 बाइट्स)

length.filter(>'[')

मान लें , [ ]कि स्ट्रिंग में केवल चार्ट हैं। सभी वर्णों से अधिक प्राप्त करने के लिए सूची को फ़िल्टर करता है [, जो सभी हैं ]और लंबाई लौटाते हैं।

उपयोग:

Prelude> length.filter(=='[')$"[[[]],[[[[]],[]]],[[[]],[[[[]],[[],[[]]]]]]]"
19

— Laikoni
स्रोत

0

बैश + कोरुटिल्स, 29 बाइट्स

f()(echo $1|tr -d -c [|wc -c)

— Angs
स्रोत

आप इसे हटा सकते हैं और बस कर सकते हैं tr -d -c [|wc -c, जो डिफ़ॉल्ट रूप से मानक इनपुट से सूची को पढ़ेगा।

— kirbyfan64sos

0

DASH , 14 बाइट्स

(ss[len;!> ="]

बस मायने रखता है ]। उपयोग:

(ss[len;!> ="]"])"[[]]"

बोनस समाधान, 15 बाइट्स

a\@+1sum ->#a#0

यह एक पुनरावर्ती एक वास्तविक सूची से गिना जाता है। उपयोग:

(f\@+1sum ->#f#0)[[]]

— मामा फन रोल
स्रोत

किसी सूची का "बिना आकार का" ढूंढें

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

रेटिना , 1 बाइट

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

ब्रेनफक, 71 61 59 बाइट्स

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

पर्ल, 9 8 7 + 1 = 8 बाइट्स

CJam , 7 5 बाइट्स

05AB1E , 4 बाइट्स

भूलभुलैया , 8 बाइट्स

व्याख्या

पायथन 3 2, 36 23 बाइट्स

पायथन, 26 बाइट्स

सी #, 46 41 बाइट्स

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

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

रूबी, 13 (+1) बाइट्स

रेगेक्स, 1 बाइट

ब्रेन-फ्लैक , 63 , 61 बाइट्स

Befunge , 22 18 16 बाइट्स

///, 13 बाइट्स

PHP, 35 बाइट्स

रैकेट 82 बाइट्स

वी , 10 बाइट्स

स्काला, 15 बाइट्स

ओ , 15 बाइट्स

व्याख्या

यदि हमें एक स्ट्रिंग पर काम करने की अनुमति है: 10 बाइट्स

> <> , 21 20 18 बाइट्स

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

सी, 48 46 बाइट्स

टिनिइलिस उत्तर , 39 बाइट्स

व्याख्या

बेगुंज -98 , 12 11 10 9 बाइट्स

हास्केल, 20 19 17 बाइट्स

बैश + कोरुटिल्स, 29 बाइट्स

DASH , 14 बाइट्स

बोनस समाधान, 15 बाइट्स