मैं आपका BIDMAS देखता हूं और आपको BADMIS बढ़ाता हूं

चुनौती

उनके बीच ऑपरेटरों के साथ संख्याओं के एक सेट को देखते हुए: "5 + 4 * 9/3 - 8", बुनियादी कार्यों के क्रम के प्रत्येक क्रमपरिवर्तन के लिए अभिव्यक्ति के सभी संभावित परिणाम लौटाएं: [/, *, +, +, -]।

नियम

मानक खामियों से मना किया
आई / ओ
- इनपुट को इनफ़िक्स ऑपरेशंस के साथ ऑर्डर करना होगा, लेकिन फिर भी यह सबसे आसान है (स्ट्रिंग या एरे)
- आपको अपरेंटिस ऑपरेटरों का समर्थन करने की आवश्यकता नहीं है (उदाहरण के लिए "-3 * 8 / +2")
- इंटेगर को उन भाषाओं के लिए फ़्लोट से बदला जा सकता है, जो स्पष्ट रूप से पार्स प्रकार (जैसे 45 by 45.0)
- आउटपुट अभिव्यक्ति के सभी संभावित परिणाम, कोई निर्दिष्ट प्रारूप या आदेश नहीं होना चाहिए
सभी इनपुट मान्य हैं (उदाहरण के लिए "7/3 + *" से निपटने की आवश्यकता नहीं है)। इसका मतलब यह भी है कि आपको कभी भी शून्य से विभाजित करने की आवश्यकता नहीं होगी।
ऑपरेटर सभी बाएं-सहयोगी हैं इसलिए "20/4/2" = "(20/4) / 2"
यह कोड गोल्फ है इसलिए बाइट्स की सबसे कम संख्या जीतती है

परीक्षण मामले (स्पष्टीकरण के साथ)

"2 + 3 * 4" = [14, 20]
- 2 + (3 * 4) + 2 + (12) 4 14
- (2 + 3) * 4 ⟶ (5) * 4 * 20
"18/3 * 2 - 1" = [11, 2, 6]
- ((१⟶ / ३) * २) - १ (((६) * २) - १ ⟶ (१२) - १ 1 ११
- (१ (/ ३) * (२ - १) 6 (६) * (१) * ६
- (१ (/ (३ * २)) - १ 18 (१ 6 / (६)) - १ ⟶ (३) - १ 3 २
- 18 / (3 * (2 - 1)) (18 / (3 * (1)) (6
- 18 / ((3 * 2) - 1) 5 18/5 (3.6

परीक्षण मामले (स्पष्टीकरण के बिना)

"45/8 + 19/45 * 3" = [6.891666666666667, 18.141666666666666, 0.11111111111111113, 0.01234567901234568, 0.01234567901234568, 5.765740740740741]।
"2 + 6 * 7 * 2 + 6/4" = [112 196 23 87.5]

code-golf permutations

— फ्रेडी आर
स्रोत

2

हालांकि, पहली अच्छी चुनौती है।

— झबरा

निकटता से संबंधित

— Arnauld

सुझाया गया परीक्षण मामला 2 - 3 + 4=>[-5, 3]

— जो राजा

सुझाए गए परीक्षण का मामला: 2*3-6+2-9/6*8+5/2-924 अलग-अलग परिणाम देना।

— अरनौल

4

जावास्क्रिप्ट (V8) , 118 112 बाइट्स

परिणाम प्रिंट करता है।

f=(s,x='',y=x,o='+-*/')=>[...o].map(v=>f(s.split(v).join(x+v+y),x+')',y+'(',o.replace(v,'')))|print(eval(y+s+x))

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

या कटौती परिणाम देखें ।

— Arnauld
स्रोत

3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 285 बाइट्स

x=>{int c=0,j,t=1,i;for(;c++<25;t=c){var r="*+-/".ToList();for(i=j=1;j++<4;t=t/j+1)(r[j-1],r[t%j])=(r[t%j],r[j-1]);float k(float z,int p=4){char d;int l;float m;return i<x.Count&&(l=r.IndexOf(d=x[i][0]))<p?k((m=k(x[(i+=2)-1],l))*0+d<43?z*m:d<44?z+m:d<46?z-m:z/m,p):z;}Print(k(x[0]));}}

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

x=>{                                          //Lambda taking in a List<dynamic>
  int c=0,j,t=1,i;                            //A bunch of delcarations jammed together to save bytes
  for(;c++<25;t=c){                           //Loop 24 times (amount of permutations a set of length 4 can have)
    var r="/+*-".ToList();                    //Initialize r as list of operators
    for(i=j=1;j++<4;t=t/j+1)                    //Create the Tth permutation, saving result in r, also reset i to 1
      (r[j-1],r[t%j])=(r[t%j],r[j-1]);
    float k(float z,int p=4) {                //Define local function 'k', with z as current value accumalated and p as current precedence
      char d;int l;float m;                   //Some helper variables
      return i<x.Count                        //If this is not the last number
        &&(l=r.IndexOf(d=x[i][0]))<p?         //  And the current operator's precedence is higher than the current precedence
      k(                                      //  Recursive call with the accumalative value as
        (m=k(x[(i+=2)-1],l))                  //    Another recursive call with the next number following the current operator as seed value,
                                              //    And the next operator's precedence as the precedence value, and store that in variable 'm'
        *0+d<43?z*m:d<44?z+m:d<46?z-m:z/m,    //    And doing the appropriate operation to m and current value ('z')
        p)                                    //  Passing in the current precedence
    :z;                                       //Else just return the current number
    }
    Print(k(x[0]));                           //Print the result of calling k with the first number as starting value
  }
}

— अज्ञान का अवतार
स्रोत

मैंने इसे ठीक कर दिया है, इसलिए आपको डुप्लिकेट को छोड़ने की आवश्यकता नहीं है क्योंकि यह समस्या का मूलभूत हिस्सा नहीं है जैसा कि बताया गया है।

— फ्रेडी आर

1

@ अर्नुलड 4 बाइट्स की कीमत पर फिक्स्ड, यह इसलिए था क्योंकि मेरे क्रमपरिवर्तन एल्गोरिथ्म थोड़ा गलत था

— अज्ञानता

3

जावास्क्रिप्ट (Node.js) , 132 बाइट्स

a=>(w=[],F=(b,a)=>b?[...b].map(q=>F(b.replace(q,""),a.replace(eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`),eval))):w.push(a))("+-*/",a)&&w

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

यह डुप्लिकेट आउटपुट देता है।

जावास्क्रिप्ट (Node.js) , 165 161 155 153 152 137 बाइट्स

a=>Object.keys((F=(b,a)=>b?[...b].map(q=>F(b.replace(q,""),a.replace(eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`),eval))):F[a]=1)("+-*/",a)&&F)

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

ऑपरेटरों और संख्याओं के बीच रिक्त स्थान के साथ एक स्ट्रिंग लेता है।

a=>                                             // Main function:
 Object.keys(                                   //  Return the keys of the -
  (
   F=(                                          //   Index container (helper function):
    b,                                          //    Operators
    a                                           //    The expression
   )=>
    b                                           //    If there are operators left:
    ?[...b].map(                                //     For each operator:
     q=>
      F(                                        //      Recur the helper function - 
       b.replace(q,""),                         //       With the operator deleted
       a.replace(                               //       And all -
        eval(`/[\\d.-]+( \\${q} [\\d.-]+)+/g`), //        Expressions using the operator
        eval                                    //        Replaced with the evaluated result
       )
      )
    )
    :F[a]=1                                     //     Otherwise - set the result flag.
  )(
   "+-*/",                                      //    Starting with the four operators
   a                                            //    And the expression
  )
  &&F
 )

— शायरु असकोतो
स्रोत

@JoKing ने मेरे द्वारा पहले तय किए गए फिक्स को लागू किया, [3, -5]अब आउटपुट करना चाहिए ।

— शायरु असकोतो

2

पर्ल 6 , 92 90 88 बाइट्स

{map {[o](@_)($_)},<* / + ->>>.&{$^a;&{S:g{[\-?<[\d.]>+]+%"$a "}=$/.EVAL}}.permutations}

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

किसी भी ऑपरेटर के बाद एक जगह के साथ एक स्ट्रिंग लेता है और संख्याओं का एक सेट लौटाता है। यह ज्यादातर n op nऑपरेटरों के सभी क्रमपरिवर्तन के लिए eval'ed परिणाम के साथ सभी उदाहरणों को प्रतिस्थापित करके काम करता है ।

स्पष्टीकरण:

{                                                                                   }  # Anonymous code block
                    <* / + ->>>.&{                                    } # Map the operators to:
                                  $^a;&{                             }  # Functions that:
                                        S:g{                }      # Substitute all matches of:
                                            \-?<[\d.]>+]+        # Numbers
                                                         %$a     # Joined by the operator
                                                              =$/.EVAL   # With the match EVAL'd
 map {           },                                                    .permutations   # Map each of the permutations of these operators
      [o](@_)        # Join the functions
             ($_)    # And apply it to the input

— मजाक कर रहा है
स्रोत

आप इसे हटा सकते हैं set, क्योंकि डुप्लिकेट को खत्म करने की शर्त को हटा दिया गया है। अच्छा कोड है।

— फ्रेडी आर

2

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

f=lambda e,s={*"+-*/"}:[str(eval(p.join(g)))for p in s for g in zip(*map(f,e.split(p),[s-{p}]*len(e)))]or[e]

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

फ़ंक्शन इनपुट के रूप में एकल स्ट्रिंग लेता है और संभावित परिणामों की सूची देता है।

Ungolfed

def get_all_eval_results(expr, operators={*"+-*/"}):
    results = []
    for operator in operators:
        remaining_operators = operators - {operator}

        # Split expression with the current operator and recursively evaluate each subexpression with remaining operators
        sub_expr_results = (get_all_eval_results(sub_expr, remaining_operators) for sub_expr in expr.split(operator))

        for result_group in zip(*sub_expr_results):   # Iterate over each group of subexpression evaluation outcomes
            expr_to_eval = operator.join(result_group)  # Join subexpression outcomes with current operator
            results.append(str(eval(expr_to_eval)))   # Evaluate and append outcome to result list of expr
    return results or [expr]  # If results is empty (no operators), return [expr]

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

— जोएल
स्रोत

1

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

œṡ⁹¹jṪḢƭ€jŒVɗßʋFL’$?
Ḋm2QŒ!çƒ€

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

लिंक की एक जोड़ी। दूसरा मुख्य लिंक है, और इसके तर्क के रूप में संचालकों के साथ अक्षर के रूप में फ़्लोट / पूर्णांक की एक जेली सूची है। कमांड लाइन के तर्कों के साथ एक पूर्ण कार्यक्रम के रूप में चलने पर जेली इसका इनपुट लेने के तरीके का एक चपटा संस्करण है। लिंक का वापसी मूल्य एकल सदस्य सूची की सूची है, जिनमें से प्रत्येक अभिव्यक्ति के लिए एक संभावित मूल्य है।

व्याख्या

हेल्पर लिंक

अपने बाएं तर्क के रूप में ऑपरेटरों (पात्रों के रूप में) के साथ वैकल्पिक रूप से फ़्लोट्स / पूर्णांक की एक सूची लेता है और एक ऑपरेटर अपने सही तर्क के रूप में; संबंधित ऑपरेटर द्वारा अलग किए गए नंबरों का मूल्यांकन करने के बाद इनपुट सूची लौटाता है, दाएं से बाएं काम करता है।

œṡ⁹                  | Split once by the right argument (the operator currently being processed)
                   ? | If:
                  $  | - Following as a monad
                L    |   - Length
                 ’   |   - Decremented by 1
              ʋ      | Then, following as a dyad:
   ¹                 | - Identity function (used because of Jelly’s ordering of dyadic links at the start of a dyadic chain)
    j       ɗ        | - Join with the following as a dyad, using the original left and right arguments for this chain:
     ṪḢƭ€            |   - Tail of first item (popping from list) and head from second item (again popping from list); extracts the numbers that were either side of the operator, while removing them from the split list
         j           |   - Joined with the operator
          ŒV         |   - Evaluate as Python (rather than V because of Jelly’s handling of decimals with a leading zero)
            ß        | - Recursive call to this helper link (in case there are further of the same operator)
               F     | Else: Flatten

मुख्य लिंक

ऑपरेटरों के साथ बारी-बारी से सूची / पूर्णांक की सूची बनाता है (पात्रों के रूप में)

Ḋ         | Remove first item (which will be a number)
 m2       | Every 2nd item, starting with the first (i.e. the operators)
   Q      | Uniquify
    Œ!    | Permutations
      çƒ€ | For each permuted list of operators, reduce using the helper link and with the input list as the starting point

— निक केनेडी
स्रोत

1

पायथन 2 , 182 172 बाइट्स

import re
def f(s,P=set('+-/*')):
 S=[eval(s)]
 for p in P:
	t=s
	while p+' 'in t:t=re.sub(r'[-\d.]+ \%s [-\d.]+'%p,lambda m:`eval(m.group())`,t,1)
	S+=f(t,P-{p})
 return S

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

फ्लोट के रूप में स्वरूपित किलों के साथ इनपुट लेता है, "इंटेगर को उन भाषाओं के लिए फ़्लोट्स द्वारा प्रतिस्थापित किया जा सकता है, जो कि स्पष्ट रूप से पार्स प्रकार" हैं।

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

1

जूलिया 1.2 , 88 (82) बाइट्स

f(t)=get(t,(),[f.([t[1:i-1];t[i+1](t[i],t[i+2]);t[i+3:end]] for i=1:2:length(t)-2)...;])

julia> f([2, +, 3, *, 4])
2-element Array{Int64,1}:
 20
 14

julia> f([18, /, 3, *, 2, -, 1])
6-element Array{Float64,1}:
 11.0
  6.0
  2.0
  3.6
  6.0
  6.0

नंबरों की एक वेक्टर के रूप में एक टेप लेता है और फ़ंक्शंस को संक्रमित करता है, प्रत्येक एकल फ़ंक्शन कॉल का मूल्यांकन करता है और प्रत्येक परिणामी टेप को पुन: पास करता है जब तक कि केवल एक ही संख्या शेष न हो। दुर्भाग्य से, get(t, (), ...)जूलिया 1.0 में ठीक से काम नहीं करता है, इसलिए एक नए संस्करण की आवश्यकता है।

छह बाइट्स को बचाया जा सकता है, अगर नेस्टेड सरणियों का एक गुच्छा आउटपुट के रूप में स्वीकार्य है:

f(t)=get(t,(),f.([t[1:i-1];t[i+1](t[i],t[i+2]);t[i+3:end]] for i=1:2:length(t)-2))

आउटपुट:

julia> f([18, /, 3, *, 2, -, 1])
3-element Array{Array{Array{Float64,1},1},1}:
 [[11.0], [6.0]]
 [[2.0], [3.6]] 
 [[6.0], [6.0]]

— user3263164
स्रोत

0

पर्ल 5 ( `-alp`), 89 बाइट्स

my$x;map{$x.=$`.(eval$&.$1).$2.$"while/\d+[-+*\/](?=(\d+)(.*))/g}@F;$_=$x;/[-+*\/]/&&redo

TIO

या अद्वितीय मान, 99 बाइट्स

my%H;map{$H{$`.(eval$&.$1).$2}++while/\d+[-+*\/](?=(\d+)(.*))/g}@F;$_=join$",keys%H;/[-+*\/]/&&redo

— नहुएल फौलीउल
स्रोत

मैं आपका BIDMAS देखता हूं और आपको BADMIS बढ़ाता हूं

मैं आपका BIDMAS देखता हूं और आपको BADMIS बढ़ाता हूं

चुनौती

नियम

परीक्षण मामले (स्पष्टीकरण के साथ)

परीक्षण मामले (स्पष्टीकरण के बिना)

जावास्क्रिप्ट (V8) , 118 112 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 285 बाइट्स

जावास्क्रिप्ट (Node.js) , 132 बाइट्स

जावास्क्रिप्ट (Node.js) , 165 161 155 153 152 137 बाइट्स

पर्ल 6 , 92 90 88 बाइट्स

स्पष्टीकरण:

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

Ungolfed

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

व्याख्या

हेल्पर लिंक

मुख्य लिंक

पायथन 2 , 182 172 बाइट्स

जूलिया 1.2 , 88 (82) बाइट्स

पर्ल 5 ( -alp), 89 बाइट्स

पर्ल 5 ( `-alp`), 89 बाइट्स