Diversi anni fa, Hot Wheels ha realizzato un semplice gioco flash chiamato "Formula Fuelers Racers" *. Per giocare, seleziona tre ingredienti da un frigorifero da mettere nella tua auto, che viene quindi corsa contro l'auto generata casualmente dal computer. Si scopre che le meccaniche di questo gioco sono piuttosto semplici. Prima di tutto, il "tempo" di gara effettivo della tua auto viene generato casualmente e non ha alcuna influenza sul fatto che tu vinca la gara. In secondo luogo, il vincitore della gara è determinato da un punteggio calcolato in base agli ingredienti selezionati (sono ammessi ingredienti doppi e l'ordine è importante). Ogni ingrediente ha un "valore" associato e una "operazione" associata come mostrato nella tabella seguente:

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

Per comodità, questa sfida farà riferimento agli ingredienti in base al loro numero e non al loro nome. Ecco i passaggi per calcolare un punteggio:

1. Innanzitutto, inizializza il punteggio con il valore del primo ingrediente.
2. Quindi, utilizzare l'operazione del secondo ingrediente per combinare il punteggio corrente e il valore del secondo ingrediente per ottenere un punteggio aggiornato.
3. Infine, usa l'operazione del terzo ingrediente per combinare il punteggio corrente e il valore del terzo ingrediente per ottenere il punteggio finale.

I punteggi più alti sono migliori e battono sempre i punteggi più bassi.

Ad esempio, gli ingredienti 1 2 3hanno un punteggio di (2+1)+1 = 4. Gli ingredienti 7 5 6hanno un punteggio di (1*-3)+2 = -1. Pertanto, 1 2 3batte 7 5 6.

Sfida

In questa sfida, dovrai scrivere un programma che prende un elenco ordinato di 3 numeri interi e genera il punteggio corrispondente.

Ingresso

Il tuo programma potrebbe accettare un elenco di tre numeri interi nel formato più conveniente. È consentito utilizzare 1-indicizzazione per i nomi degli ingredienti (come sopra) o 0-indicizzazione (sottrarre 1 da ogni indice sopra).

ouput

Il tuo programma deve generare un singolo numero intero che indica il punteggio.

Casi test

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

* Questa pagina è piuttosto obsoleta e non funziona in alcuni browser, ma non è necessario giocare per questa sfida.

Gelatina , 24 byte

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

Prende un elenco di ingredienti indicizzati 0.

Provalo online! o vedere una suite di test

Come?

Utilizza una forma leggermente contorta di compressione dei valori come numero base-6 e il fatto che le voci moltiplicative sono quelle negative. Invece di spostarsi semplicemente di 3 per ottenere le cifre di base 6, vengono utilizzati i valori completati incrementati - questo consente di risparmiare byte consentendo Ịall'atomo di selezionare le voci negative prima della fase del complemento e di salvare un byte nella base-250 compressione.

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

Accetta l'input come una matrice di 3 numeri interi, usando l'indicizzazione 0.

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

Casi test

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

Versione precedente, 78 byte

Accetta i 3 numeri interi nella sintassi del curry (a)(b)(c), utilizzando l'indicizzazione 0.

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

Come funziona

Una cosa leggermente insolita di questo codice è che prende solo 2 argomenti nella sintassi del curry "comune" a => b =>e alla fine restituisce una funzione che accetta il terzo.

Abbattersi

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'

Casi test

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 byte

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

Provalo qui!È strano che il mio codice funzioni solo su questo interprete.

La seconda riga contiene sostanzialmente tutti i valori della tabella. I valori non numerici sono in realtà valori negativi poiché vengono prima delle cifre nella tabella ASCII. C'è un po 'di logica lì che determina se il numero è negativo o meno, e se lo è, questo numero viene moltiplicato per il risultato.

Il lato destro della terza riga inizializza il primo numero. Se non dovessi farlo, potrei salvare molti byte.

PHP, 128 byte

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

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

Versione online

allargato

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

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

Provalo online!

-3 byte grazie a @mathjunkie

05AB1E , 29 byte

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

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

Questo funziona effettivamente per tutti o pochi input quanti ne desideri, quindi puoi avere auto con 4 o più tratti o auto con solo 2. Questo non era intenzionale, solo come è finito.

CJam , 43 38 byte

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

Potrebbe esserci un modo per comprimere ulteriormente l'elenco ...

Utilizza l'indicizzazione basata su 0.

Provalo online!

Spiegazione

Questo programma sfrutta il fatto che un valore è moltiplicativo anziché additivo se e solo se è 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 byte

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 byte

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

Accetta input in formato [a,b,c]
-13 byte grazie a ETHproductions

R, 125 123 byte

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

Funzione anonima che accetta tre numeri interi come input. Definisce un elenco di valori e operazioni, quindi valuta solo quelli chiamati dall'input, ad es o3(o2(v1,v2),v3). C'è quasi sicuramente un modo più golfista per farlo!

Aggiornamento: dopo alcune rielaborazioni, ho un'alternativa, anche 123 byte . Ancora una volta, una funzione anonima, ma accetta input come un singolo vettore di tre valori. Utilizza lo stesso approccio, definendo un elenco di valori e operazioni e valutandolo.

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 byte

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 funzione principale è k . Nuovo su Code Golf, quindi sono sicuro che ci sono alcuni byte che posso radere con un uso intelligente di$ dell'operatore rispetto alle parentesi. Probabilmente aggiornerò la risposta mentre continuo a trovare miglioramenti.

In sostanza il programma può essere suddiviso in questo modo:

• v è una funzione che accetta un indice basato su 1 e restituisce il valore di quell'ID cibo.
• o è una funzione che accetta il valore del cibo e restituisce l'operatore appropriato (ad es. i valori negativi sono sempre *dove i valori positivi sono sempre+ )
• w è una funzione che accetta un elenco di 3 funzioni parziali di v mappate agli interi di input e recupera le operazioni e i valori appropriati da ciascuna e restituisce l'output corretto.
• k è la funzione principale in stile punto libero che mappa v per l'input e compone questo elenco per w per restituire l'output.

AGGIORNARE

Un ringraziamento speciale per aver sottolineato il trucco fromEnum! Ha funzionato bene. Inoltre ho perso la parte nelle regole che affermava che una soluzione accettabile potrebbe essere una funzione che accetta un elenco di numeri interi. Ciò ha risparmiato un'enorme quantità di lavoro.

AGGIORNAMENTO 2

Come da altri suggerimenti, hai rasato una manciata di byte riordinando le operazioni, creando un altro guard che valuta sempre True, e un pattern matching su W che pattern corrisponde su un Elenco di 3 elementi. Grazie per i suggerimenti!

AGGIORNAMENTO 3

Un altro ringraziamento a Laikoni per aver sottolineato più regole del codice golf di cui non ero a conoscenza. Anche mappare v sul mio input per creare un elenco di funzioni parzialmente applicate è stata un'idea fenomenale e mi ha salvato 4 byte aggiuntivi!

Haskell, 92 87 byte

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

Provalo online!

Sulla base della risposta di @ maple_shaft, l'ho solo un po 'scomposta.

Grazie a @Laikoni per 5 byte!

C, 171 161 byte

#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 codice macchina, 62 byte

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

Gli ultimi tre byte contengono l'input (indicizzato zero). Ehi, mi hai detto che potevo usare il formato di input più conveniente. In questo caso, questo è hardcoding!
L'output è il codice di errore restituito alla shell.

Come funziona:

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