गणितीय प्रतिस्थापन

Question

कभी-कभी एक गणित समस्या को कई इनपुट के साथ चलाना उपयोगी होता है। इस चुनौती का लक्ष्य एक ऐसा कार्यक्रम बनाना है जो इस कार्य को आसान बनाता है।

संख्या पैदा करने वाले भाव

आपको 3 प्रकार की अभिव्यक्ति का समर्थन करना चाहिए:

• एकल संख्या जनरेटर: बहुत सरल, बस एक शाब्दिक संख्या
• मल्टी-नंबर जनरेटर: एक बालक अधिक जटिल। पैर वर्ग कोष्ठक ( []) से घिरे होते हैं । संख्याएँ अल्पविराम ( ,) अभिव्यक्ति में अलग होती हैं। उदाहरण है [-1,2,3.26]।
• रेंज जनरेटर: यह एक घुंघराले ब्रेसिज़ ( {}) से घिरा हुआ है । इसमें 3 नंबर एक अल्पविराम द्वारा अलग होंगे। इस अभिव्यक्ति का प्रारूप है {start,stop,step}। startऔर stopसमावेशी हैं।

मूल्यांकन के नियम

• आपको संचालन के क्रम का समर्थन करना चाहिए। ( https://en.wikipedia.org/wiki/Order_of_operations#Definition )
• आपको कोष्ठक का समर्थन करने की आवश्यकता नहीं है।
• अभिव्यक्ति में कोई भी स्थान हो सकता है।
• आपको फ़्लोटिंग पॉइंट नंबरों का समर्थन करना चाहिए (जो भी आपकी भाषा की सटीकता ठीक है)।
• 0परिणामों में विभाजन NaN(एक संख्या में नहीं)।

आपके कार्यक्रम को गुणा ( *), विभाजन ( /), जोड़ ( +) और घटाव ( -) का समर्थन करना चाहिए ।

उत्पादन

आउटपुट की प्रत्येक पंक्ति जनरेटर के संयोजनों में से एक है। प्रारूप अभिव्यक्ति है (वास्तविक संख्याओं में इसे प्रतिस्थापित किया गया है) इसके बाद एक बराबर चिन्ह ( =) और मूल्यांकन का परिणाम है। जनरेटर के सभी संयोजनों को आउटपुट में प्रस्तुत किया जाना चाहिए।

उदाहरण

( >>>इनपुट को दर्शाता है)

>>>3 * [3,2]
3 * 3 = 9
3 * 2 = 6

>>>{1,2,3}
1 = 1 <-- this is because 1 + 3 > the end

>>>{0,2,1} + {0,1,1}
0 + 0 = 0
1 + 0 = 1
2 + 0 = 2
0 + 1 = 1
1 + 1 = 2
2 + 1 = 3

>>>6/[2,3]
6/2 = 3
6/3 = 2

>>>{1.5,2.5,0.5}
1.5 = 1.5
2 = 2
2.5 = 2.5

>>>3-{6,5,-1}
3-6 = -3
3-5 = -2

>>>5/{-1,1,1}
5/-1 = -5
5/0 = NaN
5/1 = 5

>>>4.4 / [1,2.2] + {0,2,1}
4.4 / 1 + 0 = 4.4
4.4 / 1 + 1 = 5.4
4.4 / 1 + 2 = 6.4
4.4 / 2.2 + 0 = 2
4.4 / 2.2 + 1 = 3
4.4 / 2.2 + 2 = 4

>>> [1,2] / 0 + 5
1 / 0 + 5 = NaN
2 / 0 + 5 = NaN

कार्यक्रम को छोटा करने की आवश्यकता है इसलिए मैं इसे याद कर सकता हूं और इसे कहीं भी उपयोग कर सकता हूं।

_{सैंडबॉक्स में इस पोस्ट के साथ मेरी मदद करने के लिए @PeterTaylor और @geokavel को धन्यवाद}

Comments

आपको फ़्लोटिंग पॉइंट नंबरों का समर्थन करना चाहिए (जो भी आपकी भाषा की सटीकता ठीक है)। क्या होगा यदि मेरी भाषा केवल पूर्णांक अंकगणित का समर्थन करती है? क्या मैं यह दावा कर सकता हूं कि मेरे पास शून्य-दशमलव स्थान सटीक FP है?

— डिजिटल ट्रॉमा

क्या इनपुट मिक्स रेंज और मल्टी-नंबर्स को मिला सकता है?

— माल्टीसेन

@DigitalTrauma मैंने उन भाषाओं के बारे में नहीं सोचा था .... मैं कहूंगा कि नहीं।

— जे एटकिन

इसके अलावा, x/0NaN के लिए तत्काल मूल्यांकन होता है, या क्या मुझे NaN को एक मूल्य के रूप में मानना ​​है?

— माल्टीसेन

@ मैलेटेन हां, क्या मुझे एक उदाहरण शामिल करना चाहिए?

— जे एटकिन

Answer 1

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

f=x=>(a=0,x=x.replace(/\[.+?]|{.+?}/,r=>([i,l,n]=a=r.slice(1,-1).split`,`,r[0]>"]"&&eval(`for(a=[];n>0?i<=+l:i>=+l;i-=-n)a.push(i)`),"x")),a?a.map(n=>f(x.replace("x",n))).join``:x+` = ${r=eval(x),r<1/0?r:NaN}
`)

व्याख्या

एक पुनरावर्ती फ़ंक्शन जो अभिव्यक्ति को निष्पादित करता है यदि इसमें कोई बहु-संख्या या श्रेणी जनरेटर शामिल नहीं है, या यदि यह इनमें से किसी एक जनरेटर को शामिल करता है, तो उसके द्वारा उत्पादित प्रत्येक संख्या के साथ प्रतिस्थापित जनरेटर के साथ कॉल करता है।

0जावास्क्रिप्ट में विभाजित करके उत्पादन करता है Infinity, इसलिए Infinityबस के साथ प्रतिस्थापित किया जा सकता है NaN।

इस पद्धति का उपयोग करके बहु-जनरेटर परीक्षण मामलों में आगे-पीछे के बजाय बैक-टू-फ्रंट से पार्स किए जाते हैं। इसका मतलब यह है कि कभी-कभी आउटपुट अभिव्यक्तियों का क्रम अलग होता है।

f=x=>(
  a=0,                                           // initialise a to false
  x=x.replace(/\[.+?]|{.+?}/,r=>(                // find the first multi-generator
    [i,l,n]=                                     // i = start, l = stop, n = step
      a=r.slice(1,-1).split`,`,                  // a = each number of generator
    r[0]>"]"&&                                   // if a range generator was found
      eval(`                                     // use eval to enable for loop here
        for(a=[];n>0?i<=+l:i>=+l;i-=-n)a.push(i) // add each number of the range to a
      `),
    "x"                                          // replace the generator with "x"
  )),
  a?                                             // if a multi-generator was found
    a.map(n=>                                    // for each number n in a
      f(x.replace("x",n))                        // call itself with n inserted
    )
    .join``                                      // combine the output of each result
  :x+` = ${r=eval(x),                            // evaluate the expression
    r<1/0?r:NaN}
`                                                // replace Infinity with NaN
)

परीक्षा

टेस्ट ब्राउज़र संगतता के लिए विनाशकारी असाइनमेंट का उपयोग नहीं करता है।

f=x=>(a=0,x=x.replace(/\[.+?]|{.+?}/,r=>(a=r.slice(1,-1).split`,`,r[0]>"]"&&eval(`i=a[0],l=a[1],n=a[2];for(a=[];n>0?i<=+l:i>=+l;i-=-n)a.push(i)`),"x")),a?a.map(n=>f(x.replace("x",n))).join``:x+` = ${r=eval(x),r<1/0?r:NaN}
`)

<input type="text" id="input" value="4.4 / [1,2.2] + {0,2,1}" />
<button onclick="result.textContent=f(input.value)">Go</button>
<pre id="result"></pre>

Comments

यह वास्तव में मेरे संशोधित जवाब के बहुत करीब है।

— जे एटकिन

Answer 2

हास्केल, 474 362 बाइट्स

फ़ंक्शन f इनपुट के रूप में एक स्ट्रिंग लेता है और परिणामों को प्रिंट करता है

g '+'=(+);g '-'=(-);g '*'=(*);g '/'=(\a b->a*b/b/b)
p[]=[]
p(o:x:y)=[(flip(g o)$n,' ':o:' ':show n)|n<-v]:p r where
    [f,e,s]=z;(z,h)=reads('[':y)!!0;(w,m)=reads(x:y)!!0;(v,r)|x=='['=(z,h)|x=='{'=([f,f+s..e],h)|True=([w],m)
h '}'=']';h x=x
d(a,b)=putStrLn.drop 3$foldl(++)""b++" = "++show(foldl(flip($))0a)
f t=mapM_(d.unzip)$sequence$p(filter(/=' ')$'+':map h t)

परीक्षण:

main=do
    f "4.4 / [1,2.2] + {0,2,1}"
    putStrLn""
    f "[1,2] / 0 + 5"
    putStrLn""
    f "{0,2,1} + {0,1,1}"

उत्पादन:

4.4 / 1.0 + 0.0 = 4.4
4.4 / 1.0 + 1.0 = 5.4
4.4 / 1.0 + 2.0 = 6.4
4.4 / 2.2 + 0.0 = 2.0
4.4 / 2.2 + 1.0 = 3.0
4.4 / 2.2 + 2.0 = 4.0

1.0 / 0.0 + 5.0 = NaN
2.0 / 0.0 + 5.0 = NaN

0.0 + 0.0 = 0.0
0.0 + 1.0 = 1.0
1.0 + 0.0 = 1.0
1.0 + 1.0 = 2.0
2.0 + 0.0 = 2.0
2.0 + 1.0 = 3.0

Answer 3

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

def a(q,d=-1,f='',g=float,h=print):
 if any((c in q)for c in'[]{}'):
  for i,b in enumerate(q):
   if d!=-1:
    if b in'}]':
     e=f.split(",")
     if b=='}':
      r=g(e[0]);s=[]
      while r<=g(e[1]):s.append(str(r));r+=g(e[2])
      e[:]=s[:]
     [a(q[:d]+n+q[i+1:])for n in e];return
    f+=b
   if b in'[{':d=i
 else:
  h(q+" = ",end='')
  try:h(str(eval(q)))
  except:h("NaN")

आप इसे निम्न कोड से जांच सकते हैं:

tests=['3 * [3,2]', '{1,2,3}', '{0,2,1} + {0,1,1}',
       '6/[2,3]', '{1.5,2.5,0.5}', '3-{6,5,-1}',
       '5/{-1,1,1}', '4.4 / [1,2.2] + {0,2,1}',
       '[1,2] / 0 + 5']

for n in tests:
    print(n)
    a(n)
    print()

यहाँ कोड ungolfed है:

def eval_statement(query):
    left_bracket_index = -1
    inside_bracket_content = ''
    if any((bracket in query) for bracket in '[]{}'):
        for i, character in enumerate(query):
            if left_bracket_index != -1:
                if character in '}]':
                    params = inside_bracket_content.split(",")
                    if character == '}':
                        value = float(params[0])
                        values = []
                        while value <= float(params[1]):
                            values.append(str(value))
                            value += float(params[2])
                        params[:] = values[:]
                    for param in params:
                        new_query = query[:left_bracket_index] + param + query[i + 1:]
                        eval_statement(new_query)
                    return
                inside_bracket_content += character
            if character in '[{':
                left_bracket_index = i
    else:
        print(query + " = ", end='')
        try:
            print(str(eval(query)))
        except:
            print("NaN")

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

Comments

(थोड़ा देर से) प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!

— J Atkin

आपको आवश्यकता क्यों है e[:]=s[:]? क्या e[:]=sऐसा नहीं होगा ?

— साइओस

Answer 4

जावा, 874 बाइट्स

void E(String s)throws Exception{int i=0;String t;List<String[]>z=new ArrayList<>();List<String>x=new ArrayList<>(),y=new ArrayList<>();for(String k:s.split(" "))t+=" "+(k.matches("[0-9]+")?"["+k+"]":k);for(String k:t.split(" "))s+=" "+(k.matches("\\{[^\\}]+\\}")?"["+R(k)+"]":k);for(String k:s.split(" "))t+=" "+(k.matches("\\[[^\\]]+\\]")?"$"+(i+=z.add(k.replaceAll("[\\[\\]]","").split(","))):k);x.add(t.substring(1));while (i-->0){y.clear();for(String e:x)for(String l:z.get(i))y.add(e.replace("$"+i,l));x.clear();x.addAll(y);}for(String e:x)System.out.println(e+"="+new javax.script.ScriptEngineManager().getEngineByName("JavaScript").eval(e).replace("Infinity","NaN"));}
String R(String t){String y="",[]s=t.replaceAll("[\\{\\}]","").split(",");int i=I(s[0]);y+="["+i;while ((i+=I(s[2]))<=I(s[1]))y+=","+i;y+="]";return y;}
int I(String t){return Integer.parseInt(t);}

---

विस्तृत यहाँ देखें

import java.util.*;
import java.lang.*;
import java.io.*;

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;

class Ideone
{
    // single : x -> [x]
    public static String expandSingle (String input)
    {
        String out = "";
        for (String str : input.split(" "))
        {
            out += " ";
            if(str.matches("[0-9]+"))
            {
                out += "["+str+"]";
            }
            else
            {
                out += str;
            }
        }
        return out.substring(1);
    }

    // range : {start,end,step} -> [x,..,y]
    public static String expandRange (String input)
    {
        String out = "";
        int a,b,c;
        int i=0;
        for (String str : input.split(" "))
        {
            out += " ";
            if(str.matches("\\{[0-9]+,[0-9]+,[0-9]+\\}"))
            {
                str = str.replaceAll("[\\{\\}]","");
                a = Integer.parseInt(str.split(",")[0]);
                b = Integer.parseInt(str.split(",")[1]);
                c = Integer.parseInt(str.split(",")[2]);

                out += "["+a;
                while ((a+=c) <= b) out += ","+a;
                out += "]";
            }
            else
            {
                out += str;
            }
        }
        return out.substring(1);
    }

    public static void main (String[] args) throws java.lang.Exception
    {
        String input = "3 * [3,2] + {0,2,1}";
        System.out.println(" input = "+input);
        input = expandSingle(input);
        input = expandRange(input);
        System.out.println(" expand = "+input);
        evaluate(input);
    }

    public static void evaluate (String input) throws java.lang.Exception
    {
        int i = 0;
        String t = "";
        ArrayList<String[]> set = new ArrayList<String[]>();
        ArrayList<String> in = new ArrayList<String>();
        ArrayList<String> out = new ArrayList<String>();

        // map sets
        for (String str : input.split(" "))
        {
            t += " ";
            if(str.matches("\\[.+\\]"))
            {
                str = str.replaceAll("[\\[\\]]","");
                set.add(str.split(","));
                t+= "$"+i;
                i++;
            }
            else t+=str;
        }
        in.add(t.substring(1));

        // generate expressions
        while (i-->0)
        {
            out.clear();
            for (String exp : in)
            {
                for (String sub : set.get(i))
                {
                    out.add(exp.replace("$"+i,sub));
                }
            }
            in.clear();
            in.addAll(out);
        }

        ScriptEngineManager mgr = new ScriptEngineManager();
        ScriptEngine engine = mgr.getEngineByName("JavaScript");

        // print expressions
        for (String exp : in)
        {
            System.out.println(" "+exp+" = "+engine.eval(exp).replace("Infinity","NaN"));
        }
    }
}

Answer 5

डायलॉग एपीएल , 164 बाइट्स

यह उत्तर अद्यतन आवश्यकताओं का पालन नहीं करता है, और इसलिए गैर-प्रतिस्पर्धी है:

{n←⊂'NaN'
R←{+\b,s/⍨⌊((2⊃⍵)-b←⊃⍵)÷s←⊃⌽⍵}
D←{0::n⋄⍺×÷⍵}
↑(∊¨(,⍎'[-+×D]'⎕R','⊢e),¨¨⊂('[-+×÷]'⎕S'\0'⊢⍵),⊂'='),¨,⍎e←'{' '}' '\[' ']' '÷' '[-+×]'⎕R'(R ' ')' '(' ')' '∘.D ' '∘.{0::n⋄⍺\0⍵}'⊢⍵}

यह दिए गए अभिव्यक्ति को संबंधित APL (और सभी ऑपरेटरों को लागू करने के लिए संशोधित किया गया है NaN) में बदलने के लिए और ऑपरेटरों को निकालने के लिए रीगेक्स का उपयोग करता है । यह सभी ऑपरेटरों को कैटेनेशन के साथ प्रतिस्थापित करता है और अंतिम इनपुट संख्या प्राप्त करने के लिए अभिव्यक्ति को निष्पादित करता है। यह फिर अंतिम उत्पादन प्राप्त करने के लिए इसे एक साथ बुनता है।

एपीएल (सख्त दाएं-बाएं) के मूल्यांकन के आदेश को संरक्षित करता है।

कोष्ठक को सही ढंग से संभालता है।

परीक्षण के मामले (जोड़े गए कोष्ठक के साथ गणित जैसे निष्पादन के आदेश को लागू करने के लिए):

      f '3 × [3,2]'
3 × 3 = 9
3 × 2 = 6
      f '{1,2,3}'
1 = 1
      f '{0,2,1} + {0,1,1}'
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 2
2 + 0 = 2
2 + 1 = 3
      f '6÷[2,3]'
6 ÷ 2 = 3
6 ÷ 3 = 2
      f '{1.5,2.5,0.5}'
1.5 = 1.5
2   = 2  
2.5 = 2.5
      f '3-{6,5,¯1}'
3 - 6 = ¯3
3 - 5 = ¯2
      f '5÷{¯1,1,1}'
5 ÷ ¯1 =  ¯5 
5 ÷  0 = NaN 
5 ÷  1 =   5 
      f '(4.4 ÷ [1,2.2]) + {0,2,1}'
4.4 ÷ 1   + 0 = 4.4
4.4 ÷ 1   + 1 = 5.4
4.4 ÷ 1   + 2 = 6.4
4.4 ÷ 2.2 + 0 = 2  
4.4 ÷ 2.2 + 1 = 3  
4.4 ÷ 2.2 + 2 = 4  
      f '([1,2] ÷ 0) + 5'
1 ÷ 0 + 5 = NaN 
2 ÷ 0 + 5 = NaN 

Comments

क्या यह (अनमॉडिफाइड) टेस्ट केस पास करता है? यदि ऐसा है तो यह ठीक है।

— जे एटकिन

@JAtkin अब देखिए।

— आदम

नहीं, जैसा कि सबसे अच्छा मैं समझता हूं कि यह अभी भी संचालन के आदेश का समर्थन नहीं करता है।

— J Atkin

@JAtkin "आपको संचालन के क्रम का समर्थन करना चाहिए।" आपने कभी निर्दिष्ट नहीं किया कि कौन सा आदेश। यह प्रयुक्त भाषा के आदेश का समर्थन करता है। हर भाषा (हाई-स्कूल गणित शामिल) में एक मनमाना (लेकिन दुर्भाग्य से कभी-कभी अस्पष्ट भी) पूर्ववर्ती नियम होता है। एपीएल का नियम अस्पष्ट है।

— अदम

गणित के लिए मानक वही है जो मैं समझ रहा था: en.wikipedia.org/wiki/Order_of_operations#Definition । मैं उस पोस्ट को अभी जोड़ दूंगा

— जे एटकिन