गणितीय अभिव्यक्तियों में `/` और `difference` के बीच ऐतिहासिक अंतर

Question

परिचय:

एक चर्चा से प्रेरित है जो पहले से ही अभिव्यक्ति $6÷2(1+2)$ बारे में कई वर्षों से चल रही है ।

अभिव्यक्ति के साथ $6÷2(1+2)$ , गणितज्ञों जल्दी से देखेंगे कि सही जवाब है $1$ , जबकि स्कूल से एक सरल गणित पृष्ठभूमि के साथ लोगों को जल्दी से देखेंगे कि सही जवाब है $9$ । तो यह विवाद कहां से है और इसलिए अलग-अलग उत्तर आए हैं? वहाँ कैसे में दो परस्पर विरोधी नियमों कर रहे हैं $6÷2(1+2)$ लिखा है। एक भाग के कारण 2(, और एक विभाजन चिह्न के कारण ÷।

हालांकि दोनों गणितज्ञों और 'आम जनता' का उपयोग करेगा PEMDAS (- Exponents - प्रभाग / गुणा - कोष्ठक जोड़ / घटाव), गणितज्ञों के लिए अभिव्यक्ति इस नीचे की तरह का मूल्यांकन किया जाता है, क्योंकि $2(3)$ सिर्फ उदाहरण के लिए की तरह है $2x^2$ एक एकपद उर्फ " जुक्सैसपोजिशन द्वारा निहित गुणन के कारण एक एकल शब्द " (और इसलिए इसका हिस्सा Pहै PEMDAS), जिसका मूल्यांकन (द्विपद उर्फ ​​दो शब्दों) से अलग किया जाएगा :$2×(3)$

$$6÷2(1+2) → \frac{6}{2(3)} → \frac{6}{6} → 1$$

जबकि 'सामान्य लोगों' के लिए, और समान होंगे (और इसलिए इसका हिस्सा है ), इसलिए वे इसके बजाय इसका उपयोग करेंगे:$2(3)$$2×(3)$MDPEMDAS

$$6÷2(1+2) → 6/2×(1+2) → 6/2×3 → 3×3 → 9$$

हालांकि, हम के रूप में मूल अभिव्यक्ति लिखा है | भले ही $6÷2×(1+2)$ , वहां अभी भी कुछ विवाद विभाजन प्रतीक के उपयोग के कारण हो सकता है ÷। आधुनिक गणित में, /और ÷प्रतीकों का एक ही अर्थ होता है: विभाजित होना। कुछ नियम पूर्व-1918 ^† विभाजन प्रतीक के बारे में ÷^†† राज्य है कि यह विभाजन प्रतीक तुलना में एक अलग अर्थ था /। इसका कारण यह है है ÷मतलब है "के लिए इस्तेमाल किया दायीं ओर की संख्या / अभिव्यक्ति के साथ बायीं ओर की संख्या / अभिव्यक्ति विभाजित " ^††† । तो $a ÷ b$ तो, होगा$(a) / (b)$ या$\frac{a}{b}$ अभी। जो मामले में$6÷2×(1+2)$लोग पूर्व 1918 तक इस तरह से मूल्यांकन किया जाना होगा:

$$6÷2×(1+2) → \frac{6}{2×(1+2)} → \frac{6}{2×3} → \frac{6}{6} → 1$$

^{†: हालाँकि मैंने कई स्रोतों की व्याख्या करते हुए पाया ÷है कि अतीत में कैसे इस्तेमाल किया गया था (नीचे, देखें), मैं 1918 के आसपास कहीं भी यह साबित करने में सक्षम साबित नहीं हो पाया। लेकिन इस चुनौती के लिए हम 1918 मान रहे थे। वह मोड़ जहां ÷और /उसी चीज का मतलब शुरू होता है, जहां वे अतीत में भिन्न थे।}

^{Have: अन्य प्रतीकों का उपयोग विभाजन के लिए अतीत में भी किया गया है, जैसे :कि 1633 में (या अब भी नीदरलैंड और अन्य यूरोपीय गैर-अंग्रेजी भाषी देशों में, क्योंकि यह वही है जो मैंने व्यक्तिगत रूप से प्राथमिक स्कूल xD में सीखा है) या )में 1540 के दशक में। लेकिन इस चुनौती के लिए हम केवल ओबेलस प्रतीक के पूर्व 1918 अर्थ पर ध्यान केंद्रित करते हैं ÷।
:: स्रोत: सामान्य में यह लेख । और पूर्व 1918 के नियमों के बारे ÷में उल्लेख किया गया है: यह फरवरी 1917 से अमेरिकी गणितीय मासिक लेख ; 1659 पृष्ठ 9 और पृष्ठ 76 से जर्मन टट्सशे बीजगणित की पुस्तक ; यह एक प्रथम पुस्तक बीजगणित में1895 पृष्ठ 46 [48/189] से ।}

थोड़ा-सा ऑफ-टॉपिक: इस अभिव्यक्ति के बारे में वास्तविक चर्चा के बारे में: इसे कभी भी इस तरह से नहीं लिखना चाहिए! यदि प्रश्न अस्पष्ट है, तो सही उत्तर अप्रासंगिक है। * "क्लोज़ क्योंकि यह स्पष्ट नहीं है कि आप क्या पूछ रहे हैं" बटन पर क्लिक करता है ।
और रिकॉर्ड के लिए, कैसियो कैलकुलेटर के विभिन्न संस्करणों को भी नहीं पता कि इस अभिव्यक्ति के साथ ठीक से कैसे व्यवहार करें:

चुनौती:

आपको दो इनपुट दिए गए हैं:

• ए (वैध) गणितीय अभिव्यक्ति केवल प्रतीकों से युक्त है 0123456789+-×/÷()
• एक साल

और तुम उत्पादन गणितीय अभिव्यक्ति का परिणाम है, वर्ष के आधार पर (जहां ÷अलग ढंग से प्रयोग किया जाता है जब $year<1918$ , लेकिन वास्तव में के रूप में ही प्रयोग किया जाता है /जब $year\ge1918$ )।

चुनौती नियम:

• आप मान सकते हैं कि गणितीय अभिव्यक्ति वैध है और केवल प्रतीकों का उपयोग करता है 0123456789+-×/÷()। इसका मतलब यह भी है कि आपको घातांक का सामना नहीं करना पड़ेगा। (तुम भी के लिए एक अलग प्रतीकों का उपयोग करने की अनुमति है ×या ÷(यानी *या %), यह गोल्फ में मदद करता है या अगर अपनी भाषा केवल ASCII समर्थन करता है तो।)
• यदि आपको अभिव्यक्ति का (शायद मैनुअल) मूल्यांकन करने में मदद मिलती है, तो आपको इनपुट-एक्सप्रेशन में स्पेस-डेलिमिटर जोड़ने की अनुमति है।
• I / O लचीला है। इनपुट एक स्ट्रिंग, चरित्र-सरणी, आदि के रूप में हो सकता है। वर्ष पूर्णांक, दिनांक-ऑब्जेक्ट, स्ट्रिंग, आदि के रूप में हो सकता है। आउटपुट एक दशमलव संख्या होगी।
• आप मान सकते हैं कि 0 परीक्षण मामलों द्वारा कोई विभाजन नहीं होगा।
• आप मान सकते हैं कि इनपुट-एक्सप्रेशन में नंबर गैर-नकारात्मक होंगे (इसलिए आपको -नकारात्मक प्रतीक बनाम -घटाव प्रतीक के रूप में विभेद करने से नहीं निपटना होगा )। उत्पादन अभी भी नकारात्मक हो सकता है!
• आप मान सकते हैं N(कि हमेशा की तरह लिखा N×(जाएगा। हम इस चुनौती में केवल विभाजन प्रतीकों /बनाम के दूसरे विवाद पर ध्यान केंद्रित करेंगे ÷।
• दशमलव आउटपुट-मान में कम से कम तीन दशमलव अंकों की सटीकता होनी चाहिए।
• इनपुट अभिव्यक्ति कई हों तो ÷(यानी $4÷2÷2$ ) के साथ $year<1918$ , वे इस तरह मूल्यांकन किया जाता है: $4÷2÷2 → \frac{4}{\frac{2}{2}} → \frac{4}{1} → 4$। (या शब्दों में:संख्या$4$अभिव्यक्ति से विभाजित है$2 ÷2$, जहां अभिव्यक्ति$2 ÷2$बारी साधन में नंबर$2$संख्या से विभाजित किया जाता है$2$।)
• ध्यान दें कि जिस तरह से ÷काम करता है परोक्ष मतलब है इस पर ऑपरेटर पूर्वता है ×और /(परीक्षण का मामला देख $4÷2×2÷3$ )।
• आप मान सकते हैं कि इनपुट-ईयर सीमा $[0000, 9999]$ ।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके जवाब के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

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

Input-expression:   Input-year:   Output:      Expression interpretation with parenthesis:

6÷2×(1+2)           2018          9            (6/2)×(1+2)
6÷2×(1+2)           1917          1            6/(2×(1+2))
9+6÷3-3+15/3        2000          13           ((9+(6/3))-3)+(15/3)
9+6÷3-3+15/3        1800          3            (9+6)/((3-3)+(15/3))
4÷2÷2               1918          1            (4/2)/2
4÷2÷2               1900          4            4/(2/2)
(1÷6-3)×5÷2/2       2400          -3.541...    ((((1/6)-3)×5)/2)/2
(1÷6-3)×5÷2/2       1400          1.666...     ((1/(6-3))×5)/(2/2)
1×2÷5×5-15          2015          -13          (((1×2)/5)×5)-15
1×2÷5×5-15          1719          0.2          (1×2)/((5×5)-15)
10/2+3×7            1991          26           (10/2)+(3×7)
10/2+3×7            1911          26           (10/2)+(3×7)
10÷2+3×7            1991          26           (10/2)+(3×7)
10÷2+3×7            1911          0.434...     10/(2+(3×7))
4÷2+2÷2             2000          3            (4/2)+(2/2)
4÷2+2÷2             1900          2            4/((2+2)/2)
4÷2×2÷3             9999          1.333...     ((4/2)×2)/3
4÷2×2÷3             0000          3            4/((2×2)/3)
((10÷2)÷2)+3÷7      2000          2.928...     ((10/2)/2)+(3/7)
((10÷2)÷2)+3÷7      1900          0.785...     (((10/2)/2)+3)/7
(10÷(2÷2))+3×7+(10÷(2÷2))+3×7
                    1920          62           (10/(2/2))+(3×7)+(10/(2/2))+(3×7)
(10÷(2÷2))+3×7+(10÷(2÷2))+3×7
                    1750          62           (10/(2/2))+(3×7)+(10/(2/2))+(3×7)
10÷2/2+4            2000          6.5          ((10/2)/2)+4
10÷2/2+4            0100          2            10/((2/2)+4)
9+6÷3-3+15/3        9630          13           9+(6/3)-3+(15/3)
9+6÷3-3+15/3        0369          3            (9+6)/(3-3+(15/3))

Answer 1

आर , 68 66 बाइट्स

function(x,y,`=`=`/`)eval(parse(t=`if`(y<1918,x,gsub('=','/',x))))

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

के =बजाय ÷और के *बजाय समानता के संकेत की उम्मीद है ×।

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

एक बोनस के रूप में, यहाँ एक ही सटीक दृष्टिकोण टसर सिंटैक्स में लागू किया गया है। इस बार हमारा विशेष डिवीजन ऑपरेटर टिल्ड ( ~) है:

जूलिया 0.7 , 51 बाइट्स

~=/;f(x,y)=eval(parse(y<1918?x:replace(x,'~','/')))

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

Comments

`=`=`/`शैतानी है! महान समाधान!

— ग्रेग

uuugggghhh मेरे विचार उसी तर्ज पर थे। काश, आपने मुझे बहुत हरा दिया। इसे ऑनलाइन आजमाएं

— Giuseppe

हालाँकि अभी तक कोडगॉल्फ भाषाओं में कोई जवाब नहीं है, लेकिन मैं आपके जूलिया जवाब को अब तक के लिए सबसे छोटा मान रहा हूं। यह संभव है कि यदि भविष्य में कोई छोटा जवाब दिया जाता है तो यह भविष्य में बदल जाएगा।

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

Answer 2

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

सहेजे गए 9 बाइट @Scott Hamper को धन्यवाद

के रूप में इनपुट लेता है (year)(expr)। उम्मीद %और *के बजाय ÷और ×।

y=>g=e=>(e!=(e=e.replace(/\([^()]*\)/,h=e=>eval(e.split`%`.reduceRight((a,c)=>y<1918?`(${c})/(${a})`:c+'/'+a))))?g:h)(e)

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

कैसे?

पत्ता अभिव्यक्ति प्रसंस्करण

$h$$e$%$y$

$y<1918$X%Y(X)/(Y)

उदाहरण:

• 8%2बन जाता है (8)/(2), जिसका सरलीकृत रूप है8/2
• 2+3%3+2 हो जाता है (2+3)/(3+2)
• 8%2%2बन जाता है (8)/((2)/(2)), जिसका सरलीकृत रूप है8/(2/2)

$y\ge 1918$, प्रत्येक %बस एक में बदल गया है /।

h = e =>                    // e = input string
  eval(                     // evaluate as JS code:
    e.split`%`              //   split e on '%'
    .reduceRight((a, c) =>  //   for each element 'c', starting from the right and
                            //   using 'a' as the accumulator:
      y < 1918 ?            //     if y is less than 1918:
        `(${c})/(${a})`     //       transform 'X%Y' into '(X)/(Y)'
      :                     //     else:
        c + '/' + a         //       just replace '%' with '/'
    )                       //   end of reduceRight()
  )                         // end of eval()

नेस्टेड एक्सप्रेशन से निपटना

जैसा कि ऊपर उल्लेख किया गया है, फ़ंक्शन $h$ पत्ता अभिव्यक्ति पर संचालित करने के लिए डिज़ाइन किया गया है, अर्थात कोष्ठक में संलग्न किसी भी अन्य उप-अभिव्यक्ति के बिना एक अभिव्यक्ति।

इसलिए हम सहायक फ़ंक्शन का उपयोग करते हैं $g$ ऐसे पत्तों के भावों की पहचान करना और उन्हें पुन: संसाधित करना।

g = e => (            // e = input
  e !=                // compare the current expression with
    ( e = e.replace(  // the updated expression where:
        /\([^()]*\)/, //   each leaf expression '(A)'
        h             //   is processed with h
      )               // end of replace()
    ) ?               // if the new expression is different from the original one:
      g               //   do a recursive call to g
    :                 // else:
      h               //   invoke h on the final string
)(e)                  // invoke either g(e) or h(e)

Comments

यहाँ एक संस्करण है hकि 9 बाइट्स छोटे हैं:h=e=>eval(e.split`%`.reduceRight((a,c)=>y<1918?`(${c})/(${a})`:c+'/'+a))

— स्कॉट हैपर

@Scott Hamper बहुत अच्छा। 'बाएं से दाएं' के पास एक घंटी होनी चाहिए ... लेकिन यह नहीं हुआ।

— अरनुलद

Answer 3

पायथन 3.8 (पूर्व-रिलीज़) , 324 310 306 बाइट्स

lambda s,y:eval((g(s*(y<1918))or s).replace('%','/'))
def g(s):
 if'%'not in s:return s
 l=r=j=J=i=s.find('%');x=y=0
 while j>-1and(x:=x+~-')('.find(s[j])%3-1)>-1:l=[l,j][x<1];j-=1
 while s[J:]and(y:=y+~-'()'.find(s[J])%3-1)>-1:r=[r,J+1][y<1];J+=1
 return g(s[:l]+'('+g(s[l:i])+')/('+g(s[i+1:r])+')'+s[r:])

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

के %बजाय ÷और के *बजाय ले जाता है×

Answer 4

पर्ल 5, 47 97 95 बाइट्स

/ /;$_="($`)";$'<1918?s-%-)/(-g:y-%-/-;$_=eval

$_="($F[0])";1while$F[1]<1918&&s-\([^()]+\)-local$_=$&;s,%,)/((,rg.")"x y,%,,-ee;y-%-/-;$_=eval

TIO

Comments

बहुत अच्छा विचार है। हालाँकि, आपके पास एक समस्या है 4%2%2जिसके साथ दोनों मामलों में 1 रिटर्न देता है। (जबकि इसे 4 पूर्व 1918 को लौटाना चाहिए)

— दादा

यह सच है, मैं इस पल के लिए अब और नहीं देख सकता

— नाहुएल फूइउल

@ दादा, तय (+ 50bytes)

— नहुएल फौइउल

Answer 5

जंग - 1066 860 783 755 740 बाइट्स

macro_rules! p{($x:expr)=>{$x.pop().unwrap()}}fn t(s:&str,n:i64)->f64{let (mut m,mut o)=(vec![],vec![]);let l=|v:&Vec<char>|*v.last().unwrap();let z=|s:&str|s.chars().nth(0).unwrap();let u=|c:char|->(i64,fn(f64,f64)->f64){match c{'÷'=>(if n<1918{-1}else{6},|x,y|y/x),'×'|'*'=>(4,|x,y|y*x),'-'=>(2,|x,y|y-x),'+'=>(2,|x,y|y+x),'/'=>(5,|x,y|y/x),_=>(0,|_,_|0.),}};macro_rules! c{($o:expr,$m:expr)=>{let x=(u(p!($o)).1)(p!($m),p!($m));$m.push(x);};};for k in s.split(" "){match z(k){'0'..='9'=>m.push(k.parse::<i64>().unwrap() as f64),'('=>o.push('('),')'=>{while l(&o)!='('{c!(o,m);}p!(o);}_=>{let j=u(z(k));while o.len()>0&&(u(l(&o)).0.abs()>=j.0.abs()){if j.0<0&&u(l(&o)).0<0{break;};c!(o,m);}o.push(z(k));}}}while o.len()>0{c!(o,m);}p!(m)}

जंग में 'eval' जैसा कुछ नहीं होता है इसलिए यह थोड़ा कठिन है। मूल रूप से, यह एक मामूली संशोधन के साथ एक दलदल-मानक जिस्क्रा शंटिंग-यार्ड इन्फिक्स मूल्यांकनकर्ता है। Variable एक वैरिएबल मिसाल वाला एक ऑपरेटर है: <1918 मोड में बाकी सब से कम (लेकिन कोष्ठक),> = 1918 मोड में बाकी सब से अधिक। 4 <'2 specification 2 विनिर्देश को पूरा करने के लिए <1918 के लिए भी यह' सही जुड़ा हुआ है '(या छोड़ दिया है), और संघ' नकारात्मकता 'को पूर्ववर्ती नकारात्मक बनाकर, फिर मूल्यांकन के दौरान किसी भी पूर्वता का इलाज करते हुए <0 जुड़ा हुआ है। गोल्फ के लिए अधिक जगह है लेकिन मुझे लगता है कि यह एक अच्छा मसौदा है।

Play.rust-lang.org पर Ungolfed

Comments

क्या आपको वास्तव में इतना व्हॉट्सएप चाहिए? मुझे लगता है कि इसे हटा दिया जा सकता है।

— ivzem

@ivzem अच्छी बात है, लेकिन अभी भी अपने अजगर से 3 गुना बड़ा है

— उज्ज्वल