डी-पेरेंटेसाइजिंग एक स्ट्रिंग

Question

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

आप मान सकते हैं कि इनपुट में केवल कम-केस ASCII पत्र और कोष्ठक हैं।

आपका जवाब एक फ़ंक्शन होना चाहिए, जब एक स्ट्रिंग दी जाती है, तो स्ट्रिंग की एक सूची देता है।

उदाहरण:

                   'a(b)c(d)e' -> ['ace', 'b', 'd']
                   'a(b(c)d)e' -> ['ae', 'bd', 'c']
                  'a((((b))))' -> ['a', 'b']
                        'a()b' -> ['ab']
                            '' -> []
                           'a' -> ['a']
          '(((a(b)c(d)e)f)g)h' -> ['h', 'g', 'f', 'ace', 'b', 'd']
'ab(c(((d)ef()g)h()(i)j)kl)()' -> ['ab', 'ckl', 'hj', 'efg', 'i', 'd']

सबसे कम बाइट्स जीतता है।

Comments

हैं 'i'और 'd'अंतिम परीक्षण मामले में सही क्रम में हैं?

— पुरकाकूदरी

@ Pietu1998 iकी तुलना में कम गहरा घोंसला है d।

— feersum

@ Faersum ओह, ठीक है।

— पुरकाकूदरी

क्या आप अन्य मानक सबमिशन प्रकारों के साथ-साथ विशेष रूप से पूर्ण कार्यक्रमों की अनुमति देंगे? सभी भाषाओं में कार्यों की अवधारणा नहीं है। डिफ़ॉल्ट सर्वसम्मति के लिए meta.codegolf.stackexchange.com/a/2422/8478 और meta.codegolf.stackexchange.com/questions/2447/… देखें ।

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

@redstonerodent मेरे द्वारा उपयोग किया जाने वाला शब्द "आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं, STDIN (या निकटतम वैकल्पिक), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं और परिणाम को STDOUT (या निकटतम विकल्प) के माध्यम से आउटपुट कर सकते हैं, फ़ंक्शन वापसी मान या फ़ंक्शन (आउट) पैरामीटर। " और आपके मामले में "आउटपुट किसी भी सुविधाजनक, अस्पष्ट, फ्लैट सूची प्रारूप में हो सकता है।"

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

Answer 1

जावास्क्रिप्ट ईएस 6, 91 93 104 133 148

Edit2 2 बाइट्स ने thx user81655 को बचाया

अधिक स्ट्रिंग्स और कम सरणियों का उपयोग करके संपादित करें

एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें

f=s=>[...s].map(c=>l+=c<')'||-(o[l]=(o[l]||'')+c,c<'a'),o=[],l=0)&&(o+'').match(/\w+/g)||[]

// Less golfed

u=s=>{
  o=[]; l=0;
  [...s].map(c=>{
    if (c>'(') // letters or close bracket
      o[l]=(o[l]||'')+c, // add letter or close bracket to current level string
      l-=c<'a' // if close bracket, decrement level
    else
      ++l // open bracket, increment level
  })
  o = o+'' // collapse array to comma separated string
  return o.match(/\w+/g)||[] // fetch non empty strings into an array
}

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;[ 'a(b)c(d)e'                    // ['ace', 'b', 'd']
 , 'a(b(c)d)e'                    // ['ae', 'bd', 'c']
 , 'a((((b))))'                   // ['a', 'b']
 , 'a()b'                         // ['ab']
 , ''                             // []
 , 'a'                            // ['a']
 , '(((a(b)c(d)e)f)g)h'           // ['h', 'g', 'f', 'ace', 'b', 'd']
 , 'ab(c(((d)ef()g)h()(i)j)kl)()' // ['ab', 'ckl', 'hj', 'efg', 'i', 'd']
].forEach(t=>console.log(t +" -> " + f(t)))

<pre id=O></pre>

Comments

2 बाइट्स के साथ सहेजें c=>l+=c<')'||-(o[l]=(o[l]||'')+c,c<'a'),।

— user81655

@ user81655 अच्छा, धन्यवाद

— edc65

Answer 2

जूलिया, 117 86 83 बाइट्स

v->(while v!=(v=replace(v,r"(\(((?>\w|(?1))*)\))(.*)",s"\g<3> \g<2>"))end;split(v))

यह एक रेगेक्स समाधान है।

Ungolfed:

function f(v)
  w=""
  while v!=w
    w=v
    v=replace(v,r"(\(((?>\w|(?1))*)\))(.*)",s"\g<3> \g<2>"))
  end
  split(v)
end

r"(\(((?>\w|(?1))*)\))(.*)"एक पुनरावर्ती है ( (?1)समूह 1 को पुनरावर्ती करता है ) जो पहले बाह्यतम संतुलित कोष्ठकों से मेल खाएगा (जिसमें असंतुलित / उलटा कोष्ठक शामिल नहीं है), दूसरा समूह जिसमें कोष्ठक के अंदर सब कुछ है (स्वयं को कोष्ठक सहित नहीं) और तीसरा समूह युक्त कोष्ठक के बाद सब कुछ (स्ट्रिंग के अंत तक)।

replace(v,r"...",s"\g<3> \g<2>")फिर दूसरे समूह को स्ट्रिंग के अंत में (एक स्थान के बाद, एक सीमांकक के रूप में कार्य करने के लिए) ले जाएगा, जिसमें संबंधित कोष्ठक हटा दिए जाएंगे। V == w तक पुनरावृति करके, यह सुनिश्चित किया जाता है कि प्रतिस्थापित तब तक दोहराया जाता है जब तक कि कोई कोष्ठक शेष न हों। क्योंकि मैचों को अंत तक ले जाया जाता है, और फिर अगला मैच पहले कोष्ठक के लिए जाता है, जिसके परिणामस्वरूप गहराई के क्रम में नीचे टूटी हुई स्ट्रिंग होगी।

फिर splitस्ट्रिंग के एक सरणी के रूप में स्ट्रिंग के सभी गैर-व्हाट्सएप घटकों को वापस करता है (जिसमें कोई व्हाट्सएप नहीं है)।

ध्यान दें कि w=""ungolfed कोड में उपयोग किया जाता है यह सुनिश्चित करने के लिए कि लूप कम से कम एक बार चलता है (सिवाय इसके कि इनपुट स्ट्रिंग खाली है, निश्चित रूप से), और गोल्फ फॉर्म में इसकी आवश्यकता नहीं है।

3 बाइट बचाने के साथ सहायता के लिए मार्टिन ब्यूटनर को धन्यवाद।

Comments

नीट, मैं रेटिना में स्वतंत्र रूप से एक ही समाधान पर पहुंचा हूं। यह वहां 44 बाइट्स है, लेकिन जैसा कि यह पूर्ण-कार्यक्रम समाधानों की अनुमति देता है। : /

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

के \wबजाय का उपयोग करके आप तीन बाइट्स बचा सकते हैं [^()]।

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

@ मार्टिनबटनर - धन्यवाद। मैंने वास्तव में उस पर विचार किया था, लेकिन मुझे चिंता थी कि मैंने कुछ अनदेखी की है और यह कुछ किनारे के मामले में विफल होगा। यदि आप कहते हैं कि यह ठीक है, हालांकि, तो यह ठीक है।

— ग्लेन ओ

Answer 3

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

def f(s):
 d=0;r=[['']for c in s]
 for c in s:
  if c=='(':d+=1;r[d]+=['']
  elif c==')':d-=1
  else:r[d][-1]+=c
 return[i for i in sum(r,[])if i]

इकाई परीक्षण:

assert f('a(b)c(d)e') == ['ace', 'b', 'd']
assert f('a(b(c)d)e') == ['ae', 'bd', 'c']
assert f('a((((b))))') == ['a', 'b']
assert f('a()b') == ['ab']
assert f('') == []
assert f('a') == ['a']
assert f('(((a(b)c(d)e)f)g)h') == ['h', 'g', 'f', 'ace', 'b', 'd']
assert f('ab(c(((d)ef()g)h()(i)j)kl)()') == ['ab', 'ckl', 'hj', 'efg', 'i', 'd']

मुझे यह पहेली पसंद है; ये बहुत प्यारा है!

Answer 4

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

fTscR)uX0.<GJ-FqLH`()@[Hdk)Jzmkz

परीक्षण सूट

@ क्क्सप्लसोन के दृष्टिकोण से पूरी तरह से दूर। प्रत्येक गहराई पर वर्णों की अलग-अलग सूची बनाता है, फिर उन्हें विभाजित करता है और खाली समूहों को फ़िल्टर करता है। वर्तमान गहराई की सूची को हर समय सामने रखने के लिए कार्य सूची को घुमाया जाता है।

Answer 5

रेटिना , 44 41 बाइट्स

+`\(((\w|(\()|(?<-3>.))*).(.*)
$4 $1
S_` 

-sझंडे के साथ भागो । अंतिम पंक्ति के अंत में स्थान पर ध्यान दें।

मैं ग्लेन ओ के स्वतंत्र रूप से इस समाधान के साथ आया था लेकिन यह समान है। विचार कोष्ठकों की पहली जोड़ी से मेल खाता है, इसे हटाएं, और आउटपुट के अंत में अपनी सामग्री डालें (बार-बार)। .NET के regex में पुनरावृत्ति की कमी के कारण, मुझे संतुलन समूहों का उपयोग करना पड़ा जो अब चार बाइट्स हैं।

यदि आप पहले रेगेक्स को नहीं समझते हैं, तो मैं आपको समूह के संतुलन के बारे में मेरे SO उत्तर का संदर्भ देता हूं । के बाद से इनपुट सही ढंग से कोष्ठकों होने की गारंटी है, हम मिलान द्वारा दो बाइट्स बचा सकता है )के साथ .के बजाय \)। फिर हम बस बाकी स्ट्रिंग के साथ मेल खाते हैं (.*)। $4 $1पहले लिखते हैं कि बाकी स्ट्रिंग (दोनों कोष्ठक और उनकी सामग्री को छोड़ते हुए), और फिर एक स्थान के बाद कोष्ठक की सामग्री। +`इस कदम को दोहराने के लिए रेटिना बताता है जब तक स्ट्रिंग को बदलने (एक बार सभी कोष्ठक हटा दिया गया है जो केवल तब होता है) बंद हो जाता है।

खाली कोष्ठक दो लगातार स्थानों में परिणाम देगा, इसलिए अंत में हम पूरे स्ट्रिंग को रिक्त स्थान पर विभाजित करते हैं ( S`विभाजन मोड को सक्रिय करता है और रेगेक्स एक एकल स्थान है)। _विकल्प, विभाजन की न आना खाली भागों में रेटिना बताता है तो हम उत्पादन में खाली परिणाम शामिल नहीं हैं।

Answer 6

आम लिस्प, 160

(lambda(x)(labels((g(l)(cons(#1=format()"~(~{~A~}~)"(#2=remove-if'listp l))(mapcan #'g(#2#'atom l)))))(remove""(g(read-from-string(#1#()"(~A)"x))):test'equal))))

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

Answer 7

हास्केल, 114 112 111 बाइट्स

')'%(h:i:t)=("":i):t++[h]
'('%l=last l:init l
c%((h:i):t)=((c:h):i):t
g x=[a|a<-id=<<foldr(%)(x>>[[""]])x,a>""]

प्रयोग उदाहरण: g "ab(c(((d)ef()g)h()(i)j)kl)()"-> ["ab","ckl","hj","efg","i","d"]।

मैं इनपुट स्ट्रिंग के माध्यम से पीछे जा रहा हूं। मध्यवर्ती डेटा संरचना स्ट्रिंग की सूची की एक सूची है। बाहरी सूची प्रति स्तर है और आंतरिक सूची एक स्तर के अनुसार प्रति समूह है, उदाहरण के लिए [["ab"],["ckl"],["hj"],["efg","i"],["d"]](ध्यान दें: वास्तविक सूची में बहुत सारे खाली स्ट्रिंग हैं-बीच में)। यह सब इनपुट की लंबाई के बराबर खाली तारों की संख्या से शुरू होता है - पर्याप्त से अधिक, लेकिन खाली सूचियों को वैसे भी फ़िल्टर किया जाता है। बाहरी सूचियाँ या तो (/ पर घूमती )हैं या सामने वाले तत्व में चरित्र जोड़ती हैं। )एक नया समूह भी शुरू करता है।

संपादित करें: @Zgarb को बचाने के लिए एक बाइट मिली है।

Answer 8

सैड, 90 बाइट्स

:
s/^(\w*)\((.*)\n?(.*)/\1\n\3_\2/M
s/(\n\w*_)(\w*)\)(.*)/\3\1\2/M
t
s/[_\n]+/,/g
s/,$//

विस्तारित ब्रेडेक्स ( -rध्वज) का उपयोग करता है, जिसका खाता +1 बाइट है। इसके अलावा, यह एक GNU एक्सटेंशन ( कमांड Mपर ध्वज s) का उपयोग करता है ।

नमूना उपयोग:

$ echo 'ab(c(((d)ef()g)h()(i)j)kl)()' | sed -r -f deparenthesize.sed
ab,ckl,hj,efg,i,d

स्पष्टीकरण: चूंकि sed पुनरावर्ती रेगेक्स जैसे सामान का समर्थन नहीं करता है, इसलिए मैनुअल काम की आवश्यकता होती है। अभिव्यक्ति को कई लाइनों में विभाजित किया गया है, प्रत्येक नेस्टिंग डेप्थ के स्तर का प्रतिनिधित्व करती है। एक ही गहराई पर व्यक्तिगत अभिव्यक्तियाँ (और इसी तरह एक ही रेखा पर) एक से अलग हो जाती हैं _। स्क्रिप्ट एक समय में इनपुट स्ट्रिंग एक ब्रैकेट के माध्यम से काम करती है। शेष इनपुट हमेशा उस पंक्ति के अंत में रखा जाता है जो वर्तमान नेस्टिंग स्तर से मेल खाती है।

Answer 9

अजगर, 161 बाइट्स

यहाँ मैं एक लाइन कार्यात्मक अजगर समाधान के साथ आया था:

p=lambda s:filter(None,sum([''.join([s[i]for i in range(len(s))if s[:i+1].count('(')-s[:i+1].count(')')==d and s[i]!=')']).split('(')for d in range(len(s))],[]))

यह चुनौती https://github.com/samcoppini/Definition-book से प्रेरित थी , जो पैतृक भाषा में परिभाषित शब्द के साथ एक लंबी स्ट्रिंग को आउटपुट करती है। मैं कोड लिखना चाहता था जो मुझे प्रत्येक वाक्य देगा, जिसमें कोष्ठक हटा दिया जाएगा। कार्यात्मक समाधान लंबे तारों पर प्रभावी होने के लिए बहुत धीमा है, लेकिन अनिवार्य समाधान (जैसे @ क्क्सप्लसोन के समाधान) बहुत तेज हैं।