65

说我有一个表达：

9 * 8 + 1 - 4

根据运算符的优先级，可以用六种不同的方式解释该表达式：

(((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 (- + *)

假设我是一名开发人员，我不想记住优先级表等，因此我只是在猜测。

在这种情况下，最大的误差幅度将是45-77，相差32。这意味着我的猜测最多只能相差32。

挑战

鉴于由数字和的表达+，-，*，/（整数除法）和%，输出该表达式的最大和最小可能的值的绝对差的基础上，操作者的优先级。

技术指标

输入表达式将不包含括号，并且每个运算符都是左关联的。
输入表达式将仅包含非负整数。但是，子表达式可能会得出负数（例如1 - 4）。
您可以采用任何合理格式的表达式。例如：
- "9 * 8 + 1 - 4"
- "9*8+1-4"
- [9, "*", 8, "+", 1, "-", 4]
- [9, 8, 1, 4], ["*", "+", "-"]
输入将包含至少1个，最多10个运算符。
包含除以0或以0为模的任何表达式都将被忽略。
您可以假设不会对模取负数。

测试用例

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

— 硕果累累
source

1

@AndersKaseorg %在第二个示例中，您好像被视为具有两个不同的优先级。

— 硕果累累

1

“六个”中的三个相同，另外两个相同。剩下三个实际案例，而不是六个。

— user207421'7

3

%运算符如何处理负数？像C或Python之类的方式？

— tsh

8

只是说，您不必在描述中添加“我很懒”部分。仅仅说您是一名开发人员就足够了。:)

— Gryphon

1

@tsh任何行为。做你想做的。你可以让恶魔从我的鼻子里飞出来。

— 硕果累累

27

Python 2中，171个 156字节

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)

在线尝试！

这个怎么运作

我们用不同数量的朝外括号对包围每个运算符，以模拟不同的优先级（以所有可能的方式），并在整个字符串周围包裹足够的朝内括号对，以得到一个表达式eval。例如，

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

我们得到

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

— 安德斯·卡塞格（Anders Kaseorg）
source

您可以通过移到or外部sum来删除一个方括号来节省2个字节：sum([...],[])or[eval(a)]代替sum([...]or[[eval(a)]],[])

— Strigoides

@Strigoides我一直认为这是不相等的，因为在sum没有参数为空的情况下，可能为空，但是实际上是很好的，因为eval在这种情况下必须失败。谢谢。

— Anders Kaseorg '17

8

果冻，126字节

“操作员优先？括号？帕，谁需要那个？” -将果冻用于操作员优先级挑战的挑战。

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

在线尝试！

输入被视为字符串，例如“ 1 + 2_3×4：5％6”。注意乘法使用“×”代替“ *”，除法使用“：”代替“ /”，减法使用“ _”代替“-”。

工作原理 该程序分为三个部分：生成具有不同运算符优先级的所有表达式，对其求值，以及返回最大值和最小值之间的差。

所有表达式都是使用以下代码生成的：

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

对此链接进行了评估（我可能会使用其他结构进行改进）：

⁾[]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

最大值和最小值之间的差异是使用链接（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.

— 火烈鸟241
source

4

可能是我见过的最长的Jelly答案（不包含嵌入式数据）。做得好！

— Keyu Gan

@KeyuGan如果您想要更长的果冻答案，请查看此答案。如果没有压缩，我想不出任何其他的Jelly长答案。

— fireflame241

6

Python 2中，235个 234 233 226字节

^{-1个字节（和一个修复）感谢Anders Kaseorg！}

^{-7个字节感谢Step 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)

在线尝试！

— Notjagan
source

1

功能提交必须是可重用的。你可以通过让解决这个问题a是一个元组，而不是一个列表，甚至通过这样做（节省1个字节a=()，a+=eval(*l),）。

— Anders Kaseorg '17

T，蒂尔。谢谢你的提示！

— notjagan

1

由于您使用的是Python 2，因此可以通过交替使用空格和制表符来缩进来节省一些字节（在这种情况下，2个空格->制表符，三个空格->制表符+空格，四个空格->两个制表符）在线尝试！

— 斯蒂芬

4

Haskell 582字节

这进展不如我希望的那样...

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

在线尝试！

尝试打高尔夫球很长的程序只会让我写错代码:(

我试图在Haskell中使用安德斯算法，但超出了我的控制范围

函数e类似于eval的特定情况。（＃）接收代表整数的字符串列表和一个运算符字符串，并返回最大和最小可能值之间的差。例如

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

— 普维兹
source

1

如果您重命名#到##，你可以重命名e到(#)，像这样：(n#s)(x:a)=...

— Esolanging水果

如果为以下三个常用功能加上别名，则可以再保存6个字节。 r=read;j=zipWith;o=map然后将这些函数替换为字母别名。

— maple_shaft

我还计算了594个字节，而不是582个字节

— 。– maple_shaft

3

Pyth，45个字节

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

我确信可以做更多的优化，但是到目前为止我还是喜欢的。

接受这样的输入：[9, 8, 1, 4], ["*", "+", "-"]。

在线尝试！

— Trebuchette
source

2

您能补充说明吗？

— 吉姆（Jim）

2

数学，186个 164 159字节

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] 占用3个字节。

一些替代方案（保持字节数相同）

#2-#&@MinMax[...] 取代 Max@#-Min@#&[...]

Head@#2 取代 #2[[0]]

在http://sandbox.open.wolframcloud.com上在线尝试：( .... )[{60, "/", 8, "%", 8, "*", 6, "%", 4, "*", 5}]用....替换为上面的测试用例代码60 / 8 % 8 * 6 % 4 * 5。按Shift + enter评估。

— 用户名
source

2

Javascript，280个字节

注意：整数除法使用下位函数取整，这意味着负数会从零舍入。

此解决方案基于此答案。

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

示例代码段：

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

展开摘要

— 赫尔曼·L
source

通过用a / b | 0替换a / b外壳使其兼容，会有多困难？

— 2015年

@trlkly a/b|0停止除/模0错误检查，但Math.floor(a/b)起作用

— Herman L

2

Haskell，254个字节

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

在线尝试！

输入是一个完整的字符串，例如4 + 5 *2。它生成操作的所有排列，并针对每个排列以递归方式拆分字符串。它使用列表monad过滤除以0的除法。

— 酒标
source

(%)是模数运算符。它是左参数和右参数之间除法运算的其余部分。

— maple_shaft

1

Python 2中，262个 256 254字节

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

在线尝试！

— 查斯·布朗
source

也可以使用制表符来节省一些字节：在线尝试！

— 斯蒂芬

1

通过改变保存一个字节in [到in[（无需空格）

— 扎卡里

1

PHP，316字节

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

在线尝试！

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

— 约格·赫尔瑟曼
source

租用情况为63。您的错误是由于在一个表达式的不同部分给同一运算符赋予不同的优先级

— H.PWiz

0

Python 3，284字节

编辑：评估最后一个示例似乎有点问题。我明天再看。

另一个Python答案。不能超越其他所有人，但是我花了太长的时间以至于无法忍受。

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)

在线尝试！

— m
source

1

while(p)可以变成while p保存一个字节。

— 扎卡里

0

Clojure的（+组合学），342 377 + 41 = 418个字节

+ 35个字节，因为一个错误。

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

在线尝试！

为了使此功能正常工作，您必须use使用clojure.math.combinatorics库（41个字节）：

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

细微差别：

该函数是一个匿名函数，这意味着您必须执行以下操作才能使用它：

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

另外，我用这个词quot，而不是/（因为Clojure的默认完成了部分事业部），和mod代替%。

非高尔夫节目：

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

— Qwerp-Derp
source

我认为您可以说“关闭+组合”，而不必对use声明打分。

— 硕果累累

@ Challenger5我相信您最好在说明中写出来，因为默认情况下，The characters used to import the library will likely be counted codegolf.meta.stackexchange.com / questions / 10225 /…

— Gan

@KeyuGan你是对的-我误解了Meta共识。我认为require需要包含在代码中，并且其长度应添加到字节数中。

— 硕果累累

@ Challenger5所以我需要在我的字节数中添加41个字节，对吗？好。

— Qwerp-Derp

@ Qwerp-Derp是的，但是导入是代码的一部分，您可以进行高尔夫运动。

— 硕果累累

0

JavaScript（ES6），210个字节

输入为数字和运算符的数组

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

少打高尔夫球

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
)

测试

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>

展开摘要

— edc65
source

运营商优先级：我怎么错？

挑战

技术指标

测试用例

Python 2中，171个 156字节

这个怎么运作

果冻，126字节

Python 2中，235个 234 233 226字节

Haskell 582字节

Pyth，45个字节

数学，186个 164 159字节

Javascript，280个字节

Haskell，254个字节

Python 2中，262个 256 254字节

PHP，316字节

Python 3，284字节

Clojure的（+组合学），342 377 + 41 = 418个字节

细微差别：

非高尔夫节目：

JavaScript（ES6），210个字节