Итак, вчера был 2-й рождественский день, и мы с бабушкой и дедушкой играли в «sjoelen», как ее называют в Нидерландах. Ко мне подошел внутренний программист, но как только я получил ответ, я его потерял. Я хочу, чтобы ты переделал это.

Правила:

У вас есть деревянная доска, sjoelbak , с 4 коробками, каждая со своим номером. Когда schijf (объект, похожий на шайбу) входит в одну из коробок, вы получаете очки над этой коробкой.

Когда во всех 4-х коробках есть schijf , вы не получаете 10, но вы получаете 20 очков.

Пример:

Слева направо: 3 5 4 3
Каждая коробка имеет не менее 3 шивенов (множественное число по Шифу ), так что 20 * 3 = 60 баллов.

Результирующие значения: 0 2 1 0
0 * 2 + 2 * 3 + 1 * 4 + 0 * 1 = 10 баллов.

Что составляет в общей сложности 60 + 10 = 70 баллов.

Ввод:
количество schijven слева направо, то есть "4 5 4 5", [4,5,4,5], "4 \ n5 \ n4 \ n5", что угодно.

Вывод:
количество очков, т.е. 84, как вывод, переменная, возврат или вершина стека, как вам угодно.

Как и в каждом коде гольф, вы не можете использовать внешние скрипты и код с наименьшим количеством байтов выигрывает.

PS: Как вы уже могли заметить, я голландец. Не стесняйтесь редактировать возможные грамматические ошибки.

CJam, 23 21 20 байт

q~_$0=f+1m>{X):X*+}*

Я мог бы сыграть пару байтов от этого.

Ввод как

[3 5 4 3]

Вывод - оценка

70

Как это работает

q~                         "Read the input and evaluate into an array";
  _$0=                     "Copy the array, sort it and get the minimum number";
                           "This minimum is the number of common schijven";
      f+                   "Increment each of the schijven by the common schijven number"; 
        1m>                "Take 1 element from the end of the array and put";
                           "it in the beginning";
           {      }*       "Reduce the elements of the array based on this block";
            X):X           "Increment and update the value of X (initially 1)";
                *          "Multiply the number of schijven with X";
                 +         "Add it to current score";

Алгоритм

• Так как я сместил число Schijven вправо, порядок счета теперь становится [1 2 3 4].
• Более того, используя тот факт, что 1 + 2 + 3 + 4 = 10я просто добавляю минимальный общий schijven к каждому, чтобы получить эффект бонусного 10счета.
• Теперь, когда я уменьшаю, я сначала получаю 2 элемента в стеке, первый, который я игнорирую, - это элемент с количеством очков 1, затем я умножаю второй 2и добавляю его к первому. В следующей итерации я получаю текущую сумму и счет 3schijven. И так далее.

Попробуйте онлайн здесь

Пит, 240 (30 * 8) кодов, 138, содержащих фактический код

Кодел 10, для лучшей видимости

Тестовые примеры:

D:\codegolf\npiet-1.3a-win32>npiet sjoelen_point_count_cs10.png
? 3
? 5
? 4
? 3
70
D:\codegolf\npiet-1.3a-win32>npiet sjoelen_point_count_cs10.png
? 4
? 5
? 4
? 5
84

Дисплей потока:

Использование моих собственных сокращений для облегчения работы и компактного отображения. Он показывает общий ход программы, а не точное расположение кодов.

NOP ADD DIV GRT DUP INC END
 0   +   /   >   =   c   ~
PSH SUB MOD PTR ROL OUN
 X   -   %   #   @   N
POP MUL NOT SWI INN OUC
 ?   *   !   $   n   C

1X!nnnn=5X2X@=5X2X@=5X2X@=5X1X@**
       0                        *
       0       @+5X1X@1X-4X1X@  !
       0       -             0  !
       0       X1!X1X6+*==X40000#  <--pointer if top of stack=1 (all boxes full,
       0                     0  2      add 20 points, decrement count for all boxes)
       0000-X1@X1X2-X1@X1X3-X1  X  |  pointer if top of stack=0 (not all boxes full,
                                *  V   add 2a+3b+4c+d)
           ~N++++*X4@X2X3*X3@X1X2

Полное объяснение:

      (score=0)  a   b   c   d
      1 PSH NOT INN INN INN INN

      ..... sort and duplicate the numbers .....
**1** DUP 5 PSH 2 PSH ROL DUP 5 PSH 2 PSH ROL DUP 5 PSH 2 PSH ROL DUP 5 PSH 1 PSH ROL

      ( a*b*c*d ) (convert to boolean) 1 if all boxes are full, 0 if at least one box is empty
      MUL MUL MUL NOT NOT

      change direction if 1 (**2**)
      go straight ahead if 0 (**3**)
      PTR

      ( compress 20=4*4+4 )       (0-1=-1/ neg. roll) score+20
**2** 4 PSH DUP DUP MUL ADD 6 PSH 1 PSH NOT 1 PSH SUB ROL ADD

      (put score back to bottom of stack) ... a=a-1, b=b-1, c=c-1, d=d-1 ...
      5 PSH 1 PSH ROL 1 PSH SUB 4 PSH 1 PSH ROL 1 PSH SUB 3 PSH
      1 PSH ROL 1 PSH SUB 2 PSH 1 PSH ROL 1 PSH SUB

      loop to **1**

      (   a*2   )               (   b*3   )               (  c*4  )
**3** 2 PSH MUL 2 PSH 1 PSH ROL 3 PSH MUL 3 PSH 2 PSH ROL 4 PSH MUL

      +2a +3b +d +score
      ADD ADD ADD ADD

      output score
      OUN

Сохраните изображение и попробуйте его в этом онлайн-переводчике Piet:

PietDev онлайн переводчик Piet

APL (Dyalog Classic) , 16 13 12 байт

-3 благодаря @ Adám

(+/+\)1⌽⌽+⌊/

Попробуйте онлайн!

⌽+⌊/ обратный (arg) + мин (arg)

1⌽ поверните 1 влево

+\ частичные суммы

+/ сумма

Mathematica, 38 32 23 20 байт

(#+Min@#).{2,3,4,1}&

(С помощью swish )

Используйте, прикрепив ввод до конца:

(#+Min@#).{2,3,4,1}&@{3,5,4,3}

70

Альтернативный (36 байт):

20*Min@#+Total[(#-Min@#)*{2,3,4,1}]&

R, 41 40 символов

b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))

Использование:

> b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))
1: 4 5 4 5
5: 
Read 4 items
[1] 84
> b=min(a<-scan());sum(5*b+(a-b)*c(2:4,1))
1: 3 5 4 3
5: 
Read 4 items
[1] 70

В последнем примере, aявляется вектор 3 5 4 3, a-bявляется 0 2 1 0, который мы многократно с вектор , 2 3 4 1таким образом , давая , 0 6 4 0который мы добавим с 5*bдавая 15 21 19 15( 5*bперерабатывается для каждого члена добавленного вектора, следовательно , эффективно добавляя 4*5*b), который мы , наконец , подвести, таким образом давая 70.

JavaScript (ES6), 93 47 байт

s=(a,b,c,d)=>10*Math.min(a,b,c,d)+a*2+b*3+c*4+d

Использование: s(1, 2, 3, 4)

Как это работает: функция ищет наименьшее число в аргументах, умножает его на 10(не с 20) и добавляет остаток от оценки. Нет необходимости умножать на 20и вычитать части из счета, чтобы продолжить вычисление.

Спасибо edc65 за улучшение обмена!

Un-golfed:

function score(a, b, c, d) {
    return 10 * Math.min(a, b, c, d) + a * 2 + b * 3 + c * 4 + d;
}

Пиф , 15

sm*hd+@QtdhSQUQ

Ввод следует вводить через STDIN через запятую, например

3,5,4,3

При этом используется тот же прием, что и во многих других решениях, - добавление минимума к каждому элементу для учета бонуса. Минимум hSQв приведенном выше коде. Чтобы учесть умножение на 2, 3, 4 и 1, я отображаю d над списком [0,1,2,3] и умножаю (dl) -й элемент ввода на d + 1. Таким образом, -1-й элемент умножается на 1, ноль на 2, первый на 3, а второй на 4. Затем я суммирую.

J, 23 22 знака

   (+/ .*&2 3 4 1@(+<./))

Пример:

   test =. 3 5 4 3
   (+/ .*&2 3 4 1@(+<./)) test
70

Попробуй это здесь.

(23 длинного явное определение функции: v=:3 :'+/+/\.3|.y+<./y')

Страус v0.1.0 , 48 41 символов _{^{(слишком длинный)}}

.$0={}/:n;{n-}%)\+1:i;{i*i):i;}%{+}*20n*+

Это просто то же самое, что и старая версия ниже, за исключением того, что вместо @вращения целого стека )\+(вместо правильных) используется.

Старая версия:

.$0={}/:n;{n-}%{}/{4@}3*1:i;]{i*i):i;}%{+}*20n*+

На самом деле я обнаружил две ошибки в своем недавно реализованном языке, аннотированные в описании ниже. (Язык в настоящее время очень, очень похож на Golfscript, поэтому, если вы знаете Golfscript, его должно быть довольно легко читать.

.$0=   get min value (for the *20 thingy)
{}/    *actually* get min value (BUG: `array number =' returns a single-element array...)
:n;    store as n
{n-}%  subtract this value from all array elements
{}/    dump array onto stack
{4@}3* rotate stack so that instead of 2 3 4 1, multipliers are 1 2 3 4
       (BUG: negative rotations don't work)
1:i;   set i (the multiplier) to 1
]{i*   multiply each array element by i
i):i;  increment i
}%     (do the previous 2 lines over each array element)
{+}*   add up all the array elements
20n*+  add 20*n (the min value we got in line 1)

Ожидает ввод в виде массива на STDIN, потому что я ручка и забыла реализовать ввод / вывод в v0.1.0.

Решение реальной проблемы в Страусе приятно, потому что оно показывает мне, сколько еще нужно добавить к языку: D

Python 2, 43 байта

lambda i:i[1]-i[3]+2*(sum(i)+i[2]+5*min(i))

Вдохновленный ответом @ user2487951.

Jagl Alpha 1,2 - 20 байт

Ввод в формате stdin (3 4 5 6), вывод в стеке:

T~dqZ*S1 5r]%{U*}/b+

Жду ответа от оригинального постера о выходном формате. Поскольку input указан как «что угодно» , я предполагаю, что мой ввод может быть массивом в верхней части стека. Теперь принимает входные данные на стандартный ввод.

Объяснение:

T~                            Get input from stdin and evaluate
  dqZ*                      Duplicate, get minimum, and multiply that by 10
      S1 5r]                Swap (so array is on top), push range 1-5 exclusive, and rotate
            %{U*}/          Zip arrays together, and multiply each pair
                  b+P       Get the sum of that, add the common minimum, and print

Хаскелл, 40

g l@[a,b,c,d]=2*a+3*b+4*c+d+10*minimum l

вместо удаления минимального числа из остальных и добавления дополнительных 20s, это добавляет дополнительное 10для минимального числа.

Матлаб, 27

Мне потребовалось время, чтобы понять, что это одиночная игра. С помощью анонимной функции

f=@(N)N*[2;3;4;1]+10*min(N)

который вызывается с вектором строки

f([3 5 4 3]) == 70
f([7 7 9 7]) == 148

Java, 84 байта

int A(int[]a){int m=9;for(int i:a)m=i<m?i:m;return 10*m+a[3]+2*a[0]+3*a[1]+4*a[2];}

У меня есть идея, что дальше можно играть в гольф, но пока это все.

Вызов с A(new int[]{3,5,4,3})выходом возвращается как int (потому что System.out.println()будет удвоить байты)

Ungolfed

int getScore(int[] input){
    int min=9;

    for(int x:input) {
        if(x<min){
            min=x;
        }
    }

    return 10*min + 2*input[0] + 3*input[1] + 4*input[2] + 1*input[3];
}

GolfScript, 22 байта

~3,{1$>~;}%+$(11*+{+}*

Читает ввод из стандартного ввода в формате [3 5 4 3]. Записывает вывод в стандартный вывод. (Если разрешено использование входных данных в качестве массива в стеке, ведущий ~может быть опущен в общей сложности 21 байт.)

При этом используется несколько иная стратегия, чем в решениях CJam / Pyth / etc: сначала я строю массив из 2 копий первого входного значения, 3 второго, 4 третьего и одного четвертого. Затем я сортирую этот массив, вытаскиваю наименьший элемент, умножаю его на 11 и суммирую с другими элементами.

Python 2, 51

Скучный, но короткий:

l=input()
print l[0]*2+l[1]*3+l[2]*4+l[3]+10*min(l)

Более питонический:

l=input()
print sum(map(lambda x,y:x*y,l,[2,3,4,1]))+10*min(l)

Юлия, 48 35 персонажей

function p(m);sum([2 3 4 1].*m)+10minimum(m);end

в компактной форме задания:

p(m)=sum([2 3 4 1].*m)+10minimum(m)

Пример:

julia> p([3 5 4 3])
70

Javascript, 97 байт

a=prompt().split(" "),b=Math.min.apply(1,a);alert(20*b+2*(a[0]-b)+3*(a[1]-b)+4*(a[2]-b)+(a[3]-b))

Javascript, ES6, 57

f=(a,b,c,d)=>a*b*c*d?20+f(--a,--b,--c,--d):a*2+b*3+c*4+d

Я хотел посмотреть, как получится рекурсия, и хотя это определенно не самый короткий ответ, я чувствовал, что все получилось хорошо.

a*b*c*d: Он принимает входные значения и находит произведение всех их, и оценивает его как логическое выражение для встроенного оператора if. Это вернет false, если одно или несколько значений равно 0, и true для любого другого значения.

20+f(--a,--b,--c,--d): Если он возвращает true, функция возвращает 20 (для набора по Шийвену ) плюс рекурсивный вызов функции для всех значений минус одно (Для удаления этого набора по Шийвену ). Таким образом, он будет рекурсивно проходить по циклу, пока хотя бы один из блоков не станет пустым.

a*2+b*3+c*4+dПосле того, как хотя бы одно поле будет пустым, будет запущена остальная часть встроенного оператора if. Он просто возвращает баллы за оставшийся счижвен в коробках.

Таким образом, в конце все 20 наборов точек Шийвена , а оставшиеся точки суммируются и возвращаются из функции, что дает ответ.

Haskell 42 символа

f l=10*minimum l+sum(zipWith(*)[2,3,4,1]l)

HPPPL (язык программирования HP Prime), 58 57 байт

Знак * между 10 и мин не обязателен, поэтому я удалил его.

EXPORT s(m)
BEGIN
return sum([2,3,4,1].*m)+10min(m);
END;

HPPPL - это язык программирования для калькулятора цветных графиков HP Prime / CAS.

Пример работы:

Если это не обязательно программа, то она реализуется в 40 39 байтов однострочника:

m:=[3,5,4,3];sum([2,3,4,1].*m)+10min(m)

Staq, 72 символа

't't't't{aii*XX}$&iia$&ia$&a+XX+XX+|{mxx}{lxX}{k>?m!l}kkk&iiqi&ii*s*t|+:

Пример выполнения:

Executing D:\codegolf\Staq\sjoelen codegolf.txt

3
5
4
3
70

Execution complete.
>

Staq имеет два стека: один активный, другой пассивный. Команда |переключает активный стек в пассивный и наоборот.

Все, что находится между фигурными скобками, определяет функцию, первая буква после открывающей скобки - это имя функции, остальная часть до закрывающей скобки - это сама функция. Возможны переопределение функций, рекурсии и вложенных функций. {aii}бы определить функцию а , что бы приращение вершины стека дважды. Каждый следующий экземпляр aв коде будет заменен на ii.

Комментарии внутри программ Staq: &добавляет ноль на вершине стека, [указывает указателю перейти к соответствующему, ]если вершина стека равна нулю, xудаляет самое верхнее значение в стеке. Таким образом, комментарии могут быть записаны в код в виде&[here is a comment]x

Объяснение (также исполняемое):

'                                      &[input number]x
 t                                     &[copy top of active stack to passive stack]x
  t't't                                &[input next three numbers and copy them to the passive stack]x
       {aii*XX}                        &[define function a (increment twice, multiply the two topmost values, then delete the second value on the stack twice)]x
               $                       &[move top value to the bottom of the stack]x
                &ii                    &[put zero on top of the stack, incremment twice]x
                   a                   &[function a]x
                    $&ia$&a
                           +           &[put sum of the two topmost values on top of the stack]x
                            XX         &[delete second stack value, twice]x
                              +XX+
                                  |    &[switch active/passive stack]x
{mxx}                                  &[define function m: delete two topmost stack values]x
     {lxX}                             &[define function l: delete topmost stack value, then delete second value of remaining stack]x
          {k>?m!l}                     &[define function k: boolean top > second value? put result on top of the stack, if top>0 then execute m, if top = 0 then execute l]x
                  kkk&ii
                        q              &[put square of top value on top of the stack]x
                         i&ii
                             *         &[multiply two topmost values and put result on top of the stack]x
                              s        &[move bottom stack value to the top]x
                               *t|+
                                   :   &[output result]x

https://esolangs.org/wiki/Staq

Программа использует один стек (изначально активный), чтобы вычислить 2a + 3b + 4c + d, и второй стек (первоначально пассивный), чтобы вычислить в 10 раз меньшее из входных значений. Затем оба результата суммируются и отображаются.

PowerShell для Windows , 48 47 байт

^{-1 байт благодаря маззи}

$args|%{$a+=++$i%4*$_+$_}
$a+10*($args|sort)[0]

Попробуйте онлайн!