Кілька років тому Hot Wheels зробили просту флеш-гру під назвою "Racers Formula Fuelers" *. Щоб грати в гру, ви вибираєте три інгредієнти з холодильника, які потрібно помістити у свій автомобіль, який потім змагається з випадково генерованим автомобілем комп'ютера. Виявляється, механіка цієї гри досить проста. По-перше, фактичний час "гонки" вашого автомобіля генерується випадковим чином і не має ніякого відношення до того, ви виграєте в гонці чи ні. По-друге, переможець гонки визначається балом, який розраховується з обраних інгредієнтів (дозволені повторювані інгредієнти, а порядок має значення). Кожен інгредієнт має пов'язане "значення" та пов'язану з ним "операцію", як показано в наступній таблиці:

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

Для зручності цей виклик стосуватиметься інгредієнтів за їх кількістю, а не за назвою. Ось такі кроки для обчислення балу:

1. Спочатку ініціалізуйте оцінку зі значенням першого інгредієнта.
2. Потім скористайтеся операцією другого інгредієнта, щоб поєднати поточну оцінку та значення другого інгредієнта, щоб отримати оновлений бал.
3. Нарешті, використовуйте операцію третього інгредієнта, щоб поєднати поточну оцінку та значення третього інгредієнта, щоб отримати остаточну оцінку.

Вищі бали кращі і завжди перемагають нижчі бали.

Наприклад, інгредієнти 1 2 3мають оцінку (2+1)+1 = 4. Інгредієнти 7 5 6мають оцінку (1*-3)+2 = -1. Тому 1 2 3б’ється 7 5 6.

Виклик

У цьому виклику ви повинні написати програму, яка займає впорядкований список із 3 цілих чисел та видає відповідний бал.

Вхідні дані

Ваша програма може прийняти список із трьох цілих чисел у найбільш зручному форматі. Вам дозволяється використовувати або 1-індексацію для назв інгредієнтів (як вище), або 0-індексацію (відняти 1 від кожного індексу вище).

Вихід

Ваша програма повинна вивести одне ціле число із зазначенням балу.

Випробування

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

* Ця сторінка досить застаріла і не працює в деяких браузерах, але вам не потрібно грати в цю проблему.

Желе , 24 байти

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

Приймає список 0-індексованих інгредієнтів.

Спробуйте в Інтернеті! або переглянути тестовий набір

Як?

Використовується трохи згорнута форма стиснення значень як базове число-6 і той факт, що мультиплікативні записи є негативними. Замість простого зміщення на 3, щоб отримати базові 6 цифр, використовуються доповнені значення, збільшені - це економить байти, дозволяючи Ịатому вибирати негативні записи до кроку доповнення, а також зберігаючи байт у базі-250 стиснення.

“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 байт

Приймає введення як масив з 3 цілих чисел, використовуючи 0-індексацію.

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

Тестові справи

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

Попередня версія, 78 байт

Бере 3 цілих числа в синтаксисі каррі (a)(b)(c), використовуючи 0-індексацію.

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

Як це працює

Дещо незвична річ у цьому коді полягає в тому, що він бере лише 2 аргументи у «загальному» синтаксисі currying a => b =>і, врешті-решт, повертає функцію, яка займає 3-й.

Зламатися

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'

Тестові справи

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 байт

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

Спробуйте тут! Дивно, що мій код працює лише на цьому перекладачі.

Другий рядок в основному містить усі значення з таблиці. Нечислові значення - це фактично від’ємні значення, оскільки вони надходять до цифр таблиці ASCII. Там є трохи логіки, яка визначає, чи є число від’ємним чи ні, і якщо воно є, це число множиться на результат.

Права частина третього ряду ініціалізує перше число. Якби мені не довелося цього робити, я міг би зберегти багато байтів.

PHP, 128 байт

$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 байт

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

Інтернет-версія

Розширено

$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 байт

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

Спробуйте в Інтернеті!

-3 байти завдяки @mathjunkie

05AB1E , 29 байт

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

Спробуйте в Інтернеті!

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

Це насправді працює на стільки, скільки бажаєш входів, тож ти можеш мати автомобілі з чотирма або більше ознаками або автомобілі лише з 2. Це не було навмисно, як саме воно закінчилося.

CJam , 43 38 байт

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

Можливо, далі буде скласти список ...

Використовує індексацію на основі 0.

Спробуйте в Інтернеті!

Пояснення

Ця програма використовує той факт, що значення є мультиплікативним замість добавки, якщо і лише тоді, коли воно є від’ємним.

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)

Луа, 140 131 байт

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 байти

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

[a,b,c]
Здійснює введення у форматі -13 байт завдяки ETHproductions

R, 125 123 байт

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

Анонімна функція, яка приймає в якості трьох цілих чисел. Визначає перелік значень і операцій, а потім просто оцінює ті, що викликаються входом, тобто o3(o2(v1,v2),v3). Існує майже напевно гольфіст спосіб це зробити!

Оновлення: після деякої повторної роботи у мене є альтернатива, також 123 байти . Знову ж таки, анонімна функція, але приймає вхід як єдиний вектор із трьох значень. Використовується той же підхід, визначаючи перелік значень та операцій та оцінюючи його.

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 байт

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

Основна функція k. Новачок у Code Golf, тому я впевнений, що я маю кілька байтів, які я можу поголити за допомогою розумного використання $оператора та дужок. Я, мабуть, оновлю відповідь, оскільки продовжуватиму вдосконалюватись.

По суті, програму можна розбити так:

• v - функція, яка приймає індекс на основі 1 і повертає значення цього ідентифікатора їжі.
• o - це функція, яка приймає харчову цінність і повертає відповідного оператора (наприклад, негативні значення завжди *там, де позитивні значення завжди є +)
• w - це функція, яка приймає Список 3-х часткових функцій, vвідображених на введення цілих чисел, і отримує відповідні операції та значення з кожного та повертає належний вихід.
• k - головна функція в точковому вільному стилі, яка відображає v для введення і складає цей список для w, щоб повернути вихід.

ОНОВЛЕННЯ

Особлива вдячність за вказівку на фокус fromEnum! Це добре вийшло. Також я пропустив частину правил, яка заявляла про прийнятне рішення, може бути функцією, яка займає список цілих чисел. Це врятувало величезну кількість роботи.

ОНОВЛЕННЯ 2

Відповідно до інших пропозицій, поголіть кілька байтів шляхом переупорядкування операцій, створивши ще один захисник, який завжди визначає True, і узор, що відповідає W, що відповідає шаблону, в Списку з 3-х елементів. Дякую за пропозиції!

ОНОВЛЕННЯ 3

Ще одна подяка Лайконі за вказівку більше кодових правил гольфу, про які я не знав. Крім того, відображення v на мій вклад для створення списку частково застосованих функцій було феноменальною ідеєю і врятувало мені 4 додаткові байти!

Haskell, 92 87 байт

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

Спробуйте в Інтернеті!

Виходячи з відповіді @ maple_shaft, я просто трохи її підрахував.

Дякуємо @Laikoni за 5 байт!

C, 171 161 байт

#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 машинного коду, 62 байти

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

Останні три байти містять (нульовий показник) вхід. Гей, ви сказали мені, що я можу використовувати найзручніший формат введення. У цьому випадку це жорстке кодування!
Вихід - код помилки, повернутий в оболонку.

Як це працює:

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