Несколько лет назад Hot Wheels создали простую флеш-игру под названием «Formula Fuelers Racers» *. Чтобы играть в игру, вы выбираете три ингредиента из холодильника, чтобы положить их в свой автомобиль, который затем сравнивается со случайно сгенерированным компьютером компьютера. Оказывается, механика этой игры довольно проста. Во-первых, фактическое «время» гонки вашего автомобиля генерируется случайным образом и не имеет никакого отношения к тому, выиграете вы или нет. Во-вторых, победитель гонки определяется по количеству баллов, которое рассчитывается по выбранным ингредиентам (допускается дублирование ингредиентов, и порядок имеет значение). Каждый ингредиент имеет связанную «ценность» и связанную «операцию», как показано в следующей таблице:

#   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 из каждого индекса выше).

Ouput

Ваша программа должна вывести единственное целое число, указывающее счет.

Тестовые случаи

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, чтобы получить цифры base-6, используются увеличенные дополненные значения - это экономит байты, позволяя Ịатому выбирать отрицательные элементы перед этапом дополнения, одновременно сохраняя байт в base-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 аргумента в «обычном» синтаксисе каррирования 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.

На самом деле это работает для любого количества входов, так как вы можете иметь автомобили с 4 или более характеристиками или автомобили с двумя. Это не было преднамеренным, просто как это закончилось.

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

В соответствии с другими предложениями побрил несколько байтов путем переупорядочения операций, создания else-защиты, которая всегда оценивается как 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)