Il y a plusieurs années, Hot Wheels a créé un jeu flash simple appelé "Formula Fuelers Racers" *. Pour jouer au jeu, vous sélectionnez trois ingrédients d'un réfrigérateur à mettre dans votre voiture, qui est ensuite confronté à la voiture générée aléatoirement par l'ordinateur. Il s'avère que la mécanique de ce jeu est assez simple. Tout d'abord, le «temps» de course réel de votre voiture est généré de manière aléatoire et n'a aucune incidence sur le fait de gagner ou non la course. Deuxièmement, le vainqueur de la course est déterminé par un score qui est calculé à partir des ingrédients sélectionnés (les ingrédients en double sont autorisés et l'ordre est important). Chaque ingrédient a une "valeur" et une "opération" associées, comme indiqué dans le tableau suivant:

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

Pour plus de commodité, ce défi fera référence aux ingrédients par leur nombre et non par leur nom. Voici les étapes pour calculer un score:

1. Tout d'abord, initialisez le score avec la valeur du premier ingrédient.
2. Ensuite, utilisez l'opération du deuxième ingrédient pour combiner le score actuel et la valeur du deuxième ingrédient pour obtenir un score mis à jour.
3. Enfin, utilisez l'opération du troisième ingrédient pour combiner le score actuel et la valeur du troisième ingrédient pour obtenir le score final.

Des scores plus élevés sont meilleurs et battent toujours des scores plus bas.

Par exemple, les ingrédients 1 2 3ont un score de (2+1)+1 = 4. Les ingrédients 7 5 6ont un score de (1*-3)+2 = -1. Par conséquent, 1 2 3bat 7 5 6.

Défi

Dans ce défi, vous écrirez un programme qui prend une liste ordonnée de 3 entiers et sort le score correspondant.

Contribution

Votre programme peut accepter une liste de trois entiers dans le format le plus pratique. Vous êtes autorisé à utiliser l'indexation 1 pour les noms d'ingrédients (comme ci-dessus) ou l'indexation 0 (soustrayez 1 de chaque index ci-dessus).

Ouput

Votre programme doit produire un seul entier indiquant le score.

Cas de 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

* Cette page est assez obsolète et ne fonctionne pas dans certains navigateurs, mais vous n'avez pas besoin de jouer au jeu pour ce défi.

Gelée , 24 octets

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

Prend une liste d'ingrédients indexés 0.

Essayez-le en ligne! ou voir une suite de tests

Comment?

Utilise une forme légèrement alambiquée de compression des valeurs en tant que nombre en base 6 et le fait que les entrées multiplicatives sont les entrées négatives. Au lieu de simplement décaler de 3 pour obtenir les chiffres de base 6, les valeurs complémentaires incrémentées sont utilisées - cela permet d'économiser des octets en permettant à l' Ịatome de sélectionner les entrées négatives avant l'étape du complément tout en enregistrant un octet dans la base-250 compression.

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

Prend l'entrée comme un tableau de 3 entiers, en utilisant l'indexation 0.

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

Cas de 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

Version précédente, 78 octets

Prend les 3 entiers dans la syntaxe de currying (a)(b)(c), en utilisant l'indexation 0.

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

Comment ça marche

Une chose un peu inhabituelle à propos de ce code est qu'il ne prend que 2 arguments dans la syntaxe de curry `` commune '' a => b =>et retourne finalement une fonction qui prend le 3e.

Panne

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'

Cas de 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 octets

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

Essayez-le ici! C'est bizarre que mon code ne fonctionne que sur cet interprète.

La deuxième ligne contient essentiellement toutes les valeurs du tableau. Les valeurs non numériques sont en fait des valeurs négatives car elles précèdent les chiffres de la table ASCII. Il y a un peu de logique qui détermine si le nombre est négatif ou non, et s'il l'est, ce nombre est multiplié par le résultat.

Le côté droit de la troisième ligne initialise le premier nombre. Si je n'avais pas à le faire, je pourrais économiser beaucoup d'octets.

PHP, 128 octets

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

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

Version en ligne

Étendu

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

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

Essayez-le en ligne!

-3 octets grâce à @mathjunkie

05AB1E , 29 octets

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

Essayez-le en ligne!

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

Cela fonctionne en fait pour autant ou aussi peu d'entrées que vous le souhaitez, vous pouvez donc avoir des voitures avec 4 traits ou plus ou des voitures avec seulement 2. Ce n'était pas intentionnel, juste comment cela s'est terminé.

CJam , 43 38 octets

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

Il pourrait y avoir un moyen de compresser davantage la liste ...

Utilise l'indexation basée sur 0.

Essayez-le en ligne!

Explication

Ce programme utilise le fait qu'une valeur est multiplicative plutôt qu'additive si et seulement si elle est négative.

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 octets

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 octets

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

Prend l'entrée au format [a,b,c]
-13 octets grâce à ETHproductions

R, 125 123 octets

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

Fonction anonyme qui prend trois entiers en entrée. Définit une liste de valeurs et d'opérations, puis évalue simplement celles appelées par l'entrée, c'est-à-dire o3(o2(v1,v2),v3). Il y a presque certainement une façon golfique de le faire!

Mise à jour: après quelques retouches, j'ai une alternative, également 123 octets . Encore une fois, une fonction anonyme, mais prend l'entrée comme un seul vecteur de trois valeurs. Utilise la même approche, définissant une liste de valeurs et d'opérations et l'évaluant.

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 octets

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 fonction principale est k. Nouveau sur Code Golf, je suis sûr qu'il y a quelques octets que je pourrais raser avec une utilisation intelligente de l' $opérateur par rapport aux parenthèses. Je mettrai probablement à jour la réponse à mesure que je continuerai à trouver des améliorations.

Essentiellement, le programme peut être divisé comme suit:

• v est une fonction qui prend un index basé sur 1 et renvoie la valeur de cet identifiant de nourriture.
• o est une fonction qui prend la valeur de l'aliment et renvoie l'opérateur approprié (par exemple, les valeurs négatives sont toujours *là où les valeurs positives sont toujours +)
• w est une fonction qui prend une liste de 3 fonctions partielles de vmappé pour entrer des entiers et extrait les opérations et les valeurs appropriées de chacune et retourne la sortie appropriée.
• k est la fonction principale dans le style sans points qui mappe v à l'entrée et compose cette liste pour que w retourne la sortie.

MISE À JOUR

Un merci spécial pour avoir souligné l'astuce fromEnum! Cela a bien fonctionné. J'ai également manqué la partie des règles qui stipulait qu'une solution acceptable pourrait être une fonction qui prend une liste d'entiers. Cela a permis d'économiser énormément de travail.

MISE À JOUR 2

Selon d'autres suggestions, rasé une poignée d'octets en réorganisant les opérations, créant un garde else qui a toujours la valeur True et un modèle correspondant à W qui correspond au modèle sur une liste de 3 éléments. Merci pour les suggestions!

MISE À JOUR 3

Un autre merci à Laikoni pour avoir souligné plus de règles de golf de code que je ne connaissais pas. Le mappage de v à mon entrée pour créer une liste de fonctions partiellement appliquées était une idée phénoménale et m'a sauvé 4 octets supplémentaires!

Haskell, 92 87 octets

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

Essayez-le en ligne!

Sur la base de la réponse de @ maple_shaft, je viens de factoriser un peu.

Merci à @Laikoni pour 5 octets!

C, 171 161 octets

#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 code machine, 62 octets

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

Les trois derniers octets contiennent l'entrée (indexée zéro). Hé, tu m'as dit que je pouvais utiliser le format d'entrée le plus pratique. Dans ce cas, c'est du hardcoding!
La sortie est le code d'erreur renvoyé au shell.

Comment ça marche:

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