Nói rằng tôi có một biểu thức:

9 * 8 + 1 - 4

Biểu thức này có thể được diễn giải theo sáu cách khác nhau, tùy thuộc vào quyền ưu tiên của toán tử:

(((9 * 8) + 1) - 4) = 69 (* + -)
((9 * 8) + (1 - 4)) = 69 (* - +)
((9 * (8 + 1)) - 4) = 77 (+ * -)
(9 * ((8 + 1) - 4)) = 45 (+ - *)
((9 * 8) + (1 - 4)) = 69 (- * +)
(9 * (8 + (1 - 4))) = 45 (- + *)

Giả sử tôi là nhà phát triển và tôi không muốn ghi nhớ các bảng ưu tiên, v.v., vì vậy tôi sẽ đoán.

Trong trường hợp này, biên sai số lớn nhất sẽ là 45-77, chênh lệch là 32. Điều này có nghĩa là dự đoán của tôi sẽ chỉ bị tắt tối đa là 32.

Các thách thức

Với một biểu thức bao gồm các con số và +, -, *, /(phân chia số nguyên) và %, sản lượng chênh lệch tuyệt đối của giá trị lớn nhất và nhỏ nhất có thể cho biểu rằng, dựa trên các ưu tiên của các nhà khai thác.

Thông số kỹ thuật

• Biểu thức đầu vào sẽ không chứa dấu ngoặc đơn và mọi toán tử được liên kết trái.
• Biểu thức đầu vào sẽ chỉ chứa các số nguyên không âm. Tuy nhiên, biểu hiện phụ có thể đánh giá tiêu cực (ví dụ 1 - 4).
• Bạn có thể lấy biểu thức ở bất kỳ định dạng hợp lý. Ví dụ:
  • "9 * 8 + 1 - 4"
  • "9*8+1-4"
  • [9, "*", 8, "+", 1, "-", 4]
  • [9, 8, 1, 4], ["*", "+", "-"]
• Đầu vào sẽ chứa ít nhất 1 và tối đa 10 toán tử.
• Bất kỳ biểu thức nào có chứa phép chia hoặc modulo bằng 0 nên được bỏ qua.
• Bạn có thể giả sử rằng modulo sẽ không được đưa ra toán hạng âm.

Các trường hợp thử nghiệm

9 * 8 + 1 - 4             32
1 + 3 * 4                  3
1 + 1                      0
8 - 6 + 1 * 0              8
60 / 8 % 8 * 6 % 4 * 5    63

Python 2 , 171 156 byte

lambda a:max(e(a))-min(e(a))
u=')%s('
def e(a,t=u):
 try:b=[eval(a)]
 except:b=[]
 return sum([e('(%s)'%a.replace(o,t%o),u%t)for o in"+-*/%"if' '+o in a],b)

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

Làm thế nào nó hoạt động

Chúng tôi bao quanh mỗi toán tử với một số cặp ngoặc đơn hướng ra ngoài khác nhau để mô phỏng các ưu tiên khác nhau (theo tất cả các cách có thể) và bọc đủ các cặp dấu ngoặc đơn hướng vào trong toàn bộ chuỗi, để có được biểu thức chúng ta có thể eval. Ví dụ với

+↦ )+(
*↦ ))*((
-↦)))-(((

chúng tôi nhận được

9 * 8 + 1 - 4↦ (((9 ))*(( 8 )+( 1 )))-((( 4)))= 77.

Thạch , 126 byte

"Toán tử ưu tiên? Dấu ngoặc đơn? Pah, ai cần điều đó?" - những thách thức của việc sử dụng Jelly cho một thách thức ưu tiên người vận hành.

⁾[]i$€Ḥæ%3+\¬œp¹Ḋ€
ǵḟØDO%9µÐṀṪɓœṣ⁹,ṚÑj@¥/
ǵVṾµ1ĿFḟØDḟ”-Lµ?ÐL
5Ḷx@€“]“[”ż⁸j/€,@y³Fɓ³i@€Ṁ’x@“[“]”jÇ
“+_×:%”Œ!Ç€µṾL_L’ỊµÐfV€ṢIS

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

Đầu vào được lấy dưới dạng chuỗi, ví dụ: "1 + 2_3 × 4: 5% 6". Lưu ý nhân sử dụng "×" thay vì "*", phép chia sử dụng ":" thay vì "/" và phép trừ sử dụng "_" thay vì "-".

Cách thức hoạt động Chương trình được chia thành ba phần: tạo ra tất cả các biểu thức ưu tiên toán tử khác nhau, đánh giá chúng và trả về chênh lệch giữa mức tối đa và tối thiểu.

Tất cả các biểu thức được tạo bằng mã:

5Ḷx@€“]“[”ż⁸j/€,@y³Fɓ³i@€Ṁ’x@“[“]”jÇ (4) helper link: returns all outputs given a permutation. Input e.g. "_+:×%"
5Ḷx@€“]“[”           - repeat outer brackets to get ["",""],["]","["],["]]","[["],["]]]","[[["],["]]]]","[[[["]
          ż⁸j/€      - insert the operations in to get "_","]+[","]]:[[","]]]×[[[","]]]]%[[[["
               ,@    - turn this into a mapping equivalent to "_"↦"_","+"↦"]+[",":"↦"]]:[[","×"↦"]]]×[[[","%"↦"]]]]%[[[["
                 y³F - use this mapping to get the right number of outward brackets on each operation. e.g. "1]+[3]]]×[[[4"
ɓ³i@€Ṁ’x@“[“]”j      - add the right number of brackets to the end to get e.g."[[[1]+[3]]]×[[[4]]]"
               Ç     - this calls the link which evaluates the expression
“+_×:%”Œ!Ç€                          (5a) main link. Input e.g. "1+3×4"
“+_×:%”                                 - the string "+_×:%"
       Œ!                               - all permutations
         ǀ                             - apply link (4) to each permutation

Các liên kết được đánh giá với điều này (tôi có thể cải thiện với một cấu trúc khác):

⁾[]i$€Ḥæ%3+\¬œp¹Ḋ€      (1) Helper link: Outputs a list of expressions within brackets, e.g. "[[[1]+[3]]]×[[[4]]]"↦"[[1]+[3]]","[[4]]"
⁾[]i$€Ḥæ%3                 - map "[" to 2, "]" to -2, and any other character to 0.
          +\¬              - cumulative sum negated: 1s at characters not in brackets (includes opening brackets), 0s otherwise (includes closing brackets)
             œp¹           - partition the input, not including borders, based on the sum to get "[[[1]+[3]]","[[[4]]"
                Ḋ€         - remove opening brackets
ǵḟØDO%9µÐṀṪɓœṣ⁹,ṚÑj@¥/ (2) Return the input to this link with one of the expressions from (1) evaluated
ǵVṾµ1ĿFḟØDḟ”-Lµ?ÐL     (3) link called from part 1: Evaluates expressions
 µ  µ          µ?          - if:
     1ĿFḟØDḟ”-L            - the input contains no operators within brackets:         
  VṾ                         - evaluate this one expression with normal Jelly calculation and return to string
                           - otherwise:
Ç                            - evaluate one subexpression using link (2)
                  ÐL       - repeat this until a single output is determined

Sự khác biệt giữa tối đa và tối thiểu được tính toán với mã trong liên kết (5):

µṾL_L’ỊµÐfV€ṢIS (5b) determine difference between minimum and maximum
µ      µÐf        - filter out outputs involving division or modulo by 0. Determined with:
 ṾL_L’Ị           - actual numbers have their unevaled form Ṿ no more than one byte longer than the non-unevaled form.
          V€      - evaluate each of these valid numbers to get integers from strings
            Ṣ     - sort
             IS   - return the sum of all difference between consecutive elements.

Python 2 , 235 234 233 226 byte

^{-1 byte (và một bản sửa lỗi) nhờ có Anders Kaseorg !}

^{-7 byte nhờ Bước Hen !}

from itertools import*
def f(e,a=()):
 for o in permutations("+-*/%"):
	l=e[:]
	for c in o:
	 for i in range(len(l),0,-1):
		if l[i-1]==c:l[i-2:i+1]=["("+l[i-2]+l[i-1]+l[i]+")"]
	try:a+=eval(*l),
	except:0
 print max(a)-min(a)

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

Haskell 582 byte

Điều này đã không đi gần như tôi hy vọng nó sẽ ...

import Data.List
f x=case x of '+'->(+);'-'->(-);'*'->(*);'/'->div;_->rem
e _ s[]=s
e 1 s(')':x:a)|0<-(read$e 0""a),(x=='%'||x=='/')=""|""<-(e 0""s)=""|""<-(e 0""a)=""|0<3=show$(f x)(read$e 0""s)$read$e 0""a
e 1 s")"=e 0""s
e n s(')':a)=e(n-1)(s++")")a
e 0 s('(':a)=e 1 s a
e n s('(':a)=e(n+1)(s++"(")a
e n s(x:a)=e n(s++[x])a
n?s=take n$cycle s
a!b=e 0""(9?"("++(concat$zipWith(++)a(b++[[]]))++9?")")
c#b|l<-[read x|x<-map(c!)(a b),x/=""]=maximum l-minimum l
a c=transpose$map(\x->map((\(Just q)->q).lookup x)$map(\a->zipWith(\x y->(y,x?")"++y:x?"("))[1..5]a)$permutations"+-*%/")c

Dùng thử trực tuyến!

Cố gắng chơi golf một chương trình dài chỉ khiến tôi viết mã xấu :(

Tôi đã thử sử dụng thuật toán của Anders trong Haskell, nhưng nó đã vượt khỏi tầm kiểm soát của tôi

Hàm e giống như một trường hợp cụ thể của eval. (#) lấy danh sách các chuỗi đại diện cho số nguyên và chuỗi toán tử và trả về chênh lệch giữa giá trị tối đa và tối thiểu có thể. ví dụ

(#) ["9","8","1","4"] "*+-" => 32

Bình thường, 45 byte

KS.nm.x.vj\ u.nm+*H/kHckHGd]s.iFQY.p_{eQ-eKhK

Tôi chắc chắn rằng có thể thực hiện tối ưu hóa nhiều hơn nữa, nhưng tôi thích nó cho đến nay.

Có đầu vào như thế này : [9, 8, 1, 4], ["*", "+", "-"].

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

Toán học, 186 164 159 byte

eMax@#-Min@#&[Fold[#//.{m___,x_,#2[[0]],y_,n___}:>{m,x~Last@#2~y,n}&,e,#]&/@Permutations@{"+"@Plus,"-"[#-#2&],"*"@Times,"/"@Quotient,"%"@Mod}/. 0/0|1/0->{}]

\[Function] mất 3 byte.

Một số lựa chọn thay thế (giữ cho bytecount giống nhau)

#2-#&@MinMax[...] thay thế Max@#-Min@#&[...]

Head@#2 thay thế #2[[0]]

Dùng thử trực tuyến tại http://sandbox.open.wolframcloud.com : nhập ( .... )[{60, "/", 8, "%", 8, "*", 6, "%", 4, "*", 5}]bằng ....thay thế bằng mã ở trên cho trường hợp thử nghiệm 60 / 8 % 8 * 6 % 4 * 5. Nhấn Shift + enterđể đánh giá.

Javascript, 280 byte

Lưu ý : Các vòng chia số nguyên sử dụng hàm sàn, có nghĩa là các số âm làm tròn số 0.

Giải pháp này dựa trên câu trả lời này .

b=>(Math.max(...(f=(a,h="(",i=")",r=[...a[d="replace"](/[^-+*/%]|(.)(?=.*\1)/g,"")])=>(r[0]?(r.map((c,j)=>s=s.concat(f(h+a[d](RegExp("\\"+(n=r.concat()).splice(j,1),"g"),i+c+h)+i,h+"(",i+")",n)),s=[]),s):(a=eval(`(${a})`[d](/\(/g,"Math.floor(")))==a&&1/a?a:r))(b))-Math.min(...f(b)))

Đoạn mã ví dụ:

g=

b=>(Math.max(...(f=(a,h="(",i=")",r=[...a[d="replace"](/[^-+*/%]|(.)(?=.*\1)/g,"")])=>(r[0]?(r.map((c,j)=>s=s.concat(f(h+a[d](RegExp("\\"+(n=r.concat()).splice(j,1),"g"),i+c+h)+i,h+"(",i+")",n)),s=[]),s):(a=eval(`(${a})`[d](/\(/g,"Math.floor(")))==a&&1/a?a:r))(b))-Math.min(...f(b)))

for(k=0;k<5;k++)
  v=["9*8+1-4","1+3*4","1+1","8-6+1*0","60/8%8*6%4*5"][k],
  console.log(`g(${v}) = ${g(v)}`)

Haskell , 254 byte

import Data.List.Split
import Data.List
f s=(-)<$>maximum<*>minimum$permutations(zip"+-*/%"[p(+),p(-),p(*),c$div,c$mod])>>=(s!)
p=((pure.).)
c o a b=[o a b|b/=0]
s![]=[read s]
s!((x,o):y)=case splitOn[x]s>>=(!y)of[]->[];l->l?o
[a]?_=[a]
(a:b)?o=b?o>>=o a

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

Đầu vào là một chuỗi toàn bộ, chẳng hạn như 4 + 5 * 2. Nó tạo ra tất cả các hoán vị của các hoạt động và cho mỗi hoán vị sẽ chia chuỗi theo cách đệ quy. Nó lọc các phân chia bằng 0 với danh sách đơn nguyên.

Python 2 , 262 256 254 byte

from itertools import*
def r(s,o):
 try:
  while o in s:i=s.index(o)-1;s[i:i+3]=[`eval(''.join(s[i:i+3]))`]
  return s
 except:0
def f(s):
 u=[int(v[0])for v in [reduce(r,O,s.split(' '))for O in permutations('*/%+-')]if v!=None];return abs(max(u)-min(u))

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

PHP , 316 byte

<?for(;$t++<54322;)count_chars($t,3)!=12345?:$p[]=$t;foreach($p as$x){for(list($z,$q)=$_GET,$b=1,$i=0;$y=strtr($x,12345,"/%*+-")[$i++];)while(-1<$k=array_flip($q)[$y]){$n=$k+1;if($b&=$z[$n]||ord($y)%10<6)eval("\$z[$k]=$z[$k]$y$z[$n]^0;");($s=array_splice)($z,$n,1);$s($q,$k,1);}$b?$r[]=$z[0]:0;}echo max($r)-min($r);

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

Expanded
for(;$t++<54322;)
  count_chars($t,3)!=12345?:$p[]=$t;
foreach($p as$x){
  for(list($z,$q)=$_GET,$b=1,$i=0;$y=strtr($x,12345,"/%*+-")[$i++];)
    while(-1<$k=array_flip($q)[$y]){
      $n=$k+1;
      if($b&=$z[$n]||ord($y)%10<6)
        eval("\$z[$k]=$z[$k]$y$z[$n]^0;");
      ($s=array_splice)($z,$n,1);
      $s($q,$k,1);
    }
  $b?$r[]=$z[0]:0;
}
echo max($r)-min($r);

Python 3 , 284 byte

Chỉnh sửa: có vẻ như có gì đó không đúng với việc đánh giá ví dụ cuối cùng. Tôi sẽ xem xét nó vào ngày mai.

Một câu trả lời khác của Python. Không thể vượt qua mọi người khác, nhưng tôi đã dành quá nhiều thời gian cho việc này để không đưa nó lên.

from itertools import*
def f(n,o):
 z=[]
 for p in permutations("+-*/%"):
  try:
   p,x,a=[*p],n[:],o[:]
   while(p):
    for i,d in enumerate(a):
     if d==p[0]:x[i+1]=str(eval(x[i]+d+x[i+1]));x.pop(i);a.pop(i)
    p.pop(0)
   z+=x
  except:0
 z=[*map(float,z)];return max(z)-min(z)

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

Clojure (+ tổ hợp), 342 377 + 41 = 418 byte

+35 byte vì một lỗi.

(fn[x y](let[l filter s first z #(l(fn[y]y)%)r(sort(z(for[e(q/permutations[+ - * quot mod])](try(loop[t e m y a x](if(=[]t)(s a)(let[j(s t)i(reverse(keep-indexed #(if(= j %2)%)m))](recur(rest t)(l #(not= j %)m)(loop[d 0 h a](if(=(count i)d)h(let[c(nth i d)f(inc c)](recur(inc d)(vec(z(assoc h c(j(nth h c)(nth h f))f nil)))))))))))(catch Exception _ nil)))))](-(last r)(s r))))

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

Đối với chức năng này để làm việc, bạn phải usecác clojure.math.combinatoricsthư viện (41 byte):

(use '[clojure.math.combinatorics :as q])

Sắc thái:

Hàm này là một hàm ẩn danh, có nghĩa là bạn phải làm điều này để sử dụng nó:

((fn[x y]...) numbers operators)

Ngoài ra, tôi đang sử dụng từ quotthay vì /(vì Clojure không phân chia theo mặc định) và modthay vì %.

Chương trình Ungolfed:

(defn precedence [numbers operators]
  (let [results
        (sort
          (for [permute (c/permutations [+ - * / mod])]
            (loop [p-temp permute
                  o-temp operators
                  n-temp numbers]
              (if (empty? o-temp) (first n-temp)
                (let [first-p (first p-temp)
                      indices (reverse (keep-indexed #(when (= first-p %2) %) o-temp))]
                  (recur
                    (rest p-temp)
                    (filter #(not= first-p %) o-temp)
                    (loop [ind 0
                          n-through n-temp]
                      (if (= ind (count indices)) n-through
                        (let [current-ind (nth indices ind)]
                          (recur
                            (inc ind)
                            (vec
                              (filter #(not (nil? %))
                                (assoc n-through
                                  current-ind (first-p (nth n-through current-ind) (nth n-through (inc current-ind)))
                                  (inc current-ind) nil)))))))))))))]
    (- (last results) (first results))))

JavaScript (ES6), 210 byte

Nhập dưới dạng một mảng các số và toán tử

k=>(m=n=-k,r=(o,k,j=0)=>{for(o||(m=m>k?m:k,n=n<k?n:k);q=o[j++];(q>'%'&q<'/'||z)&&r(o.slice(0,j-1)+o.slice(j),h))for(h=[...k],z=1;i=h.indexOf(q)+1;h.splice(i-2,3,eval(a=h[i-2]+q+h[i])|0))z*=h[i]})('+-*/%',k)|m-n

Ít chơi gôn

k=>(
  m = n = NaN,
  r =(o, k, j=0) => {
    // try all operators in o
    for(;q = o[j]; j++)
    {  
      // q : current operator, 
      // look for q inside the expression to evaluate
      for(h = [...k], z = 1; i = h.indexOf(q) + 1;)
      {
        a = h[i - 2]
        b = h[i]
        z *= b // trace if any second operand is zero
        // subst subexpression with its value
        h.splice(i - 2, 3, eval(a + q + b) | 0)
      }
      // now all subexp involving current operator are evaluated
      // the result is ok if current operator is not % or /
      //  OR if no second operand was zero
      (q > '%' & q < '/' || z) && 
        // try again recursively
        // using the remaining operators and the remaining expression
        r(o.slice(0, j) + o.slice(j+1), h) 
    }
    // if no more operators to try, check max and min
    // k is an array with 1 element, can be used like a single number
    o || (
      m = m > k ? m : k, 
      n = n < k ? n : k
    )
  },
  r('+-*/%', k),
  m-n
)

Kiểm tra

var F=
k=>(m=n=-k,r=(o,k,j=0)=>{for(o||(m=m>k?m:k,n=n<k?n:k);q=o[j++];(q>'%'&q<'/'||z)&&r(o.slice(0,j-1)+o.slice(j),h))for(h=[...k],z=1;i=h.indexOf(q)+1;h.splice(i-2,3,eval(a=h[i-2]+q+h[i])|0))z*=h[i]})('+-*/%',k)|m-n

function update() {
  var input = I.value.match(/\d+|\S/g)
  var result = F(input)
  O.textContent = I.value + ' -> ' + result + ' (max:'+m+' min:'+n+')'
}

update()

<input id=I value="60 / 8 % 8 * 6 % 4 * 5" oninput='update()'>
<pre id=O></pre>