65

कहो कि मेरे पास एक अभिव्यक्ति है:

9 * 8 + 1 - 4

ऑपरेटर की पूर्वता के आधार पर इस अभिव्यक्ति की व्याख्या छह अलग-अलग तरीकों से की जा सकती है:

(((9 * 8) + 1) - 4) = 69 (* + -)
((9 * 8) + (1 - 4)) = 69 (* - +)
((9 * (8 + 1)) - 4) = 77 (+ * -)
(9 * ((8 + 1) - 4)) = 45 (+ - *)
((9 * 8) + (1 - 4)) = 69 (- * +)
(9 * (8 + (1 - 4))) = 45 (- + *)

कहो मैं एक डेवलपर हूं, और मुझे पूर्ववर्ती तालिकाओं आदि को याद करने का मन नहीं है, इसलिए मैं सिर्फ अनुमान लगाने जा रहा हूं।

इस मामले में, त्रुटि का सबसे बड़ा मार्जिन 45-77 होगा, जो कि 32 का अंतर है। इसका मतलब है कि मेरा अनुमान केवल अधिकतम 32 से दूर होगा।

चुनौती

संख्या और से मिलकर एक अभिव्यक्ति को देखते हुए +, -, *, /(पूर्णांक प्रभाग) और %, उत्पादन है कि अभिव्यक्ति के लिए सबसे बड़ा और सबसे छोटा संभव मूल्य के पूर्ण अंतर, ऑपरेटरों के पूर्वता पर आधारित है।

विशेष विवरण

इनपुट एक्सप्रेशन में कोष्ठक नहीं होगा और हर ऑपरेटर लेफ्ट-एसोसिएटिव है।
इनपुट अभिव्यक्ति में केवल nonnegative पूर्णांक होंगे। हालाँकि, सबटेक्शंस नकारात्मक (जैसे 1 - 4) का मूल्यांकन कर सकते हैं ।
आप किसी भी उचित प्रारूप में अभिव्यक्ति ले सकते हैं। उदाहरण के लिए:
- "9 * 8 + 1 - 4"
- "9*8+1-4"
- [9, "*", 8, "+", 1, "-", 4]
- [9, 8, 1, 4], ["*", "+", "-"]
इनपुट में कम से कम 1 और अधिकतम 10 ऑपरेटर शामिल होंगे।
किसी भी अभिव्यक्ति जिसमें 0 से एक विभाजन या मोडुलो है, को अनदेखा किया जाना चाहिए।
आप मान सकते हैं कि मॉडुलो को नकारात्मक ऑपरेंड नहीं दिया जाएगा।

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

9 * 8 + 1 - 4             32
1 + 3 * 4                  3
1 + 1                      0
8 - 6 + 1 * 0              8
60 / 8 % 8 * 6 % 4 * 5    63

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

1

@AndersKaseorg ऐसा लगता है कि आप %अपने दूसरे उदाहरण में दो अलग-अलग मिसालें मान रहे हैं ।

— फलों के जूल

1

'छह ’में से तीन समान हैं, जैसा कि एक और दो हैं। वह तीन वास्तविक मामलों को छोड़ देता है, छह को नहीं।

— user207421

3

%नकारात्मक संख्याओं पर ऑपरेटर कैसे काम करता है? सी या पायथन की तरह या कुछ और?

— tsh

8

केवल यह कहते हुए, आपको अपने विवरण में "और मैं आलसी हूँ" भाग नहीं जोड़ना है। सिर्फ यह कहना कि आप डेवलपर हैं, काफी है। :)

— ग्राईफॉन

1

@tsh कोई भी व्यवहार। आप जो चाहे करें। आप राक्षसों को मेरी नाक से निकाल सकते हैं ।

— फल जू

27

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

lambda a:max(e(a))-min(e(a))
u=')%s('
def e(a,t=u):
 try:b=[eval(a)]
 except:b=[]
 return sum([e('(%s)'%a.replace(o,t%o),u%t)for o in"+-*/%"if' '+o in a],b)

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

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

हम प्रत्येक ऑपरेटर को अलग-अलग संख्याओं के बाहरी-सामने वाले जोड़े के साथ अलग-अलग पूर्वाग्रहों (सभी संभव तरीकों से) का अनुकरण करने के लिए घेरते हैं, और पूरे स्ट्रिंग के चारों ओर कोष्ठकों के पर्याप्त आवक-सामना करने वाले जोड़े लपेटते हैं, जिससे हमें एक अभिव्यक्ति मिल सके eval। उदाहरण के लिए, साथ

+↦ )+(
*↦ ))*((
-↦)))-(((

हमें मिला

9 * 8 + 1 - 4↦ (((9 ))*(( 8 )+( 1 )))-((( 4)))= 77।

— एंडर्स कसीगोर
स्रोत

आप वर्ग कोष्ठक की एक परत को हटाने orके sumलिए बाहर की ओर बढ़ते हुए 2 बाइट्स बचा सकते हैं: sum([...],[])or[eval(a)]इसके बजायsum([...]or[[eval(a)]],[])

— स्ट्राइगोइड्स

@Strigoides मैं सोच रहा था कि यह समकक्ष नहीं था, क्योंकि sumइसके तर्क के बिना खाली हो सकता है - हालांकि, यह वास्तव में ठीक है क्योंकि evalउस मामले में विफल होना चाहिए। धन्यवाद।

— एंडर्स कासोर्ग

8

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

"ऑपरेटर की प्राथमिकता? कोष्ठक? Pah, जो जरूरत है?" - एक ऑपरेटर पूर्वता चुनौती के लिए जेली का उपयोग करने की चुनौतियां।

⁾[]i$€Ḥæ%3+\¬œp¹Ḋ€
ÇµḟØDO%9µÐṀṪɓœṣ⁹,ṚÑj@¥/
ÇµVṾµ1ĿFḟØDḟ”-Lµ?ÐL
5Ḷx@€“]“[”ż⁸j/€,@y³Fɓ³i@€Ṁ’x@“[“]”jÇ
“+_×:%”Œ!Ç€µṾL_L’ỊµÐfV€ṢIS

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

इनपुट को एक स्ट्रिंग के रूप में लिया जाता है, जैसे "1 + 2_3 × 4: 5% 6"। नोट गुणा "*" के बजाय "×" का उपयोग करता है, विभाजन "/" के बजाय ":" का उपयोग करता है, और घटाव "-" के बजाय "_" का उपयोग करता है।

यह कैसे काम करता है कार्यक्रम को तीन भागों में विभाजित किया गया है: विभिन्न ऑपरेटर पूर्वता की सभी अभिव्यक्तियों को उत्पन्न करना, उनका मूल्यांकन करना और अधिकतम और न्यूनतम के बीच के अंतर को वापस करना।

सभी भाव कोड के साथ उत्पन्न होते हैं:

5Ḷx@€“]“[”ż⁸j/€,@y³Fɓ³i@€Ṁ’x@“[“]”jÇ (4) helper link: returns all outputs given a permutation. Input e.g. "_+:×%"
5Ḷx@€“]“[”           - repeat outer brackets to get ["",""],["]","["],["]]","[["],["]]]","[[["],["]]]]","[[[["]
          ż⁸j/€      - insert the operations in to get "_","]+[","]]:[[","]]]×[[[","]]]]%[[[["
               ,@    - turn this into a mapping equivalent to "_"↦"_","+"↦"]+[",":"↦"]]:[[","×"↦"]]]×[[[","%"↦"]]]]%[[[["
                 y³F - use this mapping to get the right number of outward brackets on each operation. e.g. "1]+[3]]]×[[[4"
ɓ³i@€Ṁ’x@“[“]”j      - add the right number of brackets to the end to get e.g."[[[1]+[3]]]×[[[4]]]"
               Ç     - this calls the link which evaluates the expression
“+_×:%”Œ!Ç€                          (5a) main link. Input e.g. "1+3×4"
“+_×:%”                                 - the string "+_×:%"
       Œ!                               - all permutations
         Ç€                             - apply link (4) to each permutation

इस के साथ लिंक का मूल्यांकन किया जाता है (मैं शायद एक अलग संरचना के साथ सुधार कर सकता हूं):

⁾[]i$€Ḥæ%3+\¬œp¹Ḋ€      (1) Helper link: Outputs a list of expressions within brackets, e.g. "[[[1]+[3]]]×[[[4]]]"↦"[[1]+[3]]","[[4]]"
⁾[]i$€Ḥæ%3                 - map "[" to 2, "]" to -2, and any other character to 0.
          +\¬              - cumulative sum negated: 1s at characters not in brackets (includes opening brackets), 0s otherwise (includes closing brackets)
             œp¹           - partition the input, not including borders, based on the sum to get "[[[1]+[3]]","[[[4]]"
                Ḋ€         - remove opening brackets
ÇµḟØDO%9µÐṀṪɓœṣ⁹,ṚÑj@¥/ (2) Return the input to this link with one of the expressions from (1) evaluated
ÇµVṾµ1ĿFḟØDḟ”-Lµ?ÐL     (3) link called from part 1: Evaluates expressions
 µ  µ          µ?          - if:
     1ĿFḟØDḟ”-L            - the input contains no operators within brackets:         
  VṾ                         - evaluate this one expression with normal Jelly calculation and return to string
                           - otherwise:
Ç                            - evaluate one subexpression using link (2)
                  ÐL       - repeat this until a single output is determined

लिंक में कोड के साथ अधिकतम और न्यूनतम के बीच अंतर की गणना की जाती है:

µṾL_L’ỊµÐfV€ṢIS (5b) determine difference between minimum and maximum
µ      µÐf        - filter out outputs involving division or modulo by 0. Determined with:
 ṾL_L’Ị           - actual numbers have their unevaled form Ṿ no more than one byte longer than the non-unevaled form.
          V€      - evaluate each of these valid numbers to get integers from strings
            Ṣ     - sort
             IS   - return the sum of all difference between consecutive elements.

— fireflame241
स्रोत

4

संभवतः सबसे लंबा जेली उत्तर (बिना एम्बेडेड डेटा) मैंने कभी देखा है। बहुत बढ़िया!

— कीउ गण

@KeyuGan यदि आप लंबे समय तक जेली उत्तर चाहते हैं, तो इस उत्तर को देखें । मैं संपीड़न के बिना किसी भी अन्य लंबे जेली जवाब के बारे में नहीं सोच सकता।

— 1fl में fireflame241

6

पायथन 2 , 235 234 233 226 बाइट्स

^{-1 बाइट (और एक फिक्स) एंडर्स कासोर्ग के लिए धन्यवाद !}

^{-7 बाइट्स स्टेप हेन को धन्यवाद !}

from itertools import*
def f(e,a=()):
 for o in permutations("+-*/%"):
	l=e[:]
	for c in o:
	 for i in range(len(l),0,-1):
		if l[i-1]==c:l[i-2:i+1]=["("+l[i-2]+l[i-1]+l[i]+")"]
	try:a+=eval(*l),
	except:0
 print max(a)-min(a)

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

— notjagan
स्रोत

1

समारोह प्रस्तुतियाँ पुन: प्रयोज्य होनी चाहिए । आप aएक सूची के बजाय टपल होने देकर उस समस्या को ठीक कर सकते हैं , और यहां तक कि ऐसा करके (1 a=(), a+=eval(*l),) 1 बाइट बचा सकते हैं ।

— एंडर्स कासोर्ग

हुह, टीआईएल। पारितोषिक के लिए धन्यवाद!

— नॉटजैगन

1

चूंकि आप पायथन 2 में हैं, आप इंडेंटेशन के लिए स्पेस और टैब को वैकल्पिक करके कुछ बाइट्स बचा सकते हैं (इस मामले में, 2 स्पेस -> टैब, तीन स्पेस -> टैब + स्पेस, चार स्पेस -> टू टैब) ऑनलाइन इसे आज़माएं!

— स्टीफन

4

हास्केल 582 बाइट्स

यह लगभग नहीं के रूप में अच्छी तरह से मुझे आशा है कि यह होगा ...

import Data.List
f x=case x of '+'->(+);'-'->(-);'*'->(*);'/'->div;_->rem
e _ s[]=s
e 1 s(')':x:a)|0<-(read$e 0""a),(x=='%'||x=='/')=""|""<-(e 0""s)=""|""<-(e 0""a)=""|0<3=show$(f x)(read$e 0""s)$read$e 0""a
e 1 s")"=e 0""s
e n s(')':a)=e(n-1)(s++")")a
e 0 s('(':a)=e 1 s a
e n s('(':a)=e(n+1)(s++"(")a
e n s(x:a)=e n(s++[x])a
n?s=take n$cycle s
a!b=e 0""(9?"("++(concat$zipWith(++)a(b++[[]]))++9?")")
c#b|l<-[read x|x<-map(c!)(a b),x/=""]=maximum l-minimum l
a c=transpose$map(\x->map((\(Just q)->q).lookup x)$map(\a->zipWith(\x y->(y,x?")"++y:x?"("))[1..5]a)$permutations"+-*%/")c

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

एक लंबा कार्यक्रम गोल्फ करने की कोशिश कर रहा है बस मुझे बुरा कोड लिखना :(

मैंने हास्केल में एंडर्स एल्गोरिथ्म का उपयोग करने की कोशिश की, लेकिन यह मेरे नियंत्रण से बाहर हो गया

फंक्शन ई एक विशिष्ट मामले की तरह है। (#) पूर्णांकों और ऑपरेटरों की एक स्ट्रिंग का प्रतिनिधित्व करने वाले तार की एक सूची लेता है और अधिकतम और न्यूनतम संभव मूल्यों के बीच का अंतर लौटाता है। जैसे

(#) ["9","8","1","4"] "*+-" => 32

— H.PWiz
स्रोत

1

आप का नाम बदला है #करने के लिए ##, आप का नाम बदलने सकता है eकरने के लिए (#)है, तो जैसे:(n#s)(x:a)=...

— Esolanging फल

यदि आप निम्नलिखित तीन सामान्य रूप से उपयोग किए जाने वाले कार्य करते हैं, तो आप एक और 6 बाइट्स बचा सकते हैं। r=read;j=zipWith;o=mapऔर फिर उन कार्यों को अक्षर उपनाम से बदल दें।

— मेपल_शाफ्ट

इसके अलावा मैं 594 बाइट्स गिन रहा हूं, 582 नहीं।

— मेपल_शॉफ्ट

3

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

KS.nm.x.vj\ u.nm+*H/kHckHGd]s.iFQY.p_{eQ-eKhK

मुझे यकीन है कि बहुत अधिक अनुकूलन किया जा सकता है, लेकिन मुझे यह अब तक पसंद है।

इस तरह इनपुट लेता है: [9, 8, 1, 4], ["*", "+", "-"]।

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

— Trebuchette
स्रोत

2

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— जिम

2

गणितज्ञ, 186 164 159 बाइट्स

eMax@#-Min@#&[Fold[#//.{m___,x_,#2[[0]],y_,n___}:>{m,x~Last@#2~y,n}&,e,#]&/@Permutations@{"+"@Plus,"-"[#-#2&],"*"@Times,"/"@Quotient,"%"@Mod}/. 0/0|1/0->{}]

\[Function] 3 बाइट्स लेता है।

कुछ विकल्प (वही रखता है)

#2-#&@MinMax[...] बदलने के लिए Max@#-Min@#&[...]

Head@#2 बदलने के लिए #2[[0]]

पर ऑनलाइन का प्रयास करें http://sandbox.open.wolframcloud.com : प्रवेश ( .... )[{60, "/", 8, "%", 8, "*", 6, "%", 4, "*", 5}]के साथ ....परीक्षण मामले के लिए ऊपर कोड द्वारा बदल दिया 60 / 8 % 8 * 6 % 4 * 5। Shift + enterमूल्यांकन करने के लिए दबाएँ ।

— user202729
स्रोत

2

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

नोट : पूर्णांक विभाजन फर्श फ़ंक्शन का उपयोग करके गोल होता है, जिसका अर्थ है कि शून्य से दूर गोल संख्या।

यह समाधान इस उत्तर पर आधारित है ।

b=>(Math.max(...(f=(a,h="(",i=")",r=[...a[d="replace"](/[^-+*/%]|(.)(?=.*\1)/g,"")])=>(r[0]?(r.map((c,j)=>s=s.concat(f(h+a[d](RegExp("\\"+(n=r.concat()).splice(j,1),"g"),i+c+h)+i,h+"(",i+")",n)),s=[]),s):(a=eval(`(${a})`[d](/\(/g,"Math.floor(")))==a&&1/a?a:r))(b))-Math.min(...f(b)))

उदाहरण कोड स्निपेट:

g=

b=>(Math.max(...(f=(a,h="(",i=")",r=[...a[d="replace"](/[^-+*/%]|(.)(?=.*\1)/g,"")])=>(r[0]?(r.map((c,j)=>s=s.concat(f(h+a[d](RegExp("\\"+(n=r.concat()).splice(j,1),"g"),i+c+h)+i,h+"(",i+")",n)),s=[]),s):(a=eval(`(${a})`[d](/\(/g,"Math.floor(")))==a&&1/a?a:r))(b))-Math.min(...f(b)))

for(k=0;k<5;k++)
  v=["9*8+1-4","1+3*4","1+1","8-6+1*0","60/8%8*6%4*5"][k],
  console.log(`g(${v}) = ${g(v)}`)

स्निपेट का विस्तार करें

— हरमन एल
स्रोत

ए / बी केस को ए / बी | ० के साथ बदलकर इसे अनुपालन करना कितना कठिन होगा?

— त्रिकली

@trlkly a/b|0ने डिवाइड / मोडुलो 0 त्रुटि जांच को रोक दिया, लेकिन Math.floor(a/b)काम किया

— हरमन एल

2

हास्केल , 254 बाइट्स

import Data.List.Split
import Data.List
f s=(-)<$>maximum<*>minimum$permutations(zip"+-*/%"[p(+),p(-),p(*),c$div,c$mod])>>=(s!)
p=((pure.).)
c o a b=[o a b|b/=0]
s![]=[read s]
s!((x,o):y)=case splitOn[x]s>>=(!y)of[]->[];l->l?o
[a]?_=[a]
(a:b)?o=b?o>>=o a

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

इनपुट एक संपूर्ण स्ट्रिंग है, जैसे कि 4 + 5 * 2. यह संचालन के सभी क्रमपरिवर्तन को उत्पन्न करता है, और प्रत्येक क्रमपरिवर्तन के लिए स्ट्रिंग को फिर से विभाजित करता है। यह सूची मोनड के साथ 0 से डिवीजनों को फ़िल्टर करता है।

— bartavelle
स्रोत

(%)मापांक ऑपरेटर है। यह बाएं तर्क और सही तर्क के बीच एक विभाजन ऑपरेशन के शेष है।

— Maple_shaft

1

पायथन 2 , 262 256 254 बाइट्स

from itertools import*
def r(s,o):
 try:
  while o in s:i=s.index(o)-1;s[i:i+3]=[`eval(''.join(s[i:i+3]))`]
  return s
 except:0
def f(s):
 u=[int(v[0])for v in [reduce(r,O,s.split(' '))for O in permutations('*/%+-')]if v!=None];return abs(max(u)-min(u))

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

— चास ब्राउन
स्रोत

टैब का उपयोग करके कुछ बाइट्स बचाएं: इसे ऑनलाइन आज़माएं!

— स्टीफन

1

बदलकर एक बाइट सहेजें in [करने के लिए in[(अंतरिक्ष की जरूरत नहीं है)

— Zachary

1

PHP , 316 बाइट्स

<?for(;$t++<54322;)count_chars($t,3)!=12345?:$p[]=$t;foreach($p as$x){for(list($z,$q)=$_GET,$b=1,$i=0;$y=strtr($x,12345,"/%*+-")[$i++];)while(-1<$k=array_flip($q)[$y]){$n=$k+1;if($b&=$z[$n]||ord($y)%10<6)eval("\$z[$k]=$z[$k]$y$z[$n]^0;");($s=array_splice)($z,$n,1);$s($q,$k,1);}$b?$r[]=$z[0]:0;}echo max($r)-min($r);

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

Expanded
for(;$t++<54322;)
  count_chars($t,3)!=12345?:$p[]=$t;
foreach($p as$x){
  for(list($z,$q)=$_GET,$b=1,$i=0;$y=strtr($x,12345,"/%*+-")[$i++];)
    while(-1<$k=array_flip($q)[$y]){
      $n=$k+1;
      if($b&=$z[$n]||ord($y)%10<6)
        eval("\$z[$k]=$z[$k]$y$z[$n]^0;");
      ($s=array_splice)($z,$n,1);
      $s($q,$k,1);
    }
  $b?$r[]=$z[0]:0;
}
echo max($r)-min($r);

— जार्ग हुल्सरमन
स्रोत

लासे का मामला 63 है। एक ही ऑपरेटर को एक ही अभिव्यक्ति के विभिन्न हिस्सों में एक अलग मिसाल देने के कारण आपकी गलती

— H.PWiz

0

पायथन 3 , 284 बाइट्स

संपादित करें: ऐसा लगता है कि पिछले उदाहरण के मूल्यांकन में कुछ गड़बड़ है। मैं कल इसे देखूंगा।

एक और पायथन जवाब। हर किसी को आउटगोल्फ नहीं किया जा सकता है, लेकिन मैंने इसे नहीं लगाने के लिए बहुत लंबा समय बिताया।

from itertools import*
def f(n,o):
 z=[]
 for p in permutations("+-*/%"):
  try:
   p,x,a=[*p],n[:],o[:]
   while(p):
    for i,d in enumerate(a):
     if d==p[0]:x[i+1]=str(eval(x[i]+d+x[i+1]));x.pop(i);a.pop(i)
    p.pop(0)
   z+=x
  except:0
 z=[*map(float,z)];return max(z)-min(z)

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

— wrymug
स्रोत

1

while(p)हो सकता है while pएक बाइट बचाया के लिए।

— Zacharý

0

क्लोजर (+ कॉम्बिनेटरिक्स), 342 377 + 41 = 418 बाइट्स

बग के कारण +35 बाइट्स।

(fn[x y](let[l filter s first z #(l(fn[y]y)%)r(sort(z(for[e(q/permutations[+ - * quot mod])](try(loop[t e m y a x](if(=[]t)(s a)(let[j(s t)i(reverse(keep-indexed #(if(= j %2)%)m))](recur(rest t)(l #(not= j %)m)(loop[d 0 h a](if(=(count i)d)h(let[c(nth i d)f(inc c)](recur(inc d)(vec(z(assoc h c(j(nth h c)(nth h f))f nil)))))))))))(catch Exception _ nil)))))](-(last r)(s r))))

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

इस समारोह में काम करने के लिए, आप के लिए है पुस्तकालय (41 बाइट्स):useclojure.math.combinatorics

(use '[clojure.math.combinatorics :as q])

बारीकियों:

यह फ़ंक्शन एक अनाम फ़ंक्शन है, जिसका अर्थ है कि आपको इसका उपयोग करने के लिए ऐसा करना होगा:

((fn[x y]...) numbers operators)

इसके अलावा, मैं इसके quotबजाय शब्द का उपयोग कर रहा हूं /(क्योंकि क्लोजर डिफ़ॉल्ट रूप से अंश विभाजन करता है), और modइसके बजाय %।

अनप्लग्ड प्रोग्राम:

(defn precedence [numbers operators]
  (let [results
        (sort
          (for [permute (c/permutations [+ - * / mod])]
            (loop [p-temp permute
                  o-temp operators
                  n-temp numbers]
              (if (empty? o-temp) (first n-temp)
                (let [first-p (first p-temp)
                      indices (reverse (keep-indexed #(when (= first-p %2) %) o-temp))]
                  (recur
                    (rest p-temp)
                    (filter #(not= first-p %) o-temp)
                    (loop [ind 0
                          n-through n-temp]
                      (if (= ind (count indices)) n-through
                        (let [current-ind (nth indices ind)]
                          (recur
                            (inc ind)
                            (vec
                              (filter #(not (nil? %))
                                (assoc n-through
                                  current-ind (first-p (nth n-through current-ind) (nth n-through (inc current-ind)))
                                  (inc current-ind) nil)))))))))))))]
    (- (last results) (first results))))

— Qwerp-Derp
स्रोत

मुझे लगता है कि आप सिर्फ "क्लोजर + कॉम्बिनेटरिक्स" कह सकते हैं और useबयान स्कोर नहीं करना है ।

— बजे फल जूल

@ चैलेंजर 5 मेरा मानना है कि आप इसे बेहतर तरीके से वर्णन में लिखेंगे, क्योंकि डिफ़ॉल्ट रूप से, The characters used to import the library will likely be counted codegolf.meta.stackexchange.com/questions/10225/…

— गण

@KeyuGan आप सही हैं - मैं गलत समझ गया कि मेटा सर्वसम्मति है। मुझे लगता है कि कोड में शामिल किएrequire जाने की जरूरत है और इसकी लंबाई को बाइट काउंट में जोड़ा जाना चाहिए।

— फलों का रस

@ चैलेंजर 5 तो मुझे अपने बाइटकाउंट में 41 बाइट्स जोड़ने की आवश्यकता है, है ना? ठीक।

— Qwerp-Derp

@ Qwerp-Derp हां, लेकिन आयात आपके कोड का हिस्सा है, और आप इसे गोल्फ कर सकते हैं।

— २:१३ में फल ११'१

0

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

संख्या और ऑपरेटरों की एक सरणी के रूप में इनपुट

k=>(m=n=-k,r=(o,k,j=0)=>{for(o||(m=m>k?m:k,n=n<k?n:k);q=o[j++];(q>'%'&q<'/'||z)&&r(o.slice(0,j-1)+o.slice(j),h))for(h=[...k],z=1;i=h.indexOf(q)+1;h.splice(i-2,3,eval(a=h[i-2]+q+h[i])|0))z*=h[i]})('+-*/%',k)|m-n

कम गोल्फ वाला

k=>(
  m = n = NaN,
  r =(o, k, j=0) => {
    // try all operators in o
    for(;q = o[j]; j++)
    {  
      // q : current operator, 
      // look for q inside the expression to evaluate
      for(h = [...k], z = 1; i = h.indexOf(q) + 1;)
      {
        a = h[i - 2]
        b = h[i]
        z *= b // trace if any second operand is zero
        // subst subexpression with its value
        h.splice(i - 2, 3, eval(a + q + b) | 0)
      }
      // now all subexp involving current operator are evaluated
      // the result is ok if current operator is not % or /
      //  OR if no second operand was zero
      (q > '%' & q < '/' || z) && 
        // try again recursively
        // using the remaining operators and the remaining expression
        r(o.slice(0, j) + o.slice(j+1), h) 
    }
    // if no more operators to try, check max and min
    // k is an array with 1 element, can be used like a single number
    o || (
      m = m > k ? m : k, 
      n = n < k ? n : k
    )
  },
  r('+-*/%', k),
  m-n
)

परीक्षा

var F=
k=>(m=n=-k,r=(o,k,j=0)=>{for(o||(m=m>k?m:k,n=n<k?n:k);q=o[j++];(q>'%'&q<'/'||z)&&r(o.slice(0,j-1)+o.slice(j),h))for(h=[...k],z=1;i=h.indexOf(q)+1;h.splice(i-2,3,eval(a=h[i-2]+q+h[i])|0))z*=h[i]})('+-*/%',k)|m-n

function update() {
  var input = I.value.match(/\d+|\S/g)
  var result = F(input)
  O.textContent = I.value + ' -> ' + result + ' (max:'+m+' min:'+n+')'
}

update()

<input id=I value="60 / 8 % 8 * 6 % 4 * 5" oninput='update()'>
<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

ऑपरेटर की मिसाल: मैं कितना गलत हो सकता हूं?

चुनौती

विशेष विवरण

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

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

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

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

पायथन 2 , 235 234 233 226 बाइट्स

हास्केल 582 बाइट्स

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

गणितज्ञ, 186 164 159 बाइट्स

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

हास्केल , 254 बाइट्स

पायथन 2 , 262 256 254 बाइट्स

PHP , 316 बाइट्स

पायथन 3 , 284 बाइट्स

क्लोजर (+ कॉम्बिनेटरिक्स), 342 377 + 41 = 418 बाइट्स

बारीकियों:

अनप्लग्ड प्रोग्राम:

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