Há vários anos, a Hot Wheels fez um simples jogo em flash chamado "Formula Fuelers Racers" *. Para jogar o jogo, você seleciona três ingredientes de uma geladeira para colocar no seu carro, que depois é batido contra o carro gerado aleatoriamente no computador. Acontece que a mecânica deste jogo é bastante simples. Primeiro, o "tempo" real da corrida do seu carro é gerado aleatoriamente e não tem influência sobre se você vence ou não a corrida. Em segundo lugar, o vencedor da corrida é determinado por uma pontuação calculada a partir dos ingredientes selecionados (ingredientes duplicados são permitidos e a ordem é importante). Cada ingrediente possui um "valor" associado e uma "operação" associada, conforme mostrado na tabela a seguir:

#   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 conveniência, esse desafio se refere aos ingredientes pelo número e não pelo nome. Aqui estão as etapas para calcular uma pontuação:

1. Primeiro, inicialize a pontuação com o valor do primeiro ingrediente.
2. Em seguida, use a operação do segundo ingrediente para combinar a pontuação atual e o valor do segundo ingrediente para obter uma pontuação atualizada.
3. Por fim, use a operação do terceiro ingrediente para combinar a pontuação atual e o valor do terceiro ingrediente para obter a pontuação final.

Pontuações mais altas são melhores e sempre superam pontuações mais baixas.

Por exemplo, os ingredientes 1 2 3têm uma pontuação de (2+1)+1 = 4. Os ingredientes 7 5 6têm uma pontuação de (1*-3)+2 = -1. Portanto, 1 2 3bate 7 5 6.

Desafio

Neste desafio, você deve escrever um programa que pega uma lista ordenada de 3 números inteiros e gera a pontuação correspondente.

Entrada

Seu programa pode aceitar uma lista de três números inteiros no formato mais conveniente. Você tem permissão para usar a indexação 1 para os nomes dos ingredientes (como acima) ou a indexação 0 (subtrair 1 de todos os índices acima).

Ouput

Seu programa deve gerar um único número inteiro indicando a pontuação.

Casos de teste

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á desatualizada e não funciona em alguns navegadores, mas você não precisa jogar o jogo para este desafio.

Gelatina , 24 bytes

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

Leva uma lista de ingredientes indexados em 0.

Experimente online! ou veja uma suíte de testes

Quão?

Usa uma forma levemente complicada de compactar os valores como um número de base 6 e o ​​fato de as entradas multiplicativas serem negativas. Em vez de simplesmente aumentar 3 para obter os dígitos da base 6, são usados ​​os valores complementados incrementados - isso economiza bytes, permitindo que o Ịátomo selecione as entradas negativas antes da etapa do complemento, além de salvar um byte na base 250 compressão.

“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

Recebe a entrada como uma matriz de 3 números inteiros, usando a indexação 0.

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

Casos de teste

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

Versão anterior, 78 bytes

Pega os 3 números inteiros na sintaxe de currying (a)(b)(c), usando a indexação 0.

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

Como funciona

Uma coisa um pouco incomum sobre esse código é que ele usa apenas 2 argumentos na sintaxe de curry 'comum' a => b =>e, eventualmente, retorna uma função que aceita o terceiro.

Demolir

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 teste

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

Experimente aqui! É estranho que meu código funcione apenas nesse intérprete.

A segunda linha contém basicamente todos os valores da tabela. Os valores não numéricos são, na verdade, valores negativos, pois vêm antes dos dígitos na tabela ASCII. Existe um pouco de lógica que determina se o número é negativo ou não e, se for, esse número é multiplicado pelo resultado.

O lado direito da terceira linha inicializa o primeiro número. Se eu não tivesse que fazer isso, poderia economizar muitos 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);

Versão Online

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

Experimente online!

-3 bytes graças a @mathjunkie

05AB1E , 29 bytes

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

Experimente online!

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

Na verdade, isso funciona para tantas ou poucas entradas quanto você quiser, para que você possa ter carros com 4 ou mais características ou carros com apenas 2. Isso não foi intencional, exatamente como acabou.

CJam , 43 38 bytes

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

Pode haver uma maneira de compactar ainda mais a lista ...

Usa indexação baseada em 0.

Experimente online!

Explicação

Este programa utiliza o fato de que um valor é multiplicativo em vez de aditivo se e somente se for 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``)

Recebe entrada em formato [a,b,c]
-13 bytes graças 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])}

Função anônima que recebe três números inteiros como entrada. Define uma lista de valores e operações e avalia apenas os chamados pela entrada, ou seja,o3(o2(v1,v2),v3) . Definitivamente, existe uma maneira mais prática de fazer isso!

Atualização: depois de algumas retrabalhos, tenho uma alternativa, também 123 bytes . Novamente, uma função anônima, mas recebe a entrada como um único vetor de três valores. Usa a mesma abordagem, definindo uma lista de valores e operações e avaliando-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

Principal função é k. Novo no Code Golf, por isso tenho certeza de que há alguns bytes que eu poderia raspar com o uso inteligente de $operador versus parênteses. Provavelmente atualizarei a resposta à medida que continuo encontrando melhorias.

Essencialmente, o programa pode ser dividido assim:

• v é uma função que recebe um índice baseado em 1 e retorna o valor desse ID de alimento.
• o é uma função que pega o valor do alimento e retorna o operador apropriado (por exemplo, valores negativos sempre *são valores positivos sempre +)
• w é uma função que pega uma Lista de 3 funções parciais de vmapeadas para inserir números inteiros e busca as operações e valores apropriados de cada uma e retorna a saída apropriada.
• k é a função principal no estilo de ponto livre que mapeia v para entrada e compõe esta lista para w retornar a saída.

ATUALIZAR

Agradecimentos especiais por apontar o truque fromEnum! Isso funcionou muito bem. Também perdi a parte das regras que declaravam que uma solução aceitável poderia ser uma função que leva uma lista de números inteiros. Isso economizou uma tremenda quantidade de trabalho.

ATUALIZAÇÃO 2

Conforme outras sugestões, raspou um punhado de bytes reordenando as operações, criando uma outra proteção que sempre é avaliada como True e um padrão correspondente em W esse padrão corresponde a uma Lista de 3 elementos. Obrigado pelas sugestões!

ATUALIZAÇÃO 3

Outro agradecimento a Laikoni por apontar mais regras de código de golfe que eu não conhecia. Também mapear v para minha entrada para criar uma lista de funções parcialmente aplicadas foi uma ideia fenomenal e me salvou 4 bytes adicionais!

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"]!!)

Experimente online!

Com base na resposta do @ maple_shaft, eu apenas o fatorei um pouco.

Obrigado 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

Os últimos três bytes contêm a entrada (indexada a zero). Ei, você me disse que eu poderia usar o formato de entrada mais conveniente. Nesse caso, isso é codificado!
Saída é o código de erro retornado ao shell.

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