ฉันเห็น BIDMAS ของคุณและสร้าง BADMIS ให้คุณ

ท้าทาย

กำหนดตัวเลขที่มีตัวดำเนินการระหว่าง: "5 + 4 * 9/3 - 8" ให้ส่งกลับผลลัพธ์ที่เป็นไปได้ทั้งหมดของนิพจน์สำหรับการเรียงลำดับของการดำเนินการพื้นฐานทุกครั้ง: [/, *, +, -]

กฎระเบียบ

• ช่องโหว่มาตรฐานต้องห้าม
• I / O
  • ต้องป้อนข้อมูลด้วยการดำเนินการมัด แต่ที่ง่ายที่สุด (สตริงหรืออาร์เรย์)
  • คุณไม่จำเป็นต้องสนับสนุนผู้ประกอบการเอก (เช่น "-3 * 8 / +2")
  • จำนวนเต็มสามารถแทนที่ด้วยการลอยสำหรับภาษาที่แจงโดยปริยายประเภท (เช่น 45 ⟶ 45.0)
  • ผลลัพธ์จะต้องเป็นผลลัพธ์ที่เป็นไปได้ทั้งหมดของการแสดงออกไม่มีรูปแบบหรือคำสั่งที่ระบุ
• อินพุตทั้งหมดใช้งานได้ (เช่นไม่จำเป็นต้องจัดการกับ "7/3 + *") นี่ก็หมายความว่าคุณไม่จำเป็นต้องหารด้วยศูนย์
• ผู้ประกอบการทุกคนมีความสัมพันธ์ทางด้านซ้ายดังนั้น "20/4/2" = "(20/4) / 2"
• นี่คือ Code Golf ที่มีจำนวนไบต์น้อยที่สุดจึงจะชนะ

กรณีทดสอบ (พร้อมคำอธิบาย)

• "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.1111111111111111113, 0.01234567901234568, 0.01234567901234568, 5.765740740740741]
• "2 + 6 * 7 * 2 + 6/4" = [112 196 23 87.5]

JavaScript (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))

ลองออนไลน์!

หรือเห็นผลซ้ำ

C # (Visual C # Interactive Compiler) , 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
  }
}

JavaScript (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

ลองออนไลน์!

สิ่งนี้อนุญาตเอาท์พุทที่ซ้ำกัน

JavaScript (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
 )

Perl 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

Python 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]

ลองออนไลน์!

เยลลี่ 30 ไบต์

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

ลองออนไลน์!

ลิงค์คู่หนึ่ง อันที่สองคือลิงค์หลักและใช้เป็นอาร์กิวเมนต์ของรายการ Jelly ของจำนวนเต็ม / จำนวนเต็มสลับกับตัวดำเนินการเป็นตัวอักษร นี่เป็นเวอร์ชันที่แบนราบของวิธีที่ Jelly ใช้อินพุตเมื่อรันเป็นโปรแกรมเต็มรูปแบบที่มีอาร์กิวเมนต์บรรทัดคำสั่ง ค่าที่ส่งคืนของลิงก์คือรายการของรายการของรายการสมาชิกเดี่ยวซึ่งแต่ละรายการมีค่าที่เป็นไปได้สำหรับนิพจน์

คำอธิบาย

ลิงค์ผู้ช่วยเหลือ

ใช้รายการของ floats / จำนวนเต็มสลับกับตัวดำเนินการ (เป็นอักขระ) เป็นอาร์กิวเมนต์ซ้ายและตัวดำเนินการเป็นอักขระเป็นอาร์กิวเมนต์ที่ถูกต้อง ส่งคืนรายการอินพุตหลังจากประเมินตัวเลขที่คั่นด้วยตัวดำเนินการที่เกี่ยวข้องโดยทำงานจากซ้ายไปขวา

œṡ⁹                  | 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

Python 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

ลองออนไลน์!

รับอินพุตด้วยรูปแบบ ints เป็นลอยตาม "จำนวนเต็มสามารถแทนที่ด้วยลอยสำหรับภาษาที่แจงโดยปริยายประเภท"

Julia 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, (), ...)ทำงานไม่ถูกต้องใน Julia 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]] 

Perl 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