एक प्रोग्राम लिखें, जो उन जगहों पर ब्रेसिज़ के स्थान पर बदलता है जहां स्थानों में ब्रेसिज़ ठहराव का कारण बनता है

Question

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

इनपुट एक एकल पंक्ति होगी, जिसमें कई बाएं कोष्ठक ( ( [ {) और दाएं कोष्ठक ( ) ] }) होंगे। यह भी हो सकता है, लेकिन हमेशा नहीं, टिप्पणियों ( /* */) और स्ट्रिंग शाब्दिक ( " "या ' ') और विभिन्न संख्याओं, अक्षरों, या प्रतीकों में होते हैं।

कम से कम एक ब्रैकेट (एक टिप्पणी या स्ट्रिंग शाब्दिक के बाहर) होगा जिसमें एक संक्षारण विपरीत (टिप्पणी या स्ट्रिंग शाब्दिक के बाहर) नहीं है। उदाहरण के लिए, }एक {पूर्व के बिना एक गलतफ़हमी। एक और उदाहरण: (जिसके पास )बाद में नहीं है । आपका कार्यक्रम एक स्थान के साथ बदल जाएगा, कोष्ठक की न्यूनतम संख्या कोष्ठक से मेल खाने के लिए आवश्यक है।

उदाहरण:

(4 + (2 + 3))]==> (4 + (2 + 3)) (अंत में वर्ग कोष्ठक)
][][[]]==> [][[]](शुरू में वर्ग कोष्ठक)
("Hel(o!"))==> ("Hel(o!") (अंत में कोष्ठक)
( /* )]*/==> /* )]*/ (शुरू में कोष्ठक)
{()]==> () (धनुषाकार कोष्ठक और वर्ग ब्रैकेट)

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

यह कोड गोल्फ है, इसलिए बाइट्स की न्यूनतम संख्या जीत जाती है। यदि विनिर्देश स्पष्ट नहीं हैं, तो टिप्पणियों में प्रश्न पूछें।

Comments

वूप्स, हमारे संपादन की तरह वहाँ टकरा गया। : पी सब कुछ अब तय किया जाना चाहिए।

— दरवाज़े

@Doorknob इसके लिए धन्यवाद, वैसे। कैसे रिक्त स्थान पोंछते से एसई को रोकने के लिए पता नहीं था।

— चिरायता

क्या हमें स्ट्रिंग लिटरल्स (जैसे ("foo (\") bar")) में भागने वाले सामान को संभालना है ?

— दरवाज़े

मेरा तर्क है कि इसके लिए सही आउटपुट {{(})होना चाहिए { } या इसके बराबर होना चाहिए , क्योंकि शुरुआती परिदृश्य का अर्थ है कि कोड के साथ शुरू करने के लिए काम कर रहा था, और {(})मुझे पता है कि हर प्रोग्रामिंग भाषा में बेमेल कोष्ठक के रूप में गिना जाता है (यानी "कारण ठहराव" ??)। लेकिन, फिर, मैंने पहले से ही एक उत्तर लिखा था, इसलिए मैं पक्षपाती हूं।

— DLosc

समझा। लगता है कि मैं अभी अक्षम नहीं हूं। ;)

— 23

Answer 1

रूबी, 223 वर्ण

यह बात थोड़ी लंबी हो गई।

u,b,i=[],[[],[],[]],-1
s=gets.gsub(/(\/\*|"|').*?(\*\/|"|')|~/){|m|u+=[m];?~}
s.chars{|c|i+=1
(t='{[('.index(c))?b[t].push(i):((t='}])'.index(c))&&(b[t].pop||s[i]=' '))}
b.flatten.map{|l|s[l]=' '}
puts s.gsub(/~/){u.shift}

यह जो कुछ करता है उसे पहले स्ट्रिंग्स और टिप्पणियों से निकालते हैं, इसलिए वे गिनती में नहीं आते हैं (और बाद में उन्हें वापस डालते हैं)।

फिर, यह चरित्र द्वारा स्ट्रिंग चरित्र के माध्यम से जाता है। जब यह एक उद्घाटन ब्रेस पाता है, तो यह अपनी स्थिति संग्रहीत करता है। जब यह एक समापन ब्रेस पाता है, तो यह अपने संबंधित खुले ब्रेस स्टोरेज सरणी से पॉप होता है।

यदि popरिटर्न nil(यानी पर्याप्त खुलने वाले ब्रेसिज़ नहीं थे), तो यह समापन ब्रेस को हटा देता है। इस पूरी चीज़ के हो जाने के बाद, यह शेष अतिरिक्त खुलने वाले ब्रेसिज़ को हटा देता है (अर्थात पर्याप्त समापन ब्रेसिज़ नहीं थे)।

कार्यक्रम के अंत में, यह सभी स्ट्रिंग्स और टिप्पणियों को वापस रखता है और उन्हें आउटपुट करता है।

Ungolfed:

in_str = gets

# grab strings and comments before doing the replacements
i, unparsed = 0, []
in_str.gsub!(/(\/\*|"|').*?(\*\/|"|')|\d/){|match| unparsed.push match; i += 1 }

# replaces with spaces the braces in cases where braces in places cause stasis
brace_locations = [[], [], []]
in_str.each_char.with_index do |chr, idx|
    if brace_type = '{[('.index(chr)
        brace_locations[brace_type].push idx
    elsif brace_type = '}])'.index(chr)
        if brace_locations[brace_type].length == 0
            in_str[idx] = ' '
        else
            brace_locations[brace_type].pop
        end
    end
end
brace_locations.flatten.each{|brace_location| in_str[brace_location] = ' ' }

# put the strings and comments back and print
in_str.gsub!(/\d+/){|num| unparsed[num.to_i - 1] }
puts in_str

Comments

यह गंभीर रूप से प्रभावशाली है। एक सवाल, हालांकि: यह अभी भी एक इनपुट की तरह काम करेगा (("string"/*comment*/)"string"? अगर मैं (ungolfed संस्करण) सही ढंग से पढ़ रहा हूं, तो आप अपने अनुक्रमणिका के साथ स्ट्रिंग और टिप्पणियों को unparsedसरणी में बदल देंगे, जो कि प्रतिस्थापन की ओर ले जाएगा ((12)3और फिर एक नॉनसेक्सुअल इंडेक्स 12(या 11) की तलाश कर रहा है। मैं देखता हूं कि गोल्फ का संस्करण अभी भी उपयोग करता है shift, लेकिन क्या अब भी इसके समान समस्या नहीं हो सकती है?

— DLosc

Answer 2

पायथन 3, 410 322 317

import re;a='([{';z=')]}';q=[re.findall('".*?"|/\*.*?\*/|.',input())]
while q:
 t=q.pop(0);s=[];i=0
 for x in t:
  if x in a:s+=[x]
  try:x in z and 1/(a[z.find(x)]==s.pop())
  except:s=0;break
 if[]==s:print(''.join(t));break
 while 1:
  try:
   while t[i]not in a+z:i+=1
  except:break
  u=t[:];u[i]=' ';q+=[u];i+=1

विलोपन के हर संभव सेट की कोशिश करता है, छोटे लोगों के साथ शुरू होता है, जब तक कि यह एक ऐसा नहीं मिलता जहां ब्रेस संतुलित हो। (जिससे मेरा मतलब है कि पूरी तरह से संतुलित रूप से संतुलित: {{(})उत्पादन ( ), नहीं {(})।)

पहले संस्करण में एक पुनरावर्ती जनरेटर फ़ंक्शन का उपयोग किया गया था, जो वास्तव में अच्छा था लेकिन वास्तव में लंबा भी था। यह संस्करण एक कतार का उपयोग करके एक सरल चौड़ाई-पहली खोज करता है। (हाँ, यह एक तथ्यात्मक समय एल्गोरिथ्म है। समस्या क्या है ?: ^ D)

Comments

मुझे यह पसंद है क्योंकि यह वास्तव में कम से कम निष्कासन पाता है और सही ढंग से नेस्टेड अभिव्यक्तियाँ पैदा करता है, लेकिन @vonilya द्वारा अंतिम टिप्पणी से पता चलता है कि सही नेस्टिंग महत्वपूर्ण नहीं है। हालांकि, यह वास्तव में धीमा है अगर बहुत सारे ब्रेस को हटाने की आवश्यकता है।

— रिस्की

Answer 3

सी - 406

नियमित अभिव्यक्तियों का उपयोग किए बिना सी में एक प्रयास।

#define A if((d==125||d==93||d==41)
char*s;t[256];f(i,m,n,p){while(s[i]!=0){int c=s[i],k=s[i+1],v=1,d;if((c==42&&k==47)||(c==m&&i>n))return i;if(!p||p==2){if((c==39||c==34)||(c==47&&k==42)){i=f(i,c*(c!=47),i,p+1);
c=c==47?42:c;}d=c+1+1*(c>50);A){v=f(i+1,d,i,2);if(!p&&v)t[d]++;if(p==2&&v)i=v;}}d=c;A&&!p){v=!!t[c];t[c]-=v;}if(p<2)putchar(c*!!v+32*!v);i++;}return 0;}main(int c,char*v[]){s=v[1];f(0,0,0,0);}

संकलन और चलाने के लिए (एक लिनक्स मशीन पर):
gcc -o कोष्ठक कोष्ठक
।/ ब्रैकेट "[[]]"

अपरिभाषित मामलों में जैसे [()) यह अंतिम वैध ब्रैकेट जोड़ी देता है ()

Answer 4

पायथन 3, 320

import re
O=dict(zip('([{',')]}'))
def o(s,r,m=0,t=[]):m+=re.match(r'([^][)({}/"]|/(?!\*)|/\*.*?\*/|".*?")*',s[m:]).end();return r and o(s[:m]+' '+s[m+1:],r-1,m+1,t)or(o(s,r,m+1,t+[O[s[m]]])if s[m]in O else[s[m]]==t[-1:]and o(s,r,m+1,t[:-1]))if s[m:]else not t and s
s=input();i=0;a=0
while not a:a=o(s,i);i+=1
print(a)

DLosc के समाधान की तरह, यह हर संभावित विलोपन की जांच करता है, लेकिन यह एक पुनरावर्ती अन्वेषण और फ़ॉलबैक रणनीति का उपयोग करता है जो बहुत तेज़ है। मुझे पता है कि गति कोड गोल्फ में एक मानदंड नहीं है, और संपूर्ण खोज किसी भी मामले में घातीय है, लेकिन यह ({({({({({({({({(}}}}}}}}एक-दो सेकंड में इनपुट को संभाल सकता है ।

Comments

अच्छा खेला, अच्छा खेला। मैंने 317 से नीचे जाने का प्रबंधन किया, लेकिन मुझे लगता है कि आपको आसानी से पास करने में सक्षम होना चाहिए। (इस बीच, मेरा कार्यक्रम अभी भी आपके उदाहरण इनपुट पर मंथन कर रहा है ...)

— DLosc

@DLosc: अपनी सांस पकड़ नहीं है :)। 6 खुले पारे के साथ उस पैटर्न के संस्करण को करने में मेरी मशीन को 58 मिनट का समय लगा। ब्रह्मांड के ऊष्मा-मृत्यु तक पहुंचने से पहले गतिरोध को हल करने के लिए, आपको कतार को याद करने की आवश्यकता होगी; अन्यथा, आप एक O(n!!)समाधान के साथ समाप्त होते हैं, नहीं O(n!)। (मेरा गोल्फ O(n*2^n)इसके बजाय है O(2^n), क्योंकि oवास्तव में rहटाने के साथ अप करने के लिए सभी पैटर्न पैदा करता है , बिल्कुल rहटाने के बजाय । आसान तय करने के लिए, लेकिन यह कुछ वर्णों को खर्च करेगा।)

— rici