आपको एक तार दिया जाएगा s। यह गारंटी दी जाती है कि स्ट्रिंग में बराबर और कम से कम एक [एस और ]एस है। यह भी गारंटी है कि कोष्ठक संतुलित हैं। स्ट्रिंग में अन्य वर्ण भी हो सकते हैं।

इसका उद्देश्य टुपल्स या प्रत्येक [और ]जोड़ी के सूचकांकों की सूची को आउटपुट / वापस करना है ।

नोट: स्ट्रिंग शून्य-अनुक्रमित है।

उदाहरण: !^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][]लौट जाना चाहिए

[(8, 41), (20, 33), (21, 27), (36, 39), (42, 48), (49, 50)]या इसके बराबर कुछ। टुपल्स आवश्यक नहीं हैं। सूचियों का भी उपयोग किया जा सकता है।

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

input:[[asdf][][td([)ty54g% ]hg[[f]u][f[[jhg][gfd]sdf]sdfs]ghd]fr43f]
output:[(0, 62),(1, 6), (7, 8), (9, 56), (13, 22), (25, 30), (26, 28), (31, 52), (33, 47), (34, 38), (39, 43)]
input:[[][][][]][[][][][[[[(]]]]]))
output:[(0, 9), (1, 2), (3, 4), (5, 6), (7, 8), (10,26),(11, 12), (13, 14), (15, 16), (17, 25), (18, 24), (19, 23), (20, 22)]
input:[][][[]]
output:[(0, 1), (2, 3), (4, 7), (5, 6)]
input:[[[[[asd]as]sd]df]fgf][][]
output:[(0, 21), (1, 17), (2, 14), (3, 11), (4, 8), (22, 23), (24, 25)]
input:[]
output:[(0,1)]
input:[[(])]
output:[(0, 5), (1, 3)]

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

code-golf string balanced-string

— पवनचक्की कुकीज़
स्रोत

1

क्या आउटपुट ऑर्डर मायने रखता है?

— wastl

1

नहीं, यह नहीं है।

— विंडमिल कुकीज़

21

"नोट: स्ट्रिंग शून्य-अनुक्रमित है।" - इस तरह की चुनौतियों में एक सुसंगत अनुक्रमण चुनने के लिए कार्यान्वयन की अनुमति देना बहुत आम है (लेकिन यह निश्चित रूप से, आपके ऊपर है)

— जोनाथन एलन

1

क्या हम वर्णों के एक सरणी के रूप में इनपुट ले सकते हैं?

— शैगी

7

एक बाइट का खर्च ...

— डायलन

13

ब्रेन-फ्लैक क्लासिक , 108 बाइट्स

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

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

[जब भी हम हिट करते हैं, प्रत्येक स्टैक सही स्टैक में खुलता है, और आउटपुट करता है ]।

— Nitrodon
स्रोत

12

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

s=[];i=0
for c in input():
 if'['==c:s+=i,
 if']'==c:print s.pop(),i
 i+=1

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

— छड़ी
स्रोत

5

जावास्क्रिप्ट, 69 62 बाइट्स

ट्रेन घर पर गोल्फ का एक त्वरित सा। शायद में सुधार किया जा सकता है।

वर्णों के एक सरणी के रूप में इनपुट लेता है और एक वस्तु को आउटपुट करता है जिसमें की [एस के सूचकांकों और उनके मूल्यों को उनके संबंधित ]एस के सूचक होते हैं ।

a=>a.map((x,y)=>x==`]`?o[a.pop()]=y:x==`[`&&a.push(y),o={})&&o

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

— झबरा
स्रोत

यह मेरे दिमाग को उड़ा देता है कि आप मोबाइल पर गोल्फ कर सकते हैं। : पी

— ओलिवर

2

@ ओलिवर, यह मेरे दिमाग को उड़ा देता है कि मैं (बस के बारे में) टचस्क्रीन पर टाइप कर सकता हूं - कीबोर्ड वापस ला सकता हूं !

— शैगी

4

हास्केल , 92 79 बाइट्स

g(u:a)n(']':x)=(u,n):g a(n+1)x
g a n(s:x)=g([n|s=='[']++a)(n+1)x
g[]_[]=[]
g[]0

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

व्याख्या

हम एक फ़ंक्शन बनाते हैं gजिसमें 3 तर्क होते हैं।

a, जो सभी बेजोड़ [एस का स्थान है ।
n, जो संसाधित किए गए वर्णों की संख्या है
x जो कि वर्णों के अनप्रोसेस्ड है।

अगर हमारा पहला किरदार है ]तो हम uसामने वाले से दूर हो जाते हैं aऔर (u,n)साथ ही जो कुछ भी बचता है उसे वापस कर देते हैं ।

g(u:a)n(']':x)=(u,n):g a(n+1)x

यदि हमारा पहला चरित्र नहीं है ], तो वह [या कुछ और है, हम वृद्धि करते हैं nऔर [n|s=='[']सामने जोड़ते हैं a। [n|s=='[']होगा [n]यदि s=='['और []अन्यथा।

g a n(s:x)=g([n|s=='[']++a)(n+1)x

यदि हम वर्णों से बाहर हैं तो हम खाली सूची लौटाते हैं।

g[]_[]=[]

— गेहूं का जादूगर
स्रोत

1

वाह, पुनरावर्ती कार्यों का कुछ अच्छा टुकड़ा है। मैं हास्केल पर एक शुरुआत कर रहा हूं, इसने मुझे प्रभावित किया :)

— विंडमिल कुकीज़

@ गन्नू-कोई नहीं धन्यवाद! यह उत्तर शायद इष्टतम नहीं है, इसलिए मैं आपको इसे आज़माने और हरा देने के लिए प्रोत्साहित करूंगा, या गंभीर हास्केल गोल्फरों के आने तक प्रतीक्षा करूंगा।

— गेहूं जादूगर

मैं बेहतर प्रतीक्षा करूंगा जब तक कि गंभीर हास्केल गोल्फर्स न आ जाए

— विंडमिल कुकीज़

4

जावा 10, 95 बाइट्स

int[]यूनिकोड कोड बिंदुओं के रूप में इनपुट स्ट्रिंग लेने वाला एक शून्य लंबोदर ।

s->{int r=0,w=0;for(var c:s){if(c==91)s[w++]=r;if(c==93)System.out.println(s[--w]+","+r);r++;}}

यह ऑनलाइन की कोशिश करो

Ungolfed

s -> {
    int r = 0, w = 0;
    for (var c : s) {
        if (c == 91)
            s[w++] = r;
        if (c == 93)
            System.out.println(s[--w] + "," + r);
        r++;
    }
}

स्वीकृतियाँ

स्टैक के रूप में इनपुट स्ट्रिंग का उपयोग करने के विचार के लिए जोनाथन फ्रेच को धन्यवाद ( यहां )

— जेकब
स्रोत

आपको परिभाषित करना चाहिए rऔर wकोड के हिस्से के रूप में, मापदंडों के रूप में नहीं s->{int r=0,w=0;...}:।

— ओलिवियर ग्रेजायर

@ OlivierGrégoire अस्पष्ट की तरह है, लेकिन ऐसा लगता है कि यह कई खाली आदानों को कवर करने का इरादा था।

— जैकब

1

आपके द्वारा उद्धृत उत्तर स्पष्ट रूप से प्रश्न का उत्तर देता है "क्या हमें एक खाली पैरामीटर लेने की अनुमति है इसके बजाय हम कहीं भी उपयोग नहीं करेंगे ?"। आप इन इनपुट्स का उपयोग कर रहे हैं। मुझे यहां बिल्कुल भी अस्पष्टता नजर नहीं आती।

— ओलिवियर ग्रेजायर

प्रश्न का संपादित हिस्सा चर को "नो-यूज़" करने के बारे में बिल्कुल स्पष्ट करता है।

— ओलिवियर ग्रेगोइरे

सही, लेकिन फिर शीर्ष उत्तर (1) में यह नहीं बताया गया है कि इनपुट अप्रयुक्त हैं, (2) निर्दिष्ट करें कि अतिरिक्त इनपुट के मूल्य क्या हैं, और (3) अतिरिक्त इनपुट के दुरुपयोग की संभावना का उल्लेख करते हैं? भले ही, मैं चर ले जाऊँगा।

— जैकब

4

विम, 89 बाइट्स

:s/\(.\)/\1<C-V><C-M>/g|g/^\[/ :norm %mm%:pu! =line('.').','.line(\"'m\")<C-V><C-M><C-X>$<C-X>J
:v/\[/d|%s/\[//g

एनोटेट

:s/\(.\)/\1<C-V><C-M>/g            " one character per line
|g/^\[/                            " for each opening square bracket:
  :norm %mm%                       "   mark the line with the matching bracket
  :pu! =line('.').','.line(\"'m\") "   write the line numbers to preceeding line
  <C-V><C-M><C-X>$<C-X>J           "   convert to 0-based counting and join lines
:v/\[/d                            " remove all non-opening bracket lines
|%s/\[//g                          " remove brackets

<C-V>0x16 है। <C-M>0x0d है। <C-X>0x18 है।

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

— रे
स्रोत

4

QBasic (QB64), 137 127 112 बाइट्स

INPUT a$
for i=0to len(a$)
c$=mid$(a$,i+1,1)
if"["=c$then
b(n)=i
n=n+1
elseif"]"=c$then
n=n-1
?b(n),i
endif
next

हमें ~~चार~~ दो बाइट्स की आवश्यकता है क्योंकि चुनौती के लिए 0-इंडेक्सिंग की आवश्यकता होती है। मेरी पहली QBasic पोस्ट, प्रतिक्रिया की सराहना की है।

10 बाइट्स स्टीनबर्ग के लिए धन्यवाद
3 बाइट्स के लिए धन्यवाद एग्री द आउटगोलर
यूनिक्स फ़ाइल प्रारूप में बचत करके 12 बाइट्स ( \r\n-> \n)

निष्पादित होने पर ऐसा दिखता है:

— wastl
स्रोत

अच्छा है। संकेत के युगल: उपयोग ?के बजाय print(संकलक यह करने के लिए ऑटो का विस्तार print), आप उद्धृत तार के बीच और रिक्त स्थान की जरूरत नहीं है THENमें IFहै, और आप ड्रॉप कर सकते हैं iके बाद NEXT।

— स्टेनबर्घ

@steenbergh हुह, लगता है मैं व्हॉट्सएप हटाना भूल गया ... लेकिन मैंने एक को हटा दिया 0और to? मैं उलझन में हूँ ...

— wastl

1

सुनिश्चित करें कि QB64 के बारे में नहीं है, लेकिन मुझे लगता है कि if c$="["हो सकता है if"["=c$, elseif c$="]"हो सकता है elseif"]"=c$, end ifहो सकता है endif, और, उत्पादन में मामूली परिवर्तन के साथ, ?b(n),iहो सकता है ?b(n)i(QBasic 1.1 मैं क्या उपयोग करते हैं, अपने मामले अलग हो सकता है) है।

— आउटगॉल्फ

@EriktheOutgolfer सभी लेकिन ?b(n)iकाम किया

— बजे

3

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

VQIqN\[=+YZ)IqN\],.)YZ)=hZ

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

व्याख्या

VQIqN\[=+YZ)IqN\],.)YZ)=hZ
VQ                     =hZ   For each character in the input (indexed by Z)...
  IqN\[=+YZ)                 ... if the character is [, add the index to Y...
            IqN\],.)YZ)      ... if the character is ], output the previous index
                             and current index.

अच्छा! मेरा भोला दृष्टिकोण 36 बाइट्स था C,x"[" MQ #.e*qb\[t+lhfSI/LT"[]"._>Q,। संपादित करें: मैं अपना थोड़ा सा भी गोल्फ में सफल रहा, मैं अब 30 से नीचे हूँ।

— श्री एक्सकोडर

3

आर , 141 133 115 112 112 बाइट्स

function(y,x=utf8ToInt(y)){for(i in seq(x)){if(x[i]==91)F=c(i,F);if(x[i]==93){T=c(T,F[1],i);F=F[-1]}};T[-1]}

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

कुछ खास नहीं। 1-अनुक्रमित, क्योंकि मैंने ऐसा कहा। आर वास्तव में, ढेर नहीं है तो मैं मूल रूप से इस्तेमाल किया c, headऔर tailएक ही शाब्दिक असर पाने के लिए। Ungolfed मूल संस्करण (अपडेट utf8ToIntकुछ बाइट्स को हटाने के लिए, स्टैक के शीर्ष के रूप में वेक्टर की शुरुआत का उपयोग करके, और स्टैक को इनिशियलाइज़ करने से बचने के लिए गाली Tऔर Fबिलिन।):

f <- function(y, x=el(strsplit(y,""))) {
  p <- l <- NULL
  for(i in seq_along(x)) {
    if(x[[i]]=='[') {
      p <- c(p, i)
    }
    if(x[[i]]==']') {
      l <- c(l, tail(p, 1), i)
      p <- head(p, -1)
    }
  }
  l # Because I said so. Change to l-1 if you want to check the test cases.
}

— एन जी एम
स्रोत

कोस से कुछ बाइट्स सहेजें बनाया-इन T`` and F`

— Jayce

और 1:nchar(y)से छोटा है seq_along(x)। बहुत अच्छा समाधान btw :)

— JayCe

मुझे आश्चर्य है कि अगर gregexprजाने का रास्ता है।

— एन जी एम

मैंने मूल रूप से इस दृष्टिकोण का लाभ उठाने की कोशिश की थी, लेकिन मुझे यकीन नहीं है कि यह सही तरीका है।

— JayCe

जेसीई समाधान त्रुटिपूर्ण है (परिणाम की जांच करें, यह 22 28 22बदले में लौटता है 22 28 21) शायद टी (एफ) का उपयोग (ए) वास्तव में सुरक्षित नहीं है - डी। यह छोटा है और काम करने लगता है -> इसे ऑनलाइन आज़माएं!

— डाइजेक्सिल

2

फोर्थ (gforth) , 75 बाइट्स

: f 0 do dup i + c@ dup 91 = if i s>f then 93 = if f>s . i . cr then loop ;

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

फ्लोटिंग-पॉइंट स्टैक का दुरुपयोग करता है, लेकिन do loopकोड का उपयोग नहीं करने देता है (मैन्युअल रूप से) रिटर्न स्टैक को स्पर्श नहीं करता है।

व्याख्या

स्ट्रिंग में पात्रों के माध्यम से लूप
प्रत्येक वर्ण की जाँच करें
1. यदि बराबर है [, तो फ्लोटिंग पॉइंट स्टैक पर रखें
2. यदि ]वर्तमान स्थिति के साथ फ्लोटिंग पॉइंट स्टैक और आउटपुट से पॉप के बराबर है

कोड स्पष्टीकरण

0 do                 \ start a loop from 0 to string-length
  dup                \ duplicate the starting address to avoid losing it
  i + c@             \ get the address of the current position and retrieve the character
  dup                \ duplicate the character, to allow checking twice
  91 = if            \ if char = [
    i s>f            \ store the current address on the floating point stack
  then               \ end the if-statement
  93 = if            \ if char = ]
    f>s .            \ pop the starting position from the float-stack and print
    i .              \ print the current position
    cr               \ output a newline
  then               \ end the if-statement
loop                 \ end the loop

— reffu
स्रोत

2

रेटिना , 36 बाइट्स

L$v`\[((\[)|(?<-2>])|[^]])*
$.`,$.>`

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

मैच परिणामों से एक सूची बनाएं।

मैचों के बजाय सूची बनाने के लिए निम्नलिखित प्रतिस्थापन का उपयोग करें।

v`

मैचों को ओवरलैप करने की अनुमति दें।

\[((\[)|(?<-2>])|[^]])*

यह .NET के संतुलन समूहों का एक अनुप्रयोग है। का [शाब्दिक रूप से मिलान किया जाता है, फिर जितना संभव हो उतने पात्रों का उपभोग किया जाता है। जैसा कि प्रत्येक बाद [में मिलान किया जाता है, मैच $2स्टैक में जोड़ा जाता है । यदि वह स्टैक खाली नहीं है, तो हम ]मैच को स्टैक से हटाकर, मैच कर सकते हैं । अन्यथा, हम कुछ भी मैच कर सकते हैं जो एक नहीं है ]( [पहले से ही पहले से मेल खाता था)। जब यह स्टैक उस समय खाली है (अब) से मेल खाता है, तो यह मिलान के ]लिए मिलता है ।[$2

$.`,$.>`

प्रतिस्थापन में अल्पविराम द्वारा अलग किए गए दो चर होते हैं। .इंगित करता है कि चर की लंबाई, बल्कि अपने मूल्य की तुलना में, इस्तेमाल किया जा। >इंगित करता है कि चर मैच दाएँ हाथ विभाजक के बजाय के संदर्भ में मूल्यांकन किया जाना चाहिए। $`चर मैच था जिसमें साधन का उपसर्ग को दर्शाता है $.`की स्थिति देता है [; >मैच के अधिकार विभाजक, जो मिलान की स्थिति देता है के उपसर्ग के संशोधक बदलती जाती है इस ]।

— नील
स्रोत

2

जेली , 22 21 20 19 बाइट्स

^{कोई संदेह नहीं है कि यह जेली इस बाइट गिनती में आधा संभव है: पी ...}

n€Ø[ḅ-µMịÄÐƤi€0ĖƊ’Ä

वर्णों की सूची को स्वीकार करने वाला एक विचित्र लिंक जो पूर्णांकों की सूची की सूची देता है।
एक पूर्ण कार्यक्रम के रूप में यह एक स्ट्रिंग को स्वीकार करता है और उक्त सूची का प्रतिनिधित्व करता है।

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

कैसे?

n€Ø[ḅ-µMịÄÐƤi€0ĖƊ’Ä - Link: list of characters    e.g. "[f[o]o!]"
  Ø[                - list of characters = ['[', ']']
n€                  - not equal? for €ach              [[0,1],[1,1],[0,1],[1,1],[1,0],[1,1],[1,1],[1,0]]
                    -     ...relating to the characters:  [     f     [     o     ]     o     !     ]
    ḅ-              - convert from base -1             [1,0,1,0,-1,0,0,-1]
                    -     ...i.e.: 1 where '['; -1 where ']'; and 0 elsewhere
      µ             - start a new monadic chain with that as the argument, say V
                Ɗ   - last 3 links as a monad (function of V):
          ÐƤ        -   for post-fixes:
         Ä          -     cumulative sum               [[1,1,2,2,1,1,1,0],[0,1,1,0,0,0,-1],[1,1,0,0,0,-1],[0,-1,-1,-1,-2],[-1,-1,-1,-2],[0,0,-1],[0,-1],-1]
            i€0     -   1st index of 0 in €ach (or 0)  [8,1,3,1,0,1,1,0]
               Ė    -   enumerate                      [[1,8],[2,1],[3,3],[4,1],[5,0],[6,1],[7,1],[8,0]]
       M            - maximal indices of V             [1,3]
        ị           - index into                       [[1,8],[3,3]]
                 ’  - decrement                        [[0,7],[2,2]]
                  Ä - cumulative sum (vectorises)      [[0,7],[2,4]]

— जोनाथन एलन
स्रोत

मैं उपयोग करने की कोशिश कर रहा था œ¿और यह रिश्तेदार है, लेकिन इसका हल नहीं खोज सका। यह मेरे निकटतम था।

— डायलन

हां, यह कम हो सकता है, लेकिन मैंने केवल एक ही बाइट का प्रबंधन किया , न कि आधे बाइट्स का। यह अभी भी बहुत लंबा लगता है। :(

— निकोल आउट

@ EriktheOutgolfer यहां 1 आसान बाइट भी बचा रहा था

— जोनाथन एलन

2

एसडब्ल्यूआई-प्रोलॉग 254 बाइट्स

d([']'|T],I,[S|Z],M,R):-J is I+1,d(T,J,Z,[',','(',S,',',I,')'|M],R).
d(['['|T],I,S,M,R):-J is I+1,d(T,J,[I|S],M,R).
d([_|T],I,S,M,R):-J is I+1,d(T,J,S,M,R).
d(_,_,_,R,R).
m(X):-atom_chars(X,A),d(A,0,[],[']'],[_|R]),atomic_list_concat(['['|R],S),print(S).

उदाहरण:

?- m('!^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][]').
'[(49,50),(42,48),(8,41),(36,39),(20,33),(21,27)]'
true

— जान ड्रोजेन
स्रोत

1

सी (जीसीसी) , 87 बाइट्स

f(char*Z){for(char*z=Z,*q=z;*z;*z++-93||printf("%d,%d;",*--q,z-1-Z))*z-91||(*q++=z-Z);}

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

व्याख्या

ब्रैकेट के स्ट्रिंग सूचकांकों को ट्रैक करने के लिए इनपुट स्ट्रिंग को ओवरराइट किया जाता है और स्टैक के रूप में उपयोग किया जाता है।

f(char*Z){          // take mutable input string
 for(char*z=Z,*q=z; // copy pointer to current string index, current stack index
 *z;                // loop through the entire string
 *z++-93||          // if z == ']'
   printf("%d,%d;", // decrement stack pointer,
    *--q,z-1-Z))    //  write bracket pair position
  *z-91||           // if z == '['
   (*q++=z-Z);}     // write bracket position onto stack, increment stack pointer

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

— जोनाथन फ्रेच
स्रोत

1

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

=©ⱮØ[_/aÄ$+®ŻĠḊẎ_2s2

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

रजिस्टर पर इसका साइड-इफ़ेक्ट है, आशा है कि इसे फंक्शन होने दिया जाएगा।

— आउटगोल्फर को एरिक करें
स्रोत

यह पुन: प्रयोज्य है, इसलिए मुझे लगता है कि यह ठीक है। BF के उत्तर आमतौर पर टेप को नहीं छोड़ते

— dylnan

1

जाप v1.4.5, 23 बाइट्स

;Ë¥']?ApENo):D¥'[©NpE
A

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

अनपैक्ड और यह कैसे काम करता है

;UmDE{D==']?ApENo):D=='[&&NpE
A

;                              Use alternative set of initial variables
                               A = [] is used here
 UmDE{                         Map over each char of input string...
      D==']?                     If the char is closing bracket...
            ApENo)                 Push the current index and N.pop() to A
                  :D=='[&&       Otherwise, if the char is opening bracket...
                          NpE      Push the current index to N

A     Output A

आउटपुट एक चपटा सरणी है [closing index, opening index]। यदि उलटा क्रम वांछित नहीं है, wतो अंत में जोड़ना काम करता है (+1 बाइट्स)।

— bubbler
स्रोत

1

आम लिस्प, 95 बाइट्स

(lambda(u &aux s)(dotimes(p(length u))(case(elt u p)(#\[(push p s))(#\](print`(,(pop s),p))))))

दीर्घ संस्करण

(defun par (string &aux stack)
  (dotimes (pos (length string))
    (case (char string pos)
      (#\[ (push pos stack))
      (#\] (print (list (pop stack) pos))))))

टेस्ट

((lambda(u &aux s)(dotimes(p(length u))(case(elt u p)(#\[(push p s))(#\](print`(,(pop s),p))))))
 "!^45sdfd[hello world[[djfut]%%357]sr[jf]s][srtdg][] ")

प्रिंट:

(21 27) 
(20 33) 
(36 39) 
(8 41) 
(42 48) 
(49 50)

— कोर निपात
स्रोत

1

कश्मीर (NGN / ट) , 38 37 बाइट्स

{b@0N 2#,/=(|':+\-/a)b:&|/a:"[]"=\:x}

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

{ } तर्क के साथ कार्य करें x

"[]"=\:xकी घटनाओं के लिए दो बूलियन सूची "["और"]"

a: को आवंटित a

|/ बूलियन "या" दो सूचियों का

& कहाँ (किन सूचकांकों पर) कोष्ठक हैं?

b: को आवंटित b

-/1 के साथ एक सूची "[", -1 के लिए "]", और 0 हर जगह

+\ आंशिक रकम

|': जोड़ीदार मैक्सिमा (प्रत्येक तत्व पिछले एक के साथ अधिकतम, प्रारंभिक तत्व समान रहता है)

यह प्रत्येक चरित्र के लिए ब्रैकेट की गहराई का प्रतिनिधित्व करता है। हम इसे b(juxtaposition अनुक्रमित कर रहे हैं) के साथ अनुक्रमित करते हैं और केवल ब्रैकेट के लिए ब्रैकेट की गहराई प्राप्त करते हैं।

= "समूह द्वारा" - एक शब्दकोश मानचित्रण उन सूचकांकों की गहराई है, जिन पर वे घटित होते हैं

,/ कुंजियों को अनदेखा करते हुए, शब्दकोश में मूल्यों को संक्षिप्त करें

0N 2# 2-कॉलम मैट्रिक्स (सूचियों की सूची) पर फिर से क्लिक करें

b@bमैट्रिक्स के प्रत्येक तत्व के साथ सूचकांक

— NGN
स्रोत

1

जेली , 20 18 बाइट्स

सहेजा गया 1 बाइट @ उपयोगकर्ता 202729 को धन्यवाद जो मुझे सूचित कर रहा µ€है)

ẹⱮØ[µ³ḣċþØ[_/Ụị)Z’

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

कई घंटों के लिए कुश्ती के बाद बस इसे काम करने के लिए ... मुझे ईमानदारी से आश्चर्य है कि यह इस छोटे से मिल गया है :-)

व्याख्या

ẹⱮØ[µ³ḣċþØ[_/Ụị)Z’   Main link. Argument: s (string)  '[a[b]c[]][d]'
  Ø[                 Shortcut for the string "[]".
 Ɱ                   For each char in the "[]":
ẹ                      Find the indices of each occurrence in the input.
                     For our example, this gives the array [[1, 3, 7, 10], [5, 8, 9, 12]].

    µ                Begin a new monadic chain, with said array as its argument.
               )     For each of the two sub-arrays q within the array:
                         [[1, 3, 7, 10], [5, 8, 9, 12]]
     ³ḣ                For each item n in q, take the first n chars of the input.
                         [['[',     '[a[',      '[a[b]c[',   '[a[b]c[]]['],
                          ['[a[b]', '[a[b]c[]', '[a[b]c[]]', '[a[b]c[]][d]']]
        þØ[            For each string s in this, and each char c in "[]":
       ċ                 Count the occurrences of c in s.
                         [[[1, 0],  [2, 0],     [3, 1],      [4, 3]],
                          [[2, 1],  [3, 2],     [3, 3],      [4, 4]]]
           _/          Reduce each pair by subtraction. This is the number of open brackets
                         at each position.
                         [[1, 2, 2, 1], [1, 1, 0, 0]]
             U         Sort the indices by their values, using position as a tiebreaker.
                         [[1, 4, 2, 3], [3, 4, 1, 2]]
              ị        Index these values back into q.
                         [[1, 10, 3, 7], [9, 12, 5, 8]]

               )     Start a new monadic chain with the result as its argument.
                Z    Zip; transpose rows and columns.
                         [[1, 9], [10, 12], [3, 5], [7, 8]]
                 ’   Decrement; switch to 0-indexing.
                         [[0, 8], [9, 11], [2, 4], [6, 7]]

— ETHproductions
स्रोत

1

सीजेएम , 25 बाइट्स

0q{"[]"#"_ \p_p "S/=~)}/;

आश्चर्यजनक रूप से प्रतिस्पर्धी - केवल जाप और जेली के लिए हार जाता है [ संपादित करें : और चारकोल और स्टेक्स :(]

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

व्याख्या

0                          Push 0.
 q                         Push the input.
  {                   }/   For each character in the input:
   "[]"#                     Find index of this character in the string "[]" (or -1 if not found).
                   =         Use this index to choose
        "       "S/            one of the following snippets
                    ~          and execute it:
         _                       If it was 0 ('['), duplicate the number on the stack.
           \p_p                  If it was 1 (']'), print the current number and the one under it.
                                 If it was -1, do nothing.
                     )       Increment the number on top of the stack.
                        ;  Delete the number.

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

0

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

def a(s,r=[],i=0):
 o=[]
 while i<len(s):exec["r+=[i]","o+=[(r.pop(),i)]",'']['[]'.find(s[i])];i+=1
 return o

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

— wastl
स्रोत

यह भी काम करता है!

— ज़ाचरी

0

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

{I#.e,t+lhfSI/LT`Y+._>Qk\]

परीक्षण सूट।

~~फिलहाल यह मेमनोनिक के दृष्टिकोण से अधिक लंबा है~~ , लेकिन मुझे ऐसा लगता है कि मैं इसे थोड़ा नीचे कर सकता हूं और यह सौभाग्य से पाइथनिक-अपरिमेय संरचनाओं का उपयोग नहीं करता है V। प्रारंभिक संस्करण 36 बाइट्स था और इसमें कई बग भी थे।

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

{I # .e, t + lhfSI / LT`Y + ._> Qk \] - पूर्ण कार्यक्रम। STDIN से एक उद्धृत स्ट्रिंग Q लेता है।
   .e - प्रगणित नक्शा। k = पुनरावृत्ति सूचकांक, b = वर्तमान तत्व।
                     > Qk - Q के तत्वों को k से अधिक सूचकांकों में प्राप्त करें।
                   ._ - इसके सभी उपसर्गों को उत्पन्न करता है।
                  + \] - और एक "]" जोड़ें (कुछ किनारे-मामलों को संभालने के लिए)।
          f - इस सूची पर T = वर्तमान तत्व के साथ फ़िल्टर करें।
              L `Y - str ([]) में प्रत्येक चरित्र के लिए," [] "...
             / टी - ... टी में इसकी घटनाओं की गणना करें।
           एसआई - और जांचें कि क्या मान तेजी से छंटे हैं।
         ज - प्रमुख। पहले तत्व को पुनः प्राप्त करें।
       + l - इस + k की लंबाई प्राप्त करें।
      t - कमी (1 से)।
     , - और k के साथ इस मान को जोड़ते हैं। लौटता है [i, k] जहां मैं हूं
                             अनुक्रमणिका] और k का [कि] है।
  # - इस सूची को फ़िल्टर करें:
{मैं - यह जोड़ी समर्पण पर अजेय है।

— श्री Xcoder
स्रोत

{I#.e,t+lhfSI/LT`Y._>Q 22 बाइट्स के लिए एलेस्टेस्ट काम करता है ...

— मिस्टर एक्सकोडर

0

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

say"$-[0] ".($+[0]-1)while s/\[[^][]*\]/1x length$&/e

के रूप में चलाएँ perl -nE '<above code snippet>'। स्टड के माध्यम से इनपुट लेता है।

हमेशा की तरह, समस्या का इष्टतम पर्ल समाधान एक नियमित अभिव्यक्ति है। हम कोष्ठक के किसी भी जोड़े से मेल खाने का प्रयास करते हैं, जिसमें एक मूर्खतापूर्ण दिखने वाले चरित्र वर्ग ( s/\[[^][]*\]/.../) का उपयोग करके इसके भीतर कोई भी जोड़ा नहीं होता है । यदि मैच सफल होता है, तो हम मिलान किए गए टेक्स्ट को 1बार-बार अंक के साथ बदलते हैं ताकि हम गलती से उन ब्रैकेट्स से दोबारा मेल न करें, और हम मैच के सूचकांकों को प्रिंट कर लें। धोये और दोहराएं।

— सिल्वियो मायोलो
स्रोत

0

स्टैक्स , 13 बाइट्स

é√p(l▓1½\á²ë(

इसे चलाएं और डीबग करें

यह खुले ब्रेस जोड़े को ट्रैक करने के लिए इनपुट स्टैक का उपयोग करता है। यहाँ प्रोग्राम अनपैक्ड, अनगुल्फेड और कमेंटेड है।

F       iterate over input characters
 .][I   get the index of the character in the string "[]", or -1
 ^|cv   skip the rest of this iteration if index was -1
 i~     push the current iteration index to the input stack
 C      skip the rest of this iteration if index was 0
 \      form a pair with the top two items from the input stack
 JP     join with space, and print

इसको चलाओ

— पुनरावर्ती
स्रोत

0

चारकोल , 20 बाइट्स

ＦＬθ≡§θι[⊞υι]«Ｉ⊟υ,Ｉι⸿

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＦＬθ

इनपुट स्ट्रिंग की लंबाई के निहित सीमा पर लूप।

≡§θι

वर्तमान चरित्र पर स्विच करें।

[⊞υι

यदि यह एक [मौजूदा सूचकांक को पूर्वनिर्धारित सरणी चर पर धकेलता है।

]«Ｉ⊟υ,Ｉι⸿

अगर यह ]एरे वेरिएबल से लेटेस्ट इंडेक्स को पॉप करता है और इसे प्रिंट करता है और करंट इंडेक्स कॉमा से अलग हो जाता है और एक नई लाइन शुरू करता है। वैकल्पिक आउटपुट प्रारूप, यदि स्वीकार्य हो, तो कुछ बाइट्स को बचाएगा: ]Ｉ⟦⊟υιω2 बाइट बचाता है, लेकिन प्रत्येक इंडेक्स को एक अलग लाइन पर प्रिंट करता है, इंडेक्स के जोड़े को डबल-स्पेस करता है; ]Ｉ⟦⊟υιबस अलग-अलग लाइनों पर अनुक्रमित प्रिंट करता है, जिससे उन्हें भेद करना मुश्किल हो जाता है।

— नील
स्रोत

गोल्फ एक कोष्ठक मिलान एल्गोरिथ्म

नोट: स्ट्रिंग शून्य-अनुक्रमित है।

ब्रेन-फ्लैक क्लासिक , 108 बाइट्स

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

जावास्क्रिप्ट, 69 62 बाइट्स

हास्केल , 92 79 बाइट्स

व्याख्या

जावा 10, 95 बाइट्स

Ungolfed

स्वीकृतियाँ

विम, 89 बाइट्स

एनोटेट

QBasic (QB64), 137 127 112 बाइट्स

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

व्याख्या

आर , 141 133 115 112 112 बाइट्स

फोर्थ (gforth) , 75 बाइट्स

व्याख्या

कोड स्पष्टीकरण

रेटिना , 36 बाइट्स

जेली , 22 21 20 19 बाइट्स

कैसे?

एसडब्ल्यूआई-प्रोलॉग 254 बाइट्स

सी (जीसीसी) , 87 बाइट्स

व्याख्या

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

जाप v1.4.5, 23 बाइट्स

अनपैक्ड और यह कैसे काम करता है

आम लिस्प, 95 बाइट्स

कश्मीर (NGN / ट) , 38 37 बाइट्स

जेली , 20 18 बाइट्स

व्याख्या

सीजेएम , 25 बाइट्स

व्याख्या

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

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

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

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

स्टैक्स , 13 बाइट्स

चारकोल , 20 बाइट्स