Hace varios años, Hot Wheels creó un juego flash simple llamado "Formula Fuelers Racers" *. Para jugar, selecciona tres ingredientes de una nevera para poner en tu automóvil, que luego se corre contra el automóvil generado aleatoriamente de la computadora. Resulta que la mecánica de este juego es bastante simple. En primer lugar, el "tiempo" de carrera real de su automóvil se genera aleatoriamente y no tiene relación con si gana o no la carrera. En segundo lugar, el ganador de la carrera está determinado por un puntaje que se calcula a partir de los ingredientes seleccionados (se permiten ingredientes duplicados, y el orden es importante). Cada ingrediente tiene un "valor" asociado y una "operación" asociada como se muestra en la siguiente tabla:

#   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   +

Por conveniencia, este desafío se referirá a los ingredientes por su número y no por su nombre. Estos son los pasos para calcular una puntuación:

1. Primero, inicialice la puntuación con el valor del primer ingrediente.
2. Luego, use la operación del segundo ingrediente para combinar el puntaje actual y el valor del segundo ingrediente para obtener un puntaje actualizado.
3. Finalmente, use la operación del tercer ingrediente para combinar el puntaje actual y el valor del tercer ingrediente para obtener el puntaje final.

Los puntajes más altos son mejores y siempre superan los puntajes más bajos.

Por ejemplo, los ingredientes 1 2 3tienen una puntuación de (2+1)+1 = 4. Los ingredientes 7 5 6tienen una puntuación de (1*-3)+2 = -1. Por lo tanto, 1 2 3late 7 5 6.

Reto

En este desafío, deberá escribir un programa que tome una lista ordenada de 3 enteros y genere la puntuación correspondiente.

Entrada

Su programa puede aceptar una lista de tres enteros en el formato más conveniente. Se le permite usar la indexación 1 para los nombres de ingredientes (como arriba) o la indexación 0 (restar 1 de cada índice arriba).

Ouput

Su programa debe generar un solo entero que indique la puntuación.

Casos de prueba

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

* Esta página está bastante desactualizada y no funciona en algunos navegadores, pero no necesitas jugar el juego para este desafío.

Jalea , 24 bytes

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

Toma una lista de ingredientes indexados a 0.

Pruébalo en línea! o ver un conjunto de pruebas

¿Cómo?

Utiliza una forma ligeramente enrevesada de comprimir los valores como un número base 6 y el hecho de que las entradas multiplicativas son las negativas. En lugar de simplemente desplazarse hacia arriba por 3 para obtener los dígitos de base 6, se utilizan los valores complementados incrementados; esto ahorra bytes al permitir que el Ịátomo seleccione las entradas negativas antes del paso del complemento mientras también guarda un byte en la base-250 compresión.

“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 bytes

Toma la entrada como una matriz de 3 enteros, usando la indexación 0.

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

Casos de prueba

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

Versión anterior, 78 bytes

Toma los 3 enteros en la sintaxis de curry (a)(b)(c), usando la indexación 0.

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

Cómo funciona

Una cosa un poco inusual sobre este código es que solo toma 2 argumentos en la sintaxis de curry 'común' a => b =>y finalmente devuelve una función que toma el 3er.

Descompostura

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'

Casos de prueba

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 bytes

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

Pruébalo aquí! Es extraño que mi código solo funcione en este intérprete.

La segunda fila contiene básicamente todos los valores de la tabla. Los valores no numéricos son en realidad valores negativos, ya que aparecen antes de los dígitos en la tabla ASCII. Hay un poco de lógica allí que determina si el número es negativo o no, y si lo es, este número se multiplica por el resultado.

El lado derecho de la tercera fila inicializa el primer número. Si no tuviera que hacer eso, podría ahorrar muchos bytes.

PHP, 128 bytes

$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 bytes

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

Versión en línea

Expandido

$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 bytes

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

Pruébalo en línea!

-3 bytes gracias a @mathjunkie

05AB1E , 29 bytes

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

Pruébalo en línea!

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

Esto realmente funciona para tantas o tan pocas entradas como desee, por lo que puede tener automóviles con 4 o más rasgos o automóviles con solo 2. Esto no fue intencional, sino cómo terminó.

CJam , 43 38 bytes

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

Puede haber una manera de comprimir aún más la lista ...

Utiliza indexación basada en 0.

Pruébalo en línea!

Explicación

Este programa hace uso del hecho de que un valor es multiplicativo en lugar de aditivo si y solo si es negativo.

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 bytes

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 bytes

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

Toma entrada en formato [a,b,c]
-13 bytes gracias a ETHproductions

R 125 123 bytes

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

Función anónima que toma tres enteros como entrada. Define una lista de valores y operaciones, y luego solo evalúa los llamados por la entrada, es decir o3(o2(v1,v2),v3). ¡Definitivamente hay una forma más golfista de hacer esto!

Actualización: después de volver a trabajar, tengo una alternativa, también 123 bytes . Una vez más, una función anónima, pero toma la entrada como un solo vector de tres valores. Utiliza el mismo enfoque, define una lista de valores y operaciones y la evalúa.

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 bytes

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

La función principal es k . Nuevo en Code Golf, así que estoy seguro de que hay algunos bytes que podría eliminar con un uso inteligente de$ operador frente a paréntesis. Probablemente actualizaré la respuesta a medida que continúe encontrando mejoras.

Esencialmente, el programa puede desglosarse así:

• v es una función que toma un índice basado en 1 y devuelve el valor de esa identificación de alimentos.
• o es una función que toma el valor del alimento y devuelve el operador apropiado (por ejemplo, los valores negativos siempre son *donde los valores positivos son siempre+ )
• w es una función que toma una lista de 3 funciones parciales de v asignadas a enteros de entrada y obtiene las operaciones y valores apropiados de cada uno y devuelve la salida adecuada.
• k es la función principal en estilo de punto libre que asigna v a la entrada y compone esta lista para que w devuelva la salida.

ACTUALIZAR

¡Un agradecimiento especial por señalar el truco fromEnum! Eso funcionó muy bien. También me perdí la parte de las reglas que establecía que una solución aceptable podría ser una función que toma una lista de enteros. Eso ahorró una tremenda cantidad de trabajo.

ACTUALIZACIÓN 2

Según otras sugerencias, redujo un puñado de bytes al reordenar las operaciones, creando un protector de else que siempre se evalúa como Verdadero, y un patrón que coincide en W que el patrón coincide en una Lista de 3 elementos. Gracias por las sugerencias!

ACTUALIZACIÓN 3

Otro agradecimiento a Laikoni por señalar más reglas de golf de código que no conocía. ¡Mapear v a mi entrada para crear una lista de funciones parcialmente aplicadas fue una idea fenomenal y me ahorró 4 bytes adicionales!

Haskell, 92 87 bytes

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

Pruébalo en línea!

Basado en la respuesta de @ maple_shaft, lo factoricé un poco.

¡Gracias a @Laikoni por 5 bytes!

C, 171 161 bytes

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

Código de máquina 8086, 62 bytes

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

Los últimos tres bytes contienen la entrada (indexada a cero). Oye, me dijiste que podía usar el formato de entrada más conveniente. En este caso, eso es hardcoding!
La salida es el código de error devuelto al shell.

Cómo funciona:

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