अनावश्यक कोष्ठक निकालें

Question

आपको पात्रों के साथ एक तार दिया गया है 0123456789+*()। आप मान सकते हैं कि स्ट्रिंग हमेशा एक वैध गणितीय अभिव्यक्ति है।

आपका काम अनावश्यक कोष्ठक को हटाना है, यह मानते हुए कि गुणन में जोड़ की तुलना में अधिक प्राथमिकता है।

कोष्ठक को केवल तभी हटाया जाना चाहिए जब उन्हें संरचनात्मक रूप से आवश्यक न हो :

• गुणन के कारण उच्च प्राथमिकता: 3+(4*5)=>3+4*5
• गुणन या जोड़ की वजह से: 3*(4*5)=>3*4*5
• जब वे एक अभिव्यक्ति के आसपास बेमानी हैं: 3*((4+5))=>3*(4+5)

कोष्ठकों को तब रखा जाना चाहिए जब विशिष्ट संख्या मानों के कारण उनका सरलीकरण किया जा सके:

• 1*(2+3) को सरलीकृत नहीं किया जाना चाहिए 1*2+3
• 0*(1+0) को सरलीकृत नहीं किया जाना चाहिए 0*1+0

उदाहरण:

(4*12)+11         ==>    4*12+11
(1+2)*3           ==>    (1+2)*3
3*(4*5)           ==>    3*4*5
((((523))))       ==>    523
(1+1)             ==>    1+1
1*(2*(3+4)*5)*6   ==>    1*2*(3+4)*5*6
1*(2+3)           ==>    1*(2+3)
0*(1+0)           ==>    0*(1+0)


(((2+92+82)*46*70*(24*62)+(94+25))+6)    ==>    (2+92+82)*46*70*24*62+94+25+6

Comments

अधिक वृषण कृपया?

— लीक नून

1*(2*(3+4)*5)*6एक दिलचस्प टेस्टकेस होना चाहिए (जो मेरा समाधान वर्तमान में विफल रहता है)।

— लीक नून

"अनावश्यक" को संरचनात्मक रूप से या प्रति-मामले के आधार पर परिभाषित किया गया है? दूसरे शब्दों में, क्या यहाँ कोष्ठक अनावश्यक हैं? (2+2)*1

— लुइस मेंडो

@LuisMendo मुझे लगता है कि इसकी व्याख्या किसी भी तरह से करना उचित है

— anatolyg

@anatolyg मुझे नहीं लगता कि यह उचित होगा, क्योंकि दोनों के लिए दृष्टिकोण बहुत भिन्न होंगे। यह अच्छा होगा अगर हमें कुछ स्पष्टीकरण मिले।

— Sp3000

Answer 1

गणितज्ञ, 105 97 91 बाइट्स

^{-6 बाइट्स रोमन को धन्यवाद !}

a=StringReplace;ToString@ToExpression@a[#,{"*"->"**","+"->"~~"}]~a~{" ** "->"*","~~"->"+"}&

के स्थान पर +और *साथ ~~( StringExpression) और **( NonCommutativeMultiply) क्रमश: यह stringifies यह मूल्यांकन करता है, और ऑपरेटरों वापस बदल देता है।

Comments

क्या? Mathematica में अंतर्निहित नहीं है?

— ऑर्गन आउटगॉल्फ

@EriktheGolfer यह मूल रूप से करता है; मैं इसे संचालकों का मूल्यांकन नहीं करने की कोशिश कर रहा हूं ।

— लीजियनममाल 978

यही कारण है कि मैथेमेटिका इतनी विज्ञापन और इतनी महंगी है ... क्योंकि मुझे लगता है कि बिल्ट-इन है। लेकिन, यदि अन्य भाषाएं पूरी तरह से कठिन नहीं हैं, तो गणितज्ञों को अन्य भाषाओं में बदलाव नहीं मिला है, फिर भी "अन्य भाषाएं" यहां प्रतिस्पर्धा नहीं करती हैं।

— आउटगोल्फर

91 बाइट्स केStringExpression बजाय का उपयोग करके Dot, और " "->""क्लॉज को हटाकर :a=StringReplace;ToString@ToExpression@a[#,{"*"->"**","+"->"~~"}]~a~{" ** "->"*","~~"->"+"}&

— रोमन

@Roman धन्यवाद! ऐसा लगता है कि आपको एक और अच्छा सहयोगी गैर-कम्यूटेटिव अनवैल्यूएटेड ऑपरेटर मिला है जो संख्याओं के साथ संयोजन नहीं करता है।

— लीजनमोनमल 978

Answer 2

जावास्क्रिप्ट (ईएस 6) 163 178

15 बाइट्स संपादित करें thx @IsmaelMiguel को बचाया

a=>eval(`s=[]${_=';for(b=0;a!=b;a=b.replace(/'}\\(([^()]*)\\)(?=(.?))/,(x,y,z,p)=>~y.indexOf('+')?-s.push(b[p-1]=='*'|z=='*'?x:y):y))b=a;${_}-\\d+/,x=>s[~x]))b=a`)

कम गोल्फ वाला

a=>{
  for(s=[],b='';
      a!=b;
      a=b.replace(/\(([^()]*)\)(?=(.?))/,(x,y,z,p)=>y.indexOf('+')<0?y:-s.push(b[p-1]=='*'|z=='*'?x:y)))
    b=a;
  for(b=0;
      a!=b;
      a=b.replace(/-\d+/,x=>s[~x]))
    b=a;
  return a
}

परीक्षा

f=a=>eval(`s=[]${_=';for(b=0;a!=b;a=b.replace(/'}\\(([^()]*)\\)(?=(.?))/,(x,y,z,p)=>~y.indexOf('+')
?-s.push(b[p-1]=='*'|z=='*'?x:y)
:y))b=a;${_}-\\d+/,x=>s[~x]))b=a`)

console.log=x=>O.textContent+=x+'\n'

test=`(4*12)+11         ==>    4*12+11
(1+2)*3           ==>    (1+2)*3
3*(4*5)           ==>    3*4*5
((((523))))       ==>    523
(1+1)             ==>    1+1
1*(2*(3+4)*5)*6   ==>    1*2*(3+4)*5*6
1*(2+3)           ==>    1*(2+3)
0*(1+0)           ==>    0*(1+0)
(((2+92+82)*46*70*(24*62)+(94+25))+6)    ==>    (2+92+82)*46*70*24*62+94+25+6`

test.split`\n`.forEach(r=>{
  var t,k,x
  [t,,k]=r.match(/\S+/g)
  x=f(t)
  console.log((x==k?'OK ':'KO ')+t+' -> '+x+(x==k?'':' expected '+k))
})

<pre id=O></pre>

Comments

आपने y.indexOf('+')इसके बजाय क्यों लिखा y.indexOf`+`[...]? ([...] स्वरूपण को टालने से बचने के लिए जोड़ा गया) क्या यह इस तरह से खराब हो रहा था?

— इस्माइल मिगेल

यहाँ आप जाते हैं, 170 बाइट्स:a=>eval(`for(b=s=[]${_=';a!=b;a=b.replace(/'}\\(([^()]*)\\)(?=(.?))/,(x,y,z,p)=>~y.indexOf('+')<0?-s.push(b[p-1]=='*'|z=='*'?x:y):y))b=a;for(b=0${_}-\\d+/,x=>s[~x]))b=a`)

— इस्माईल मिगुएल

@IsmaelMiguel जो वास्तव में चतुर है, धन्यवाद! सबक सीखा: जब eval के लिए गुजर रहा है, इसे फिर से पुनर्विचार करें

— edc65

मुझे खुशी है कि आपको अपना कोड कम करने का मेरा सरल उपाय पसंद आया। काश मैं इसके बारे में for(b=, =='*'और अन्य दोहराया बिट्स कर सकता। इसके अलावा, के ~y.indexOf('+')<0रूप में ही नहीं है ~y.indexOf('+')? चूंकि एकमात्र मान जो indexOf()रिटर्न देता है -1, जो गलत मूल्य का मूल्यांकन करता है , <0बेमानी लगता है। या, अगर मुझे यह गलत लगा, तो आप कर सकते हैंy.indexOf('+')>1

— इस्माइल मिगुएल

@IsmaelMiguel 1: हाँ, <0यह अनप्लग्ड वर्जन से बकवास है और इसे हटा दिया जाना चाहिए। 2: फिर से सोचने पर, forदोहराया जाने वाले हिस्से में शामिल होने के लिए संशोधित किया जा सकता है। धन्यवाद फिर से

— edc65

Answer 3

पायथन 3 + 271 बाइट्स में पायथन कार्यान्वयन

import peg
e=lambda o,m=0:o.choice and str(o)or(m and o[1][1]and"("+e(o[1])+")"or e(o[1]))if hasattr(o,"choice")else o[1]and e(o[0],1)+"".join(str(x[0])+e(x[1],1)for x in o[1])or e(o[0])
print(e(peg.compile_grammar('e=f("+"f)*f=p("*"p)*p="("e")"/[0-9]+').parse(input())))

कुछ समय पहले मैंने पायथन में एक पीईजी कार्यान्वयन किया था । मुझे लगता है कि मैं यहाँ का उपयोग कर सकते हैं।

एक पेड़ में अभिव्यक्ति को पार्स करता है, और केवल बच्चे के अलावा होने पर लघुकोष्ठक रखता है, और माता-पिता गुणा है।

Answer 4

पर्ल, 132 बाइट्स

-pध्वज के लिए 129 बाइट्स स्रोत + 3 :

#!perl -p
0while s!\(([^\(\)]+)\)!$f{++$i}=$1,"_$i"!e;s!_$i!($v=$f{$i})=~/[+]/&&($l.$r)=~/[*]/?"($v)":$v!e
while($l,$i,$r)=/(.?)_(\d+)(.?)/

का उपयोग करते हुए:

echo "1*(2*(3+4)*5)*6" | perl script.pl

Answer 5

रूबी, 140 130 बाइट्स

-pध्वज के लिए 127 बाइट्स स्रोत + 3 :

t={}
r=?%
0while$_.gsub!(/\(([^()]+)\)/){t[r+=r]=$1;r}
0while$_.gsub!(/%+/){|m|(s=t[m])[?+]&&($'[0]==?*||$`[/\*$/])??(+s+?):s}

और अपुष्ट:

tokens = Hash.new
key = '%'

# convert tokens to token keys in the original string, innermost first
0 while $_.gsub!(/\(([^()]+)\)/) { # find the innermost parenthetical
  key += key # make a unique key for this token
  tokens[key] = $1
  key # replace the parenthetical with the token key in the original string
}

# uncomment to see what's going on here
# require 'pp'
# pp $_
# pp tokens

# convert token keys back to tokens, outermost first
0 while $_.gsub!(/%+/) {|key|
  str = tokens[key]
  if str['+'] and ($'[0]=='*' or $`[/\*$/]) # test if token needs parens
    '(' + str + ')'
  else
    str
  end
}
# -p flag implicity prints $_

Comments

बहुत अच्छा जवाब। 0 whileवाक्य रचना के साथ क्या हो रहा है ?

— जोनाह

@ जोना रूबी में, expr while condके बराबर है while cond; expr; end। यहां, मैं केवल condबार-बार प्रदर्शन करना चाहता हूं और वास्तव में एक लूप बॉडी नहीं है। आमतौर पर कोई यह लिखता है while cond; endया शायद loop{ break unless cond }लेकिन 0 while condकम बाइट है। कुछ 0भी नहीं करता है; यह सिर्फ इसलिए है क्योंकि लूप के संक्षिप्त रूप के लिए एक बॉडी की आवश्यकता होती है।

— २२:०२

Answer 6

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

{`\(((\d+|\((((\()|(?<-5>\))|[^()])*(?(5)^))\))(\*(\d+|\((((\()|(?<-10>\))|[^()])*(?(10)^))\)))*)\)
$1
(?<!\*)\((((\()|(?<-3>\))|[^()])*(?(3)^))\)(?!\*)
$1

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

एक बार में सभी टेस्टकेस का सत्यापन करें।

व्याख्या

मुख्य बात यह है कि यह कोड है:

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

यह रेगेक्स किसी भी स्ट्रिंग से मेल खा सकता है जिसमें कोष्ठक संतुलित हैं, जैसे 1+(2+(3))+4या 2+3।

स्पष्टीकरण में आसानी के लिए, इस रेगेक्स को होने दें B।

इसके अलावा, हमें का उपयोग करते हैं <और >बजाय कोष्ठक, साथ ही के लिए pऔर mके लिए \+और \*।

कोड बन जाता है:

{`<((\d+|<B>)(m(\d+|<B>))*)>
$1
(?<!m)<B>(?!m)
$1

पहली दो पंक्तियाँ ब्रैकेट के लिए मेल खाती हैं, जिसमें केवल गुणा, उदाहरण (1*2*3)या सम्‍मिलित है (1*(2+3)*4)। उन्हें अंदर उनकी सामग्री द्वारा प्रतिस्थापित किया जाता है।

अंतिम दो पंक्तियाँ ब्रैकेट के लिए मेल खाती हैं जो पूर्ववर्ती नहीं हैं और जिनका गुणा से पालन नहीं किया जाता है। उन्हें अंदर उनकी सामग्री द्वारा प्रतिस्थापित किया जाता है।

प्रारंभिक का {`अर्थ है "इडिपोटेंट तक प्रतिस्थापित करें", जिसका अर्थ है कि प्रतिस्थापन तब तक किए जाते हैं जब तक वे या तो मेल नहीं खाते या वे स्वयं के साथ बदल दिए जाते हैं।

इस मामले में, प्रतिस्थापन तब तक किए जाते हैं जब तक वे मेल नहीं खाते।

Comments

के लिए विफल रहता है 1*(2*(3+4)*5)*6।

— orlp

@orlp धन्यवाद, निश्चित।

— लीक नून

के लिए विफल रहता है(1*(2+3)+4)*5

— Sp3000

@ Sp3000 धन्यवाद, निश्चित।

— लीक

Answer 7

पायथन 3, 274 269 359 337 336 बाइट्स

यह विधि मूल रूप से कोष्ठकों की हर संभावित जोड़ी को हटा देती है और यह देखने के लिए जांच करती है कि क्या यह अभी भी उसी का मूल्यांकन करता है।

from re import *
def f(x):
    *n,=sub('\D','',x);x=sub('\d','9',x);v,i,r,l=eval(x),0,lambda d,a,s:d.replace(s,"?",a).replace(s,"",1).replace("?",s),lambda:len(findall('\(',x))
    while i<l():
        j=0
        while j<l():
            h=r(r(x,i,"("),j,")")
            try:
                if eval(h)==v:i=j=-1;x=h;break
            except:0
            j+=1
        i+=1
    return sub('9','%s',x)%tuple(n)

दोहन ​​परीक्षण

print(f("(4*12)+11")=="4*12+11")
print(f("(1+2)*3") =="(1+2)*3")
print(f("3*(4*5)")=="3*4*5")
print(f("((((523))))")=="523")
print(f("(1+1)")=="1+1")
print(f("1*(2*(3+4)*5)*6")=="1*2*(3+4)*5*6")
print(f("(((2+92+82)*46*70*(24*62)+(94+25))+6)")=="(2+92+82)*46*70*24*62+94+25+6")
print(f("1*(2+3)")=="1*(2+3)")
print(f("0*(1+0)")=="0*(1+0)")

अपडेट

• -1 [16-10-04] अतिरिक्त स्थान हटा दिया गया
• -22 [16-05-07] की मेड उपयोग relib
• +90 [16-05-07] नए परीक्षण मामलों को संभालने के लिए अद्यतन किया गया
• -5 [16-05-07] लम्बाई से हटाया गया पैरामीटर ( l) लंबा

Comments

यह परीक्षण के मामले को विफल करता है 1*(2+3), क्योंकि ओपी ने कहा कि विशेष संख्या के मामलों के लिए सरलीकरण न करें। हालांकि अच्छा जवाब; यह मेरा उत्थान है।

— हाइपरनेत्रिनो

@AlexL। उस पकड़ने के लिए धन्यवाद! मैंने अपने परीक्षण मामलों को अपडेट नहीं किया D: लेकिन यह अब तय हो गया है।

— नॉनलाइनयरफ्रूट

Answer 8

PHP, 358 बाइट्स

function a($a){static$c=[];$d=count($c);while($g=strpos($a,')',$g)){$f=$a;$e=0;for($j=$g;$j;--$j){switch($a[$j]){case')':++$e;break;case'(':--$e;if(!$e)break 2;}}$f[$g++]=$f[$j]=' ';if(eval("return $f;")==eval("return $a;"))$c[str_replace(' ', '', $f)]=1;}if(count($c)>$d){foreach($c as$k=>$v){a($k);}}return$c;}$t=a($argv[1]);krsort($t);echo key($t);

एक प्रभावशाली लंबाई नहीं, यही मुझे इष्टतम दृष्टिकोण से कम लेने के लिए (और इष्टतम भाषा से कम का उपयोग करने के लिए) है।

स्ट्रिप्स कोष्ठक की एक जोड़ी को बाहर निकालता है, फिर परिणामस्वरूप अभिव्यक्ति को बढ़ाता है। यदि परिणाम मूल के समान है, तो यह इसे वैध अभिव्यक्तियों के मानचित्र में जोड़ता है और तब तक पुनरावृत्ति करता है जब तक कोई नया भाव नहीं मिलता है। फिर सबसे छोटी मान्य अभिव्यक्ति प्रिंट करता है।

ब्रेक जब अभिव्यक्ति का परिणाम बड़ा हो जाता है और डबल / एक्सप्रेशन नोटेशन को दिखाता है।

Answer 9

प्रोलॉग (एसडब्ल्यूआई) , 122 118 बाइट्स

T+S:-term_string(T,S).
I/O:-X+I,X-Y,Y+O.
E-O:-E=A+(B+C),A+B+C-O;E=A*(B*C),A*B*C-O;E=..[P,A,B],A-X,B-Y,O=..[P,X,Y];E=O.

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

एक विधेय //2को परिभाषित करता है जो पहले तर्क के स्ट्रिंग मान से कोष्ठक को हटाता है और अपने दूसरे तर्क के माध्यम से एक स्ट्रिंग को आउटपुट करता है। इनपुट Prolog मामले में हो सकता है, तो यह केवल होगा 81 77 को परिभाषित बाइट्स +/2वर्बोज़ से निपटने के लिए बिना term_string/2, लेकिन अनावश्यक कोष्ठकों का एक बहुत बस उस तरह के साथ शुरू हो, तो यह बहुत धोखाधड़ी के करीब हो सकता है, के बाद से ही अस्तित्व में है नहीं होगा सब कुछ है कि +/2संबद्धता को संभालना है।

मैंने =../2इसे सभी के लिए उपयोग करने की कोशिश की , लेकिन यह बहुत लंबे समय तक बाहर आया, क्योंकि तीन-बाइट ऑपरेटर जो सूचियों के साथ काम करता है, वह वास्तव में नहीं है:

प्रोलॉग (एसडब्ल्यूआई) , 124 बाइट्स

T+S:-term_string(T,S).
I/O:-X+I,X-Y,Y+O.
X-Y:-X=..[O,A,B],(B=..[O,C,D],E=..[O,A,C],F=..[O,E,D],F-Y;A-C,B-D,Y=..[O,C,D]);X=Y.

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