Vor einigen Jahren erstellte Hot Wheels ein einfaches Flash-Spiel namens "Formula Fuelers Racers" *. Um das Spiel zu spielen, wählst du drei Zutaten aus einem Kühlschrank aus, die in dein Auto gelegt werden und dann gegen das zufällig erzeugte Auto des Computers rasen. Es stellt sich heraus, dass die Mechanik dieses Spiels ziemlich einfach ist. Zunächst einmal wird die tatsächliche "Rennzeit" Ihres Autos zufällig generiert und hat keinen Einfluss darauf, ob Sie das Rennen gewinnen oder nicht. Zweitens wird der Sieger des Rennens anhand einer Punktzahl ermittelt, die aus den ausgewählten Zutaten berechnet wird (doppelte Zutaten sind zulässig und die Reihenfolge ist wichtig). Jeder Zutat ist ein "Wert" und eine "Operation" zugeordnet, wie in der folgenden Tabelle gezeigt:

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

Der Einfachheit halber bezieht sich diese Herausforderung auf Zutaten anhand ihrer Nummer und nicht ihres Namens. Hier sind die Schritte zum Berechnen einer Punktzahl:

1. Initialisieren Sie zuerst die Punktzahl mit dem Wert der ersten Zutat.
2. Verwenden Sie dann die Operation der zweiten Zutat, um die aktuelle Punktzahl und den Wert der zweiten Zutat zu kombinieren und eine aktualisierte Punktzahl zu erhalten.
3. Verwenden Sie schließlich die Operation der dritten Zutat, um die aktuelle Punktzahl und den Wert der dritten Zutat zu kombinieren, um die endgültige Punktzahl zu erhalten.

Höhere Werte sind besser und schlagen immer niedrigere Werte.

Zum Beispiel haben die Zutaten 1 2 3eine Punktzahl von (2+1)+1 = 4. Die Zutaten 7 5 6haben eine Punktzahl von (1*-3)+2 = -1. Daher 1 2 3schlägt 7 5 6.

Herausforderung

In dieser Herausforderung schreiben Sie ein Programm, das eine geordnete Liste mit 3 ganzen Zahlen erstellt und die entsprechende Punktzahl ausgibt.

Eingang

Ihr Programm akzeptiert möglicherweise eine Liste mit drei Ganzzahlen im bequemsten Format. Sie können entweder die 1-Indizierung für die Inhaltsstoffnamen (wie oben) oder die 0-Indizierung (1 von jedem Index oben abziehen) verwenden.

Ausgang

Ihr Programm muss eine einzelne Ganzzahl ausgeben, die die Punktzahl angibt.

Testfälle

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

* Diese Seite ist ziemlich veraltet und funktioniert in einigen Browsern nicht, aber Sie müssen das Spiel für diese Herausforderung nicht spielen.

Gelee , 24 Bytes

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

Nimmt eine Liste mit Zutaten mit Index 0 auf.

Probieren Sie es online! oder sehen Sie sich eine Testsuite an

Wie?

Verwendet eine leicht verschlungene Form der Komprimierung der Werte als Basis-6-Zahl und die Tatsache, dass die multiplikativen Einträge die negativen sind. Anstatt einfach um 3 nach oben zu schieben, um die 6-stelligen Basiswerte zu erhalten, werden die inkrementierten komplementären Werte verwendet - dies spart Bytes, indem das ỊAtom die negativen Einträge vor dem Komplementierungsschritt heraussucht und gleichzeitig ein Byte in der 250er-Basis speichert Kompression.

“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

Nimmt die Eingabe als Array mit 3 Ganzzahlen unter Verwendung der 0-Indizierung.

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

Testfälle

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

Vorherige Version, 78 Bytes

Übernimmt die 3 Ganzzahlen in der aktuellen Syntax (a)(b)(c)und verwendet die 0-Indizierung.

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

Wie es funktioniert

Eine etwas ungewöhnliche Sache an diesem Code ist, dass er nur zwei Argumente in der gängigen Currying-Syntax akzeptiert a => b =>und schließlich eine Funktion zurückgibt, die die dritte übernimmt.

Nervenzusammenbruch

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'

Testfälle

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

Probieren Sie es hier aus! Es ist seltsam, dass mein Code nur mit diesem einen Interpreter funktioniert.

Die zweite Zeile enthält grundsätzlich alle Werte aus der Tabelle. Die nicht numerischen Werte sind tatsächlich negative Werte, da sie vor den Ziffern in der ASCII-Tabelle stehen. Es gibt ein bisschen Logik, die bestimmt, ob die Zahl negativ ist oder nicht, und wenn ja, wird diese Zahl mit dem Ergebnis multipliziert.

Die rechte Seite der dritten Zeile initialisiert die erste Nummer. Wenn ich das nicht tun müsste, könnte ich eine Menge Bytes sparen.

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

Online Version

Erweitert

$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

Probieren Sie es online!

-3 Bytes dank @mathjunkie

05AB1E , 29 Bytes

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

Probieren Sie es 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.

Dies funktioniert tatsächlich für so viele oder so wenige Eingaben, wie Sie möchten, sodass Sie Autos mit 4 oder mehr Merkmalen oder Autos mit nur 2 haben können. Dies war nicht beabsichtigt, nur wie es endete.

CJam , 43 38 Bytes

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

Es könnte eine Möglichkeit geben, die Liste weiter zu komprimieren ...

Verwendet eine 0-basierte Indizierung.

Probieren Sie es online!

Erläuterung

Dieses Programm nutzt die Tatsache, dass ein Wert genau dann multiplikativ und nicht additiv ist, wenn er negativ ist.

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

[a,b,c]
Übernimmt dank ETHproductions Eingaben im Format -13 Bytes

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

Anonyme Funktion, die drei Ganzzahlen als Eingabe verwendet. Definiert eine Liste von Werten und Operationen und wertet dann nur die Werte aus, die von der Eingabe aufgerufen werden, d o3(o2(v1,v2),v3). H. Es gibt fast definitiv eine golferischere Möglichkeit, dies zu tun!

Update: Nach einiger Überarbeitung habe ich eine Alternative, ebenfalls 123 Bytes . Wieder eine anonyme Funktion, die Eingaben jedoch als einzelner Vektor mit drei Werten akzeptiert. Verwendet denselben Ansatz, definiert eine Liste von Werten und Operationen und bewertet sie.

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

Hauptfunktion ist k. Neu bei Code Golf, daher bin ich mir sicher, dass es ein paar Bytes gibt, die ich mit geschickter Verwendung von abschneiden könnte$ Operatoren im Vergleich zu Klammern . Ich werde die Antwort wahrscheinlich aktualisieren, wenn ich weitere Verbesserungen finde.

Im Wesentlichen kann das Programm so aufgeteilt werden:

• v ist eine Funktion, die einen auf 1 basierenden Index verwendet und den Wert dieser Lebensmittel-ID zurückgibt.
• o ist eine Funktion, die den Lebensmittelwert nimmt und den entsprechenden Operator zurückgibt (zB sind negative Werte immer dort, *wo positive Werte immer sind+ ).
• w ist eine Funktion, die eine Liste von 3 Teilfunktionen von v auf Eingabe-Ganzzahlen abgebildeten die entsprechenden Operationen und Werte von jeder abruft und die richtige Ausgabe zurückgibt.
• k ist die Hauptfunktion im punktfreien Stil, die v der Eingabe zuordnet und diese Liste erstellt, damit w die Ausgabe zurückgibt.

AKTUALISIEREN

Besonderer Dank für den Hinweis auf den fromEnum-Trick! Das hat gut geklappt. Außerdem habe ich den Teil in den Regeln übersehen, der besagt, dass eine akzeptable Lösung eine Funktion sein könnte, die eine Liste von ganzen Zahlen enthält. Das hat enorm viel Arbeit gespart.

UPDATE 2

Nach anderen Vorschlägen sollten Sie eine Handvoll Bytes rasieren, indem Sie Vorgänge neu anordnen. Dabei wird ein else-Schutz erstellt, der immer True ergibt, und ein Muster, das mit W übereinstimmt, das mit einer Liste von 3 Elementen übereinstimmt. Danke für die Vorschläge!

UPDATE 3

Ein weiterer Dank geht an Laikoni für den Hinweis auf weitere Codegolfregeln, die mir nicht bekannt waren. Auch die Zuordnung von v zu meiner Eingabe zum Erstellen einer Liste von teilweise angewendeten Funktionen war eine phänomenale Idee und sparte mir 4 zusätzliche Bytes!

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

Probieren Sie es online!

Basierend auf der Antwort von @ maple_shaft habe ich es nur ein bisschen faktorisiert.

Danke an @Laikoni für 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);}

8086 Maschinencode, 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

Die letzten drei Bytes enthalten den (nullindizierten) Eingang. Hey, du hast mir gesagt, ich könnte das bequemste Eingabeformat verwenden. In diesem Fall ist das Hardcoding!
Ausgabe ist der an die Shell zurückgegebene Fehlercode.

Wie es funktioniert:

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