Tôi thấy BIDMAS của bạn và tăng cho bạn một BADMIS

Thử thách

Cho một tập hợp các số có toán tử giữa chúng: "5 + 4 * 9/3 - 8", trả về tất cả các kết quả có thể có của biểu thức cho mọi hoán vị của thứ tự các thao tác cơ bản: [/, *, +, -].

Quy tắc

• Sơ hở tiêu chuẩn bị cấm
• Tôi / O
  • Đầu vào phải được sắp xếp với các thao tác infix, tuy nhiên đó là dễ nhất (chuỗi hoặc mảng)
  • Bạn không cần phải hỗ trợ các toán tử đơn nguyên (ví dụ: "-3 * 8 / +2")
  • Số nguyên có thể được thay thế bằng số float cho các ngôn ngữ ngầm định kiểu phân tích cú pháp (ví dụ 45 45.0)
  • Đầu ra phải là tất cả các kết quả có thể có của biểu thức, không có định dạng hoặc thứ tự được chỉ định
• Tất cả các đầu vào là hợp lệ (ví dụ: không cần phải xử lý "7/3 + *"). Điều này cũng có nghĩa là bạn sẽ không bao giờ cần chia cho số không.
• Các toán tử đều liên kết trái nên "20/4/2" = "(20/4) / 2"
• Đây là Code Golf nên số byte thắng ít nhất

Các trường hợp thử nghiệm (Có giải thích)

• "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

Các trường hợp thử nghiệm (Không cần giải thích)

• "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]

JavaScript (V8) ,  118  112 byte

In kết quả.

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

Hãy thử trực tuyến!

Hoặc xem kết quả trùng lặp .

C # (Trình biên dịch tương tác Visual C #) , 285 byte

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]));}}

Hãy thử trực tuyến!

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 byte

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

Hãy thử trực tuyến!

Điều này cho phép đầu ra trùng lặp.

JavaScript (Node.js) , 165 161 155 153 152 137 byte

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)

Hãy thử trực tuyến!

Lấy một chuỗi có khoảng trắng giữa toán tử và số.

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 byte

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

Hãy thử trực tuyến!

Lấy một chuỗi có khoảng trắng sau bất kỳ toán tử nào và trả về một tập hợp số. Điều này chủ yếu hoạt động bằng cách thay thế tất cả các trường hợp n op nvới kết quả được đánh giá cho tất cả các hoán vị của các toán tử.

Giải trình:

{                                                                                   }  # 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 byte

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]

Hãy thử trực tuyến!

Hàm lấy một chuỗi làm đầu vào và trả về một danh sách các kết quả có thể.

Ung dung

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]

Hãy thử trực tuyến!

Thạch , 30 byte

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

Hãy thử trực tuyến!

Một cặp liên kết. Liên kết thứ hai là liên kết chính và lấy tham số của nó là một danh sách Jelly của số float / số nguyên xen kẽ với các toán tử dưới dạng các ký tự. Đây là phiên bản dẹt của cách Jelly lấy đầu vào của nó khi chạy dưới dạng một chương trình đầy đủ với các đối số dòng lệnh. Giá trị trả về của liên kết là một danh sách danh sách các danh sách thành viên, mỗi danh sách là một giá trị có thể có cho biểu thức.

Giải trình

Liên kết trợ giúp

Lấy một danh sách các số float / số nguyên xen kẽ với các toán tử (dưới dạng ký tự) làm đối số bên trái của nó và một toán tử là một ký tự làm đối số bên phải của nó; trả về danh sách đầu vào sau khi đánh giá các số được phân tách bởi toán tử có liên quan, làm việc từ trái sang phải.

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

Liên kết chính

Đưa ra một danh sách các số float / số nguyên xen kẽ với các toán tử (dưới dạng ký tự)

Ḋ         | 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 byte

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

Hãy thử trực tuyến!

Đưa đầu vào với số nguyên được định dạng là số float, theo "Số nguyên có thể được thay thế bằng số float cho các ngôn ngữ ngầm định kiểu phân tích cú pháp".

Julia 1,2 , 88 (82) byte

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

Thực hiện một băng dưới dạng một vectơ số và hàm số, đánh giá từng lệnh gọi hàm duy nhất và đệ quy chuyển từng băng kết quả trở lại chính nó cho đến khi chỉ còn lại một số. Không may,get(t, (), ...) không hoạt động đúng trong Julia 1.0, vì vậy cần có phiên bản mới hơn.

Sáu byte có thể được lưu, nếu một loạt các mảng lồng nhau được chấp nhận làm đầu ra:

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

Đầu ra:

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 byte

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

TIO

hoặc các giá trị duy nhất, 99 byte

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