Kilka lat temu Hot Wheels stworzyło prostą grę flash o nazwie „Formula Fuelers Racers” *. Aby zagrać w tę grę, wybierasz trzy składniki z lodówki i wkładasz je do samochodu, który następnie ściga się z losowo generowanym samochodem komputera. Okazuje się, że mechanika tej gry jest dość prosta. Po pierwsze, faktyczny „czas” wyścigu twojego samochodu jest generowany losowo i nie ma wpływu na to, czy wygrasz wyścig. Po drugie, zwycięzca wyścigu jest określany na podstawie wyniku obliczonego na podstawie wybranych składników (dozwolone są duplikaty składników i kolejność ma znaczenie). Każdy składnik ma powiązaną „wartość” i powiązaną „operację”, jak pokazano w poniższej tabeli:

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

Dla wygody to wyzwanie będzie dotyczyło składników według ich liczby, a nie nazwy. Oto kroki, aby obliczyć wynik:

1. Najpierw zainicjuj wynik wartością pierwszego składnika.
2. Następnie użyj operacji drugiego składnika, aby połączyć aktualny wynik z wartością drugiego składnika, aby uzyskać zaktualizowany wynik.
3. Na koniec użyj operacji trzeciego składnika, aby połączyć aktualny wynik z wartością trzeciego składnika, aby uzyskać wynik końcowy.

Wyższe wyniki są lepsze i zawsze pokonują niższe wyniki.

Na przykład składniki 1 2 3mają wynik (2+1)+1 = 4. Składniki 7 5 6mają wynik (1*-3)+2 = -1. Dlatego 1 2 3bije 7 5 6.

Wyzwanie

W tym wyzwaniu napiszesz program, który pobierze uporządkowaną listę 3 liczb całkowitych i wyświetli odpowiedni wynik.

Wkład

Twój program może zaakceptować listę trzech liczb całkowitych w najwygodniejszym formacie. Możesz używać indeksowania 1 dla nazw składników (jak wyżej) lub indeksowania 0 (odejmij 1 od każdego indeksu powyżej).

Ouput

Twój program musi wypisać jedną liczbę całkowitą wskazującą wynik.

Przypadki testowe

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

* Ta strona jest dość przestarzała i nie działa w niektórych przeglądarkach, ale nie musisz grać w tę grę.

Galaretka , 24 bajty

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

Pobiera listę składników o indeksie 0.

Wypróbuj online! lub zobacz zestaw testowy

W jaki sposób?

Używa nieco zawiłej formy kompresji wartości jako liczby podstawowej 6 oraz faktu, że wpisy multiplikatywne są wartościami ujemnymi. Zamiast po prostu przesuwać w górę o 3, aby uzyskać cyfrę podstawową 6, stosuje się uzupełnione wartości przyrostowe - pozwala to zaoszczędzić bajty, umożliwiając Ịatomowi wykrycie ujemnych wpisów przed krokiem uzupełniania, jednocześnie oszczędzając bajt w bazie-250 kompresja.

“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 bajtów

Pobiera dane wejściowe jako tablicę 3 liczb całkowitych, wykorzystując indeksowanie 0.

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

Przypadki testowe

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

Poprzednia wersja, 78 bajtów

Pobiera 3 liczby całkowite w składni curry (a)(b)(c), stosując indeksowanie 0.

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

Jak to działa

Nieco niezwykłą rzeczą w tym kodzie jest to, że wymaga tylko 2 argumentów w „wspólnej” składni curry a => b =>i ostatecznie zwraca funkcję, która przyjmuje trzecią.

Awaria

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'

Przypadki testowe

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 bajtów

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

Wypróbuj tutaj! To dziwne, że mój kod działa tylko na tym jednym tłumaczu.

Drugi wiersz zawiera w zasadzie wszystkie wartości z tabeli. Wartości nienumeryczne są w rzeczywistości wartościami ujemnymi, ponieważ występują przed cyframi w tabeli ASCII. Jest trochę logiki, która określa, czy liczba jest ujemna, czy nie, a jeśli tak, to liczba ta jest mnożona przez wynik.

Prawa strona trzeciego rzędu inicjuje pierwszą liczbę. Gdybym nie musiał tego robić, mógłbym zaoszczędzić wiele bajtów.

PHP, 128 bajtów

$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 bajtów

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

Wersja online

Rozszerzony

$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 bajtów

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

Wypróbuj online!

-3 bajty dzięki @mathjunkie

05AB1E , 29 bajtów

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

Wypróbuj 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.

To faktycznie działa na tyle lub tak mało danych, ile chcesz, więc możesz mieć samochody z 4 lub więcej cechami lub samochody z zaledwie 2. To nie było zamierzone, po prostu jak to się skończyło.

CJam , 43 38 bajtów

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

Może istnieć sposób na dalsze kompresowanie listy ...

Wykorzystuje indeksowanie 0.

Wypróbuj online!

Wyjaśnienie

Ten program korzysta z faktu, że wartość jest multiplikatywna zamiast addytywna wtedy i tylko wtedy, gdy jest ujemna.

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 bajtów

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 bajtów

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

Pobiera dane wejściowe w formacie [a,b,c]
-13 bajtów dzięki produktom ETH

R, 125 123 bajtów

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

Anonimowa funkcja, która przyjmuje trzy liczby całkowite jako dane wejściowe. Definiuje listę wartości i operacji, a następnie po prostu ocenia te wywołane przez dane wejściowe, tj o3(o2(v1,v2),v3). Jest prawie na pewno bardziej golfowy sposób!

Aktualizacja: po ponownej obróbce mam alternatywę, również 123 bajty . Ponownie anonimowa funkcja, ale przyjmuje dane wejściowe jako pojedynczy wektor trzech wartości. Stosuje to samo podejście, definiując listę wartości i operacji i oceniając ją.

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 bajtów

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

Główną funkcją jest k. Nowość w Code Golf, więc jestem pewien, że jest kilka bajtów, które mógłbym się ogolić dzięki sprytnemu użyciu $operatora i nawiasów. Prawdopodobnie zaktualizuję odpowiedź, gdy będę nadal znajdować ulepszenia.

Zasadniczo program można podzielić w następujący sposób:

• v jest funkcją, która pobiera indeks oparty na 1 i zwraca wartość tego identyfikatora żywności.
• o jest funkcją, która pobiera wartość żywności i zwraca odpowiedni operator (np. wartości ujemne są zawsze *tam, gdzie zawsze są wartości dodatnie +)
• w jest funkcją, która pobiera listę 3 częściowych funkcji vodwzorowanych na wejściowe liczby całkowite i pobiera z nich odpowiednie operacje i wartości oraz zwraca właściwe dane wyjściowe.
• k jest główną funkcją w stylu bez punktów, która odwzorowuje v na dane wejściowe i tworzy tę listę dla w, aby zwrócić dane wyjściowe.

AKTUALIZACJA

Specjalne podziękowania za wskazanie sztuczki fromEnum! To działało ładnie. Brakowało mi również części zasad, która mówi, że akceptowalnym rozwiązaniem może być funkcja, która pobiera listę liczb całkowitych. To pozwoliło zaoszczędzić ogromną ilość pracy.

AKTUALIZACJA 2

Zgodnie z innymi sugestiami, ogoliłem garść bajtów, zmieniając kolejność operacji, tworząc inny element zabezpieczający, który zawsze ocenia wartość Prawda, i dopasowujący wzorzec dla W, który wzorzec pasuje do Listy 3 elementów. Dzięki za sugestie!

AKTUALIZACJA 3

Kolejne podziękowania dla Laikoni za wskazanie większej liczby zasad gry w golfa, o których nie wiedziałem. Również mapowanie v do moich danych wejściowych w celu utworzenia listy częściowo zastosowanych funkcji było fenomenalnym pomysłem i pozwoliło mi zaoszczędzić 4 dodatkowe bajty!

Haskell, 92 87 bajtów

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

Wypróbuj online!

Opierając się na odpowiedzi @ maple_shaft, po prostu trochę to rozłożyłem.

Dzięki @Laikoni za 5 bajtów!

C 171 161 bajtów

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

Kod maszynowy 8086, 62 bajty

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

Ostatnie trzy bajty zawierają dane wejściowe (indeksowane od zera). Hej, powiedziałeś mi, że mogę użyć najwygodniejszego formatu wejściowego. W tym przypadku to jest na stałe!
Dane wyjściowe to kod błędu zwracany do powłoki.

Jak to działa:

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