几年前，Hot Wheels制作了一个简单的Flash游戏，名为“ Formula Fuelers Racers” *。要玩游戏，您需要从冰箱中选择三种食材放入您的汽车中，然后将其与计算机的随机生成的汽车竞争。事实证明，这款游戏的机制非常简单。首先，您汽车的实际比赛“时间”是随机生成的，与您是否赢得比赛无关。其次，比赛的获胜者是根据从所选成分中计算出的分数确定的（允许重复的成分，顺序很重要）。每种成分都有一个关联的“值”和一个关联的“操作”，如下表所示：

#   ingredient     val  op
1   Hot Salsa       2   +
2   Root Beer       1   +
3   Milk            1   +
4   Pickle Juice    2   +
5   Mystery Lunch   -3  *
6   BBQ Sauce       2   +
7   Egg             1   +
8   Ketchup         2   +
9   Mustard         -1  *
10  Melon           1   +
11  Chocolate Milk  1   +
12  Mayonnaise      -2  *
13  Baby Food       0   +
14  Pepper          1   +
15  Salt            2   +
16  Syrup           -1  *
17  Salad Dressing  2   +
18  Orange Juice    1   +
19  Soy Sauce       2   +

为了方便起见，此挑战将通过成分的编号而不是名称来指代成分。以下是计算分数的步骤：

1. 首先，使用第一个成分的值初始化分数。
2. 然后，使用第二个成分的运算将当前分数和第二个成分的值相结合以获得更新的分数。
3. 最后，使用第三成分的运算将当前分数与第三成分的值相结合以获得最终分数。

分数越高越好，并且总是比分数低。

例如，成分1 2 3的得分为(2+1)+1 = 4。这些成分7 5 6的得分为(1*-3)+2 = -1。因此，1 2 3节拍7 5 6。

挑战

在这个挑战中，您将编写一个程序，该程序接受3个整数的有序列表，并输出相应的分数。

输入项

您的程序可能会以最方便的格式接受三个整数的列表。允许对成分名称使用1索引（如上所述）或0索引（从上面的每个索引中减去1）。

乌普特

您的程序必须输出一个表示分数的整数。

测试用例

4 5 5  =>  18 // max score
5 5 5  =>  -27 // min score
13 13 13  =>  0
1 2 3  =>  4
7 5 6  =>  -1
16 2 19  =>  2
19 7 12  =>  -6

*此页面已经过时，在某些浏览器中不起作用，但是您无需为此挑战玩游戏。

果冻，24 字节

“zẈ€$ụ¤’b6’ị@µỊị⁾+׿CFḊV

列出0索引成分。

在线尝试！或查看测试套件

怎么样？

使用略微复杂的形式将值压缩为以6为底的数字，并且乘法项为负数。而不是简单地上移3以得到以6为基数的数字，而是使用增加的补码值-通过允许Ị原子在补数步骤之前挑选出负数条目来节省字节，同时还以base-250保存一个字节压缩。

“zẈ€$ụ¤’b6’ị@µỊị⁾+׿CFḊV - Main link: 0-based ingredient list  e.g. [6,4,5]
“zẈ€$ụ¤’                 - base 250 compressed number: 120851767994004
        b6               - convert to base 6: [1,1,0,5,0,1,0,3,1,1,4,2,1,0,3,0,1,0,0]
          ’              - decrement: [0,0,-1,4,-1,0,-1,2,0,0,3,1,0,-1,2,-1,0,-1,-1]
           ị@            - index into [reversed @rguments]          [0,4,-1]
             µ           - monadic chain separation (call that x)
              Ị          - insignificant(x)? (abs(x)<=1)            [1,0,1]
                ⁾+×      - ['+','×']
               ị         - index into                               ['+','×','+']
                    C    - complement(x) (1-x)                      [1,-3,2]
                   ż     - zip                                      [['+',1],['×',-3],['+',2]]
                     F   - flatten                                  ['+',1,'×',-3,'+',2]
                      Ḋ  - dequeue                                  [1,'×',-3,'+',2]
                       V - evaluate as Jelly code                   -1

JavaScript（ES6），89 84 82 78 73字节

使用0索引将输入作为3个整数的数组。

a=>(o=a=>F()<0?a*n:a+n)(o((F=_=>n='5445054524413452545'[a.shift()]-3)()))

测试用例

let f =

a=>(o=a=>F()<0?a*n:a+n)(o((F=_=>n='5445054524413452545'[a.shift()]-3)()))

console.log(f([3, 4, 4]))     // =>  18
console.log(f([4, 4, 4]))     // =>  -27
console.log(f([12, 12, 12]))  // =>  0
console.log(f([0, 1, 2]))     // =>  4
console.log(f([6, 4, 5]))     // =>  -1
console.log(f([15, 1, 18]))   // =>  2
console.log(f([18, 6, 11]))   // =>  -6

先前版本，78字节

(a)(b)(c)使用0索引，以currying语法获取3个整数。

a=>b=>(o=a=>b=>(n=F(b))<0?a*n:a+n)(o((F=n=>'5445054524413452545'[n]-3)(a))(b))

怎么运行的

这段代码有一点不寻常的事情是，它仅使用“通用”循环语法使用2个参数，a => b =>并最终返回采用第3个参数的函数。

分解

F = n => '5445054524413452545'[n] - 3
o = a => b => (n = F(b)) < 0 ? a * n : a + n
f = a => b => o(o(F(a))(b))

f(a)(b)(c)
  |  |  |
  |  |  +-- 'b' argument of the function returned by the outer call to 'o'
  |  +----- 'b' argument of the function returned by 'f'
  +-------- 'a' argument of 'f'

测试用例

let f =

a=>b=>(o=a=>b=>(n=F(b))<0?a*n:a+n)(o((F=n=>'5445054524413452545'[n]-3)(a))(b))

console.log(f(3)(4)(4))     // =>  18
console.log(f(4)(4)(4))     // =>  -27
console.log(f(12)(12)(12))  // =>  0
console.log(f(0)(1)(2))     // =>  4
console.log(f(6)(4)(5))     // =>  -1
console.log(f(15)(1)(18))   // =>  2
console.log(f(18)(6)(11))   // =>  -6

Befunge，74 73字节

>&:0`!#^_1g68*-^:0`!#v_+
^2112-212/11.012/212 >*
^   @.$<       >">"35*0p

在这里尝试！我的代码只能在此解释器上运行，这很奇怪。

第二行基本上包含表中的所有值。非数字值实际上是负值，因为它们位于ASCII表上的数字之前。那里有一些逻辑来确定该数字是否为负，如果是，则将该数字乘以结果。

第三行的右侧初始化第一个数字。如果不需要这样做，我可以节省很多字节。

PHP，128字节

$i="5445054524413452545";[,$a,$b,$c]=$argv;echo(bc.($i[$c]-3<0?mul:add))((bc.($i[$b]-3<0?mul:add))($i[$a]-3,$i[$b]-3),$i[$c]-3);

PHP，138字节

$d=decbin(506743);$i="5445054524413452545";[,$a,$b,$c]=$argv;echo(bc.($d[$c]?add:mul))((bc.($d[$b]?add:mul))($i[$a]-3,$i[$b]-3),$i[$c]-3);

在线版本

展开式

$d=decbin(506743);
$i="5445054524413452545";
[,$a,$b,$c]=$argv;
echo(bc.($d[$c]?add:mul))((bc.($d[$b]?add:mul))($i[$a]-3,$i[$b]-3),$i[$c]-3);

Python 2中，123个 110 107字节

a,b,c=input()
s=[int(i)-3for i in'05445054524413452545']
n=s[a]
for i in s[b],s[c]:n=[n*i,n+i][n>0]
print n

在线尝试！

-3个字节，感谢@mathjunkie

05AB1E，29个字节

•6SÚ²ÄOÕ6BS3-©¹è|v®yèD0‹i*ë+

在线尝试！

•6SÚ²ÄOÕ6BS3-©               # Push [2, 1, 1, 2, -3, 2, 1, 2, -1, 1, 1, -2, 0, 1, 2, -1, 2, 1, 2] and store.
               ¹è             # Get first score.
                 |v           # Iterate through remaining scores.
                   ®yèD0‹i*ë+ # Push score list, grab relevant score.
                              # If negative, multiply, else add.

实际上，这可以根据您的需要输入任意数量的数量，因此您可以拥有具有4个或更多特征的汽车，或只有2个特征的汽车。

CJam，43 38字节

q~[YXXY-3YXYWXX-2TXYWYXY]f={_W>42+c~}*

可能有一种方法可以进一步压缩列表...

使用基于0的索引。

在线尝试！

说明

该程序利用以下事实：当且仅当其值为负时，该值才是乘法而不是加法。

q~                     e# Get the list from input
  [...]                e# Push the list of values for each ingredient. T=0, W=-1, 
                       e#   X=1, Y=2. 
       f=              e# Get the elements at the given indices 
         {             e# Reduce over this block:
          _W>          e#  Check if the second number is > -1 (returning 0 or 1)
             42+c      e#  Add the result to 42 and cast to a char. 
                       e#    (ASCII 42 is * and 43 is +)
                 ~     e#  Eval the char (* is multiply, + is add)
                  }*   e# (end block)

Lua中，140个 131字节

i={2,1,1,2,-3,2,1,2,-1,1,1,-2,0,1,2,-1,2,1,2}function f(a,b,c)loadstring(("print("..i[a].."+"..i[b].."+"..i[c]..")"):gsub('%+%-','*-'))()end

i={2,1,1,2,-3,2,1,2,-1,1,1,-2,0,1,2,-1,2,1,2}function f(a,b,c)x,y,z=i[a],i[b],i[c]v=y>0 and x+y or x*y;print(z>0 and v+z or v*z)end

JavaScript，85 72字节

a=a=>eval(a.map(x=>(b="5445054524413452545"[x]-3,b<0?"*":"+")+b).join``)

[a,b,c]
通过ETHproductions以-13字节的格式输入

R， 125个 123字节

function(a,b,c){v=c(5,4,4,5,0,5,4,5,2,4,4,1,3,4,5,2,5,4,5)-3
o=rep("+",19)
o[v<0]="*"
get(o[c])(get(o[b])(v[a],v[b]),v[c])}

接受三个整数作为输入的匿名函数。定义值和操作的列表，然后仅评估输入调用的值和o3(o2(v1,v2),v3)。几乎肯定有一个高尔夫球手可以做到这一点！

更新：经过一些修改，我还有一个选择，也是123个字节。同样，这是一个匿名函数，但是将输入作为三个值的单个向量。使用相同的方法，定义值和操作的列表并进行评估。

function(x,f=c(sum,prod)[x[-1]%in%c(5,9,12,16)+1],s=c(5,4,4,5,0,5,4,5,2,4,4,1,3,4,5,2,5,4,5)[x]-3)f[[2]](el(f)(s[-3]),s[3])

Haskell中，186 116 112 108个字节

o x|x<0=(*)|0<1=(+)
v=(map((-51+).fromEnum)"95445054524413452545"!!)
w [x,y,z]=(o z)((o y)x y)z
k=w.map v

主要功能是 k。Code Golf的新手，所以我敢肯定，如果巧妙使用，我可以删除一些字节$运算符和括号，。当我继续寻找改进时，我可能会更新答案。

本质上，程序可以像这样分解：

• v是一个从1开始的索引，并返回该食品ID的值的函数。
• o是获取食物值并返回适当运算符的函数（例如，负值始终*是正值，+）
• w是一个函数，其中包含3个部分函数的列表 v映射到输入整数并从每个整数中获取适当的操作和值，并返回适当的输出。
• k是无点样式的主要功能，它将v映射到输入，并为w组成此列表以返回输出。

更新

特别感谢您指出fromEnum技巧！效果很好。我也错过了规则中规定可接受的解决方案的部分，该函数可以是接受整数列表的函数。这节省了大量工作。

更新2

根据其他建议，通过对操作进行重新排序来节省少量字节，创建一个始终评估为True的else保护，并在W上匹配一个模式，该模式在一个3个元素的列表上匹配。感谢您的建议！

更新3

再次感谢Laikoni指出了我不知道的更多高尔夫球规则代码。同样将v映射到我的输入以创建部分应用函数的列表是一个了不起的主意，并为我节省了另外4个字节！

Haskell，92 87字节

x#y|x<0=(y*)|0<1=(y+)
k[x,y,z]=z#z$y#x$y
k.map([read[q]-3|q<-"95445054524413452545"]!!)

在线尝试！

基于@maple_shaft的答案，我只是对其进行了分解。

感谢@Laikoni 5个字节！

C，171161字节

#include<stdio.h>
r,z[3],*a=z,i;f(x){i?x<0?r*=x:(r+=x):(r=x);}main(){scanf("%d %d %d",a,a+1,a+2);for(;i++<3;f("05445054524413452545"[*a++]-51));printf("%d",r);}

8086机器代码，62字节

00000000  be 3b 01 31 c0 86 c4 ac  e8 0a 00 81 fe 3e 01 72  |.;.1.........>.r|
00000010  f4 b4 4c cd 21 bb 32 01  d0 e8 d7 73 03 c0 e0 04  |..L.!.2....s....|
00000020  c0 f8 04 e3 05 31 c9 c3  86 c4 78 03 00 e0 c3 f6  |.....1....x.....|
00000030  ec c3 21 12 d2 12 f1 1e  01 2f 12 00 00 00        |..!....../....|
0000003e

最后三个字节包含（零索引）输入。嘿，您告诉我，我可以使用最方便的输入格式。在这种情况下，这就是硬编码！
输出是返回到外壳程序的错误代码。

怎么运行的：

            |   org 0x100
            |   use16
be 3b 01    |       mov si, input   ; source = input
31 c0       |       xor ax, ax      ; clear ax
86 c4       |   @@: xchg al, ah     ; swap al/ah (ah = total value)
ac          |       lodsb           ; al = *si++
e8 0a 00    |       call fn
81 fe 3e 01 |       cmp si, input+3 ; end of input?
72 f4       |       jb @b           ; repeat if not
b4 4c       |       mov ah, 0x4c    ; dos function: exit with al=error code
cd 21       |       int 0x21        ; syscall
            |
bb 32 01    |   fn: mov bx, table   ; pointer to lookup table
d0 e8       |       shr al, 1       ; divide input by 2
d7          |       xlatb           ; al = *(bx + al)
73 03       |       jnc @f          ; skip next instruction if input was odd
c0 e0 04    |       shl al, 4       ; shift low nibble to high nibble
c0 f8 04    |   @@: sar al, 4       ; shift high nibble to low nibble with sign-extension
e3 05       |       jcxz @f         ; return if cx is non-zero (only happens for the first input)
31 c9       |       xor cx, cx      ; clear cx
c3          |       ret
86 c4       |       xchg al, ah     ; swap al/ah (al = total value)
78 03       |   @@: js @f           ; multiply if negative, add if positive
00 e0       |       add al, ah      ; al = al+ah
c3          |       ret
f6 ec       |   @@: imul ah         ; ax = al*ah
c3          |       ret
21 12 d2 12 |   table db 0x21, 0x12, 0xd2, 0x12, 0xf1, 0x1e, 0x01, 0x2f, 0x12
f1 1e 01 2f |                       ; each value is stored in a 4-bit nibble
12          |
00 00 00    |   input db 3 dup(0)