আমি আপনার বিডমাসটি দেখতে পাচ্ছি এবং আপনাকে একটি ব্যাডমিস উত্থাপন করব

চ্যালেঞ্জ

তাদের মধ্যে অপারেটরগুলির সাথে সংখ্যার একটি সেট দেওয়া: "5 + 4 * 9/3 - 8", মৌলিক ক্রিয়াকলাপের ক্রমের প্রতিটি অনুক্রমের জন্য অভিব্যক্তির সমস্ত সম্ভাব্য ফলাফলগুলি ফিরিয়ে দিন: [/, *, +, -]।

বিধি

স্ট্যান্ডার্ড লুফোলস নিষিদ্ধ
ইনপুট / আউটপুট
- ইনপুট অবশ্যই ইনফিক্স অপারেশনের সাথে অর্ডার করতে হবে তবে তবে এটি সবচেয়ে সহজ (স্ট্রিং বা অ্যারে)
- আপনাকে আনরি অপারেটরগুলিকে সমর্থন করার প্রয়োজন নেই (যেমন "-3 * 8 / +2")
- পূর্ণসংখ্যার স্পষ্টভাবে প্রকারভেদ প্রকারের ভাষাগুলির জন্য ফ্লোট দ্বারা প্রতিস্থাপন করা যেতে পারে (উদাহরণস্বরূপ 45 ⟶ 45.0)
- আউটপুট অবশ্যই প্রকাশের সমস্ত সম্ভাব্য ফলাফল হতে হবে, কোনও নির্দিষ্ট বিন্যাস বা ক্রম নেই
সমস্ত ইনপুট বৈধ (উদাহরণস্বরূপ "7/3 + *" নিয়ে কাজ করার দরকার নেই)। এর অর্থ হ'ল আপনার কখনই শূন্য দ্বারা ভাগ করার প্রয়োজন হবে না।
অপারেটররা সকলেই বাম-সহযোগী হয় তাই "20/4/2" = "(20/4) / 2"
এটি কোড গল্ফ তাই সবচেয়ে কম সংখ্যক বাইট জিতেছে

পরীক্ষার কেস (ব্যাখ্যা সহ)

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

পরীক্ষার কেস (ব্যাখ্যা ছাড়াই)

"45/8 + 19/45 * 3" = [6.891666666666667, 18.141666666666666, 0.1111111111111111313, 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-9:, 24 স্বতন্ত্র ফলাফল প্রদান।

— আরনাউল্ড

4

জাভাস্ক্রিপ্ট (ভি 8) , 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

@ আর্নল্ড ৪ বাইটের মূল্যে নির্ধারিত হয়েছিল, কারণ আমার অনুমতিগুলি অ্যালগরিদমটি কিছুটা ভুল ছিল

— অজ্ঞতার

3

জাভাস্ক্রিপ্ট (নোড.জেএস) , 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

এটি অনলাইন চেষ্টা করুন!

এটি নকল আউটপুট অনুমতি দেয়।

জাভাস্ক্রিপ্ট (নোড.জেএস) , 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
 )

— শিয়েরু আসাকোটো
সূত্র

@ জোকিং আমার আগে ঠিক করে ফিক্সটি কার্যকর করেছে, [3, -5]এখনই আউটপুট করা উচিত ।

— শিয়ারু আসাকোটো

2

পার্ল 6 , 92 90 88 বাইট

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

এটি অনলাইন চেষ্টা করুন!

যে কোনও অপারেটরের পরে একটি স্পেসের সাথে একটি স্ট্রিং নেয় এবং সংখ্যার সেট দেয়। এটি বেশিরভাগ n op nঅপারেটরদের সমস্ত অনুমতি দেওয়ার জন্য বিস্মৃত ফলাফলের সাথে সমস্ত দৃষ্টান্ত স্থাপন করে কাজ করে ।

ব্যাখ্যা:

{                                                                                   }  # 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, (), ...)জুলিয়া ১.০ এ সঠিকভাবে কাজ করে না, সুতরাং একটি নতুন সংস্করণ প্রয়োজন।

ছয়টি বাইট সংরক্ষণ করা যায়, যদি নেস্টেড অ্যারেগুলির একগুচ্ছ আউটপুট হিসাবে গ্রহণযোগ্য হয়:

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

— নাহুয়েল ফৌইলুল
সূত্র

আমি আপনার বিডমাসটি দেখতে পাচ্ছি এবং আপনাকে একটি ব্যাডমিস উত্থাপন করব

আমি আপনার বিডমাসটি দেখতে পাচ্ছি এবং আপনাকে একটি ব্যাডমিস উত্থাপন করব

চ্যালেঞ্জ

বিধি

পরীক্ষার কেস (ব্যাখ্যা সহ)

পরীক্ষার কেস (ব্যাখ্যা ছাড়াই)

জাভাস্ক্রিপ্ট (ভি 8) , 118 112 বাইট

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 285 বাইট

জাভাস্ক্রিপ্ট (নোড.জেএস) , 132 বাইট

জাভাস্ক্রিপ্ট (নোড.জেএস) , 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 বাইট