9

^{चैलेंज से लिया यहाँ है और यह भी यहाँ}

एक n कोष्ठक अनुक्रम में n ( s और n ) s होते हैं ।

एक मान्य कोष्ठक अनुक्रम निम्नलिखित के रूप में परिभाषित किया गया है:

आप कोष्ठक के निकटवर्ती जोड़ी को मिटाने का एक तरीका पा सकते हैं "()" जब तक यह खाली न हो जाए।

उदाहरण के लिए, (())एक वैध कोष्ठक है, आप 2 और 3 की स्थिति पर जोड़ी को मिटा सकते हैं और यह बन जाता है (), फिर आप इसे खाली कर सकते हैं। )()(एक वैध कोष्ठक नहीं है, जब आप 2 और 3 के स्थान पर जोड़ी को मिटा देते हैं, तो यह बन जाता है )(और आप इसे और नहीं मिटा सकते

कार्य

एक संख्या n को देखते हुए आपको लेक्सिकोग्राफ़िक क्रम में सभी सही कोष्ठक अनुक्रम उत्पन्न करने की आवश्यकता है

आउटपुट एक सरणी, सूची या स्ट्रिंग हो सकता है (इस मामले में प्रति पंक्ति एक क्रम)

आप कोष्ठक जैसे की एक अलग जोड़ी का उपयोग कर सकते {}, [], ()या किसी खुले करीब संकेत

उदाहरण

n = 3

((()))    
(()())    
(())()    
()(())    
()()()

n = 2
```
(())
()()
```

code-golf balanced-string

— लुइस फेलिप डी जीसस मुनोज
स्रोत

@ जोकिंग बिल्कुल हाँ। मुझे लगता है कि अभ्यस्त चुनौती की मुख्य अवधारणा के लिए वैसे भी कोई फर्क नहीं पड़ता।

— लुइस फेलिप डी जेउस मुनोज

एह, मैं कुछ भाषाओं के बारे में सोच सकता हूं, जहां ईगल उन्हें उदाहरण के लिए अलग तरह से व्याख्या करेंगे

— जो राजा

1

संबंधित: कैटलन संख्या (उस चुनौती का परिणाम = इस चुनौती के परिणाम की संख्या)

— user202729

3

वस्तुतः वही , लेकिन कुछ अजीब प्रतिबंधों जैसे "आप पुनरावर्ती कार्य नहीं लिख सकते हैं"। /// इस चैलेंज का एक सुपरसेट (सभी ब्रेन-फ्लैक ब्रैकेट्स की अनुमति दें)

— user202729

क्या "किसी भी खुले-पास के संकेत" के अनुक्रमों की "एक सरणी, सूची या स्ट्रिंग" का अर्थ है कि हम दो पूर्णांकों (जैसे 1s और -1s) की सूची का उत्पादन कर सकते हैं ?

— जोनाथन एलन

8

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

{grep {try !.EVAL},[X~] <[ ]>xx$_*2}

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

के सभी lexographically हल संयोजनों को ढूँढता है $2n$ []s और जो EVALसही तरीके से फ़िल्टर करता है । ध्यान दें कि सभी मान्य संयोजन (यहां तक कि सामान भी [][]) मूल्यांकन करते हैं [](जो कि गलत है, लेकिन हम notइसे ( !) tryलौटने से अलग करने के लिए Nil)

स्पष्टीकरण:

{                                  }  # Anonymous code block
                        <[ ]>         # Create a list of ("[", "]")
                             xx$_*2   # Duplicate this 2n times
                   [X~]               # Find all possible combinations
 grep {          },                   # Filter from these
            .EVAL                     # The EVAL'd strings
       try !                          # That do not throw an error

— मजाक कर रहा है
स्रोत

3

अगर किसी की जिज्ञासा है, [][]तो एक खाली सरणी का ज़ेन टुकड़ा है जो सरणी को ही पैदा करता है। स्लाइस को कई बार लागू किया जा सकता है, इसलिए इसका [][][][]...मूल्यांकन करता है []। इसके अलावा, एकल तर्क नियम के[[]] कारण एक नेस्टेड सरणी का निर्माण नहीं होता है , लेकिन एक खाली सरणी होती है (आपको नेस्टेड सरणी के लिए लिखना होगा )। तो कोष्ठक के किसी भी संतुलित अनुक्रम के परिणामस्वरूप एक खाली सरणी होती है, जो कि झूठी होती है। [[],][]

— nwellnhof

6

आर , 112 107 99 बाइट्स

गैर-पुनरावर्ती दृष्टिकोण। हम "<" और ">" का उपयोग करते हैं क्योंकि यह रेगेक्स में भागने वाले पात्रों से बचता है। हमें ASCII रेंज के लिए एक छोटे विनिर्देशन का उपयोग करने की अनुमति देने के लिए, हम "^", "=" और ">" का उपयोग करके 3 ^ 2n 2n-वर्ण स्ट्रिंग्स उत्पन्न करते हैं expand.grid(उनके ASCII कोड 60, 61 और 62 के माध्यम से) और फिर gpp देखें कि कौन से संयोजन संतुलित खुले और निकट कोष्ठक देते हैं। "=" संभावनाओं को अनदेखा किया जाएगा, निश्चित रूप से।

वाया http://rachbelaid.com/recursive- अनियमित-experession/

function(n)sort(grep("^(<(?1)*>)(?1)*$",apply(expand.grid(rep(list(60:62),2*n)),1,intToUtf8),,T,T))

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

व्याख्या

"^(<(?1)*>)(?1)*$" = regex for balanced <> with no other characters
^ # match a start of the string
  ( # start of expression 1
    < # open <>
       (?1)* # optional repeat of any number of expression 1 (recursive)
  # allows match for parentheses like (()()())(()) where ?1 is (\\((?1)*\\))
    > # close <>
  ) # end of expression 1
  (?1)* # optional repeat of any number of expression 1
$ # end of string

function(n)
  sort(
    grep("^(<(?1)*>)(?1)*$", # search for regular expression matching open and close brackets
      apply(
        expand.grid(rep(list(60:62),2*n)) # generate 3^(2n) 60,61,62 combinations
      ,1,intToUtf8) # turn into all 3^(2n) combinations of "<","=",">"
    ,,T,T) # return the values that match the regex, so "=" gets ignored
  ) # sort them

आर , 107 बाइट्स

सामान्य पुनरावर्ती दृष्टिकोण।

-1 धन्यवाद @ गिउसेप्पे

f=function(n,x=0:1)`if`(n,sort(unique(unlist(Map(f,n-1,lapply(seq(x),append,x=x,v=0:1))))),intToUtf8(x+40))

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

— J.Doe
स्रोत

1

आह, मैं एक Mapगोल्फ खोजने की कोशिश कर रहा था, लेकिन इसके चारों ओर अपना सिर नहीं लपेट सकता था। मुझे यकीन नहीं हो रहा है parse+ के evalबाद से काम करने जा रहा है ()()और इस तरह की त्रुटियां।

— ग्यूसेप

4

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

f(n,x,s,a,i){char b[99]={};n*=2;for(x=1<<n;x--;s|a<0||puts(b))for(s=a=i=0;i<n;)a|=s+=2*(b[n-i]=41-(x>>i++&1))-81;}

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

N <= 15 के लिए काम करना चाहिए।

व्याख्या

f(n,x,s,a,i){
  char b[99]={};   // Output buffer initialized with zeros.
  n*=2;            // Double n.
  for(x=1<<n;x--;  // Loop from x=2**n-1 to 0, x is a bit field
                   // where 1 represents '(' and 0 represents ')'.
                   // This guarantees lexicographical order.
      s|a<0||puts(b))  // Print buffer if s==0 (as many opening as
                       // closing parens) and a>=0 (number of open
                       // parens never drops below zero).
    for(s=a=i=0;i<n;)  // Loop from i=0 to n-1, note that we're
                       // traversing the bit field right-to-left.
      a|=              // a is the or-sum of all intermediate sums,
                       // it becomes negative whenever an intermediate
                       // sum is negative.
        s+=            // s is the number of closing parens minus the
                       // number of opening parens.
                        x>>i++&1   // Isolate current bit and inc i.
                    41-(        )  // ASCII code of paren, a one bit
                                   // yields 40 '(', a zero bit 41 ')'.
             b[n-i]=               // Store ASCII code in buffer.
          2*(                    )-81;  // 1 for ')' and -1 for '(' since
                                        // we're going right-to-left.
}

— nwellnhof
स्रोत

4

पायथन 2 , 91 88 84 81 बाइट्स

f=lambda n:n and sorted({a[:i]+'()'+a[i:]for a in f(n-1)for i in range(n)})or['']

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

_{-3 बाइट्स pizzapants184 के लिए धन्यवाद}

— TFeld
स्रोत

पायथन 3 में भी काम करता है, मुझे लगता है

— सुपरस्टॉर्मर

-3 बाइट्स के लिए आप set(...)एक सेट कॉम्प्रिहेंशन ( {...}) की जगह ले सकते हैं इसे ऑनलाइन आज़माएं!

— pizzapants184

@ pizzapants184 धन्यवाद :)

— TFeld

3

05AB1E , 13 बाइट्स

„()©s·ãʒ®õ:õQ

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

स्पष्टीकरण:

„()            # Push string "()"
   ©           # Store it in the register without popping
    s·         # Swap to get the (implicit) input, and double it
      ã        # Cartesian product that many times
       ʒ       # Filter it by:
        ®      #  Push the "()" from the register
         õ:    #  Infinite replacement with an empty string
           õQ  #  And only keep those which are empty after the infinite replacement

— केविन क्रूज़सेन
स्रोत

3

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

f=->n{n<1?['']:(0...n).flat_map{|w|f[n-1].map{|x|x.insert w,'()'}}|[]}

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

— जीबी
स्रोत

3

जाप, 15 13 बाइट्स

ç>i<)á Ôke/<>

कोशिश करो

व्याख्या

ç                 :Input times repeat the following string
 >i<              :  ">" prepended with "<"
    )             :End repeat
     á            :Get unique permutations
       Ô          :Reverse
        k         :Remove any that return true (non-empty string)
         e/<>     :  Recursively replace Regex /<>/

— झबरा
स्रोत

3

K (ngn / k) , 36 35 बाइट्स

{"()"(&/-1<+\1-2*)#(x=+/)#+!2|&2*x}

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

+!2|&2*x लंबाई 2 * n के सभी बाइनरी वैक्टर

(x=+/)# केवल उन है कि n को योग

(&/-1<+\1-2*)# केवल जिनके आंशिक योग हैं, 0/1 को 1 / -1 मानते हैं, वे कहीं भी नकारात्मक नहीं हैं

"()" इस स्ट्रिंग में सूचकांकों के रूप में 0/1 का उपयोग करें

— NGN
स्रोत

2

पर्ल 5 `-n` , 41 39 बाइट्स

कोण कोष्ठक के साथ -2 बाइट्स

s/<(?R)*>//gr||say for glob'{<,>}'x2x$_

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

मेरे पर्ल 6 उत्तर का पोर्ट।

— nwellnhof
स्रोत

2

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

{grep {!S:g/\(<~~>*\)//},[X~] <( )>xx$_*2}

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

एक पुनरावर्ती रेगेक्स का उपयोग करता है। वैकल्पिक प्रतिस्थापन:S/[$<~~>$]*//

38 बाइट्स 0 और 1 खुले / बंद प्रतीकों के रूप में:

{grep {!S:g/0<~~>*1//},[X~] ^2 xx$_*2}

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

व्याख्या

{                                        }  # Anonymous block
                              <( )>         # List "(", ")"
                                   xx$_*2   # repeated 2n times
                         [X~]  # Cartesian product with string concat
                               # yields all strings of length 2n
                               # consisting of ( and )
 grep {                },  # Filter strings
        S:g/             # Globally replace regex match
            \(           #   literal (
              <~~>       #   whole regex matched recursively
                  *      #   zero or more times
                   \)    #   literal )
                     //  # with empty string
       !                 # Is empty string?

— nwellnhof
स्रोत

2

रेटिना 0.8.2 , 50 बाइट्स

.+
$*
1
11
+%1`1
<$'¶$`>
Gm`^(?<-1>(<)*>)*$(?(1).)

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

.+
$*

यूनीरी में बदलें।

1
11

परिणाम को दोगुना करें।

+%1`1
<$'¶$`>

2²ⁿ 2n-bit के सभी द्विआधारी संख्याओं की गणना करें, अंकों की मैपिंग करें <>।

Gm`^(?<-1>(<)*>)*$(?(1).)

केवल संतुलित क्रम रखें। यह @MartinEnder द्वारा खोजी गई संतुलित कोष्ठक चाल का उपयोग करता है।

— नील
स्रोत

2

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

यह nwellnhof के C उत्तर पर आधारित है ।

f=(n,i)=>i>>2*n?'':(g=(o,k)=>o[2*n]?s|m<0?'':o:g('()'[m|=s+=k&1||-1,k&1]+o,k/2))(`
`,i,m=s=0)+f(n,-~i)

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

— Arnauld
स्रोत

2

लाल , 214, 184 136 बाइट्स

func[n][g: func[b n][either n = length? b[if not error? try[load b][print b]return 0][g append copy b"["n g append copy b"]"n]]g""2 * n]

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

जो राजा के दृष्टिकोण का उपयोग करता है। पुनरावृत्ति (वे लेक्सिकोग्राफिक क्रम में उत्पन्न होती हैं) का उपयोग करके ब्रैकेट्स के सभी अभेद्य व्यवस्था को ढूँढता है और इसे प्रिंट करता है यदि व्यवस्था एक वैध ब्लॉक के रूप में मूल्यांकन करती है।

— गैलेन इवानोव
स्रोत

1

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

Ø+xŒ!QÄAƑ>ṪƊ$Ƈ=1ịØ(

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

आउटपुट TIO पर स्पष्ट किया गया।

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

कोष्ठक क्रम में क्रमबद्ध करता है

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

स्पष्टीकरण:

आर , 112 107 99 बाइट्स

व्याख्या

आर , 107 बाइट्स

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

व्याख्या

पायथन 2 , 91 88 84 81 बाइट्स

05AB1E , 13 बाइट्स

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

जाप, 15 13 बाइट्स

व्याख्या

K (ngn / k) , 36 35 बाइट्स

पर्ल 5 -n , 41 39 बाइट्स

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

व्याख्या

रेटिना 0.8.2 , 50 बाइट्स

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

लाल , 214, 184 136 बाइट्स

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

पर्ल 5 `-n` , 41 39 बाइट्स