Вступление

Игра в кости 10 000 - игра в кости, в которую можно сыграть с 6 кубиками и кое-чем написать. Игроки бросают кости несколько раз за ход и получают очки в конце. Игрок, набравший 10000 очков первым, выигрывает игру. Подсчет очков за один бросок - ваша работа в этом испытании.
Смотрите здесь для полных правил.
Обратите внимание, что правила (в частности, оценка) меняются от региона к региону, поскольку игра широко известна. Мы используем правила, описанные ниже.

Соревнование

Учитывая список из шести чисел от одного до шести, представляющих бросок костей, выведите их результат. Оценка рассчитывается следующим образом:

• Ones насчитывает 100 точек
• Пятерки подсчитывают 50 очков
• Тройняшки считают их количество раз 100 очков. Например, три пары дают 200 очков. Исключение составляют три, которые насчитывают 1000 баллов.
• Шесть из того же числа считаются двумя тройками, как описано выше. Итак, шесть тройок дают 600 очков. То же самое относится и к крайнему случаю с шестью: шесть - 2000 очков.
• Один кубик нельзя использовать более одного раза. Если кубик является частью триплета, он не учитывается для других очков. Пятерки в тройке не учитывают 50 очков в дополнение к 500 очкам, которые они дают.
• Тройки всегда учитываются в первую очередь, чтобы максимизировать счет. Таким образом, три пятерки никогда не считаются 150 очками. Четыре пятерки считаются одной тройкой и одной обычной пятеркой, что дает 550 очков.

Примечания

• Ввод всегда будет содержать шесть чисел от одного до шести. Вы не получите неверный ввод.
• Числа могут быть в любом порядке. Вы не можете принимать какие-либо конкретные заказы.

правила

• Формат ввода зависит от вас, если он не был предварительно обработан.
• Функция или полная программа разрешены.
• Правила по умолчанию для ввода / вывода.
• Применяются стандартные лазейки .
• Это код-гольф , поэтому выигрывает меньшее количество байт. Tiebreaker является более ранним представлением.

Контрольные примеры

[1, 2, 3, 4, 5, 6] -> 150
[1, 1, 1, 2, 3, 5] -> 1050
[1, 1, 1, 1, 1, 1] -> 2000
[2, 2, 2, 2, 2, 2] -> 400
[6, 6, 1, 5, 5, 6] -> 800
[2, 3, 4, 6, 2, 4] -> 0
[1, 5, 1, 5, 1, 5] -> 1500
[5, 5, 5, 5, 2, 3] -> 550
[1, 1, 1, 1, 1, 5] -> 1250
[3, 3, 4, 4, 3, 4] -> 700

05AB1E , 34 31 30 байт

7G¹N¢O3‰N*2LRN1Q+°*X5‚Nå_i¨}OO

объяснение

7G                                  # for N in 1..6
  ¹N¢O                              # count number of occurrences of N in input
      3‰                            # divmod 3
        N*                          # multiply by N
          2LRN1Q+°*                 # multiply by 10, 100 or 1000
                   X5‚Nå_i¨}        # if N is not 1 or 5, scrap the singles
                            OO      # sum all triple and single scores so far
                                    # implicitly display total sum

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

Python 2, 152 148 125 байт

Довольно простое решение. Можно играть в гольф больше. L.countЭто немного долго, но я не мог удалить первый вызов, потому что L обновляется.

def f(L):s=n=0;exec"n+=1\nwhile L.count(n)>2:s+=[n*100,1e3][n<2];exec'L.remove(n);'*3\n"*6;C=L.count;print s+100*C(1)+50*C(5)

Попробуйте онлайн - (все тестовые случаи)

Ungolfed:

def f(L,s=0):
    L.sort()
    for n in range(1,7):
        while L.count(n)>2:
            s+=n*100*((n<2)*9+1) # multiply by 10 if n==1
            i=L.index(n)
            L=L[:i]+L[i+3:]
    s+=100*L.count(1)+50*L.count(5)
    print s

Некоторые кредиты в гольф @Copper , используя некоторые советы из своего кода

PowerShell v2 + v3 +, 147 144 137 133 байта

$n=$args[0]|sort;while($n){if(($x=$n[0])-eq$n[2]){$s+=100*$x+900*($x-eq1);$a,$b,$n=$n}else{$s+=50*($x-in1,5)+50*($x-eq1)}$a,$n=$n};$s

_{Вычеркнуто 144 выглядит как 144?}

Принимает данные $args[0]и sortсохраняет их в $n. Затем whileостаются еще элементы, мы оцениваем if/else .

Если первый элемент (временный элемент хранится в $xнескольких байтах) соответствует третьему элементу, у нас есть тройка. Добавьте к $sумножению результат некоторого умножения 100*$xплюс логическое значение, 900только если это значение $xравно -equal 1. Это дает нам необходимое 1000для трех. Затем снимите первые два элемента в $a, и $b, а остальные в $n- удаление третьего элемента тройки обрабатывается позже.

В противном случае у нас нет тройки, поэтому добавим к $sрезультату другого логического сложения. Мы добавляем 50if $xили 1or 5, а затем добавляем другую, 50если это -equal 1. Этот раздел теперь требует v3 + для -inоператора.

В любом случае у нас еще есть элемент, который нужно удалить, поэтому снимите первый элемент $aи оставьте его в $n.

Наконец, когда цикл завершен, поместите его $sв конвейер. Вывод неявный Write-Outputв конце выполнения.

Контрольные примеры

PS C:\Tools\Scripts\golfing> (1,2,3,4,5,6),(1,1,1,2,3,5),(1,1,1,1,1,1),(2,2,2,2,2,2),(6,6,1,5,5,6),(2,3,4,6,2,4),(1,5,1,5,1,5),(5,5,5,5,2,3),(1,1,1,1,1,5),(3,3,4,4,3,4)|%{($_-join',')+" -> "+(.\evaluate-dice-1000.ps1 $_)}
1,2,3,4,5,6 -> 150
1,1,1,2,3,5 -> 1050
1,1,1,1,1,1 -> 2000
2,2,2,2,2,2 -> 400
6,6,1,5,5,6 -> 800
2,3,4,6,2,4 -> 0
1,5,1,5,1,5 -> 1500
5,5,5,5,2,3 -> 550
1,1,1,1,1,5 -> 1250
3,3,4,4,3,4 -> 700

JavaScript (ES6), 87 86 байт

a=>a.sort().join``.replace(/(.)\1\1|1|5/g,s=>r+=s>>7?s/1.11:s>5?1e3:s>1?50:100,r=0)&&r

Сортирует и структурирует входные данные, чтобы можно было идентифицировать оценочные комбинации с помощью регулярных выражений. Редактировать: 1 байт сохранен благодаря @Arnauld.

Python 2 или 3, 123 122 121 116 109 108 104 102 100 97 байт

Python 2, 97 байт

lambda r:100*sum(c/3*((v<2)*9+v)+c%3*(v<2or(v==5)/2.)for v,c in enumerate(map(r.count,range(7))))

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

Python 3, 97 байт

lambda r:100*sum(c//3*((v<2)*9+v)+c%3*(v<2or(v==5)/2)for v,c in enumerate(map(r.count,range(7))))

Рубин, 80 78 байт

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

-2 байта от @ezrast.

->d{s=0;7.times{|i|c=d.count i;i<2&&i=10;s+=c>2?c/3*i*100:1>i%5?c%3*i*10:0};s}

Haskell, 130 123 байта

Это не вызов для Хаскелла. Также я в этом играю в гольф.

Спасибо @nimi.

import Data.List
f=g.sort
g(x:a@(y:z:b))|x>z=j x+g a|0<1=100*h x+g b
g(x:y)=j x+g a
g _=0
h 1=10
h x=x
j 1=100
j 5=50
j _=0

Javascript (ES6), 85 84 байта

x=>x.map(v=>s+=v*(((z+=1<<v*3)>>v*3&7)%3?v-5?v-1?0:10:1:v-5?v-1?10:80:8),s=z=0)|10*s

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

let F =
x=>x.map(v=>s+=v*(((z+=1<<v*3)>>v*3&7)%3?v-5?v-1?0:10:1:v-5?v-1?10:80:8),s=z=0)|10*s

console.log(F([1, 2, 3, 4, 5, 6])); // 150
console.log(F([1, 1, 1, 2, 3, 5])); // 1050
console.log(F([1, 1, 1, 1, 1, 1])); // 2000
console.log(F([2, 2, 2, 2, 2, 2])); // 400
console.log(F([6, 6, 1, 5, 5, 6])); // 800
console.log(F([2, 3, 4, 6, 2, 4])); // 0
console.log(F([1, 5, 1, 5, 1, 5])); // 1500
console.log(F([5, 5, 5, 5, 2, 3])); // 550
console.log(F([1, 1, 1, 1, 1, 5])); // 1250
console.log(F([3, 3, 4, 4, 3, 4])); // 700

Python 3, 131 байт

lambda r,C=list.count:sum([x%7*100,1e3][x%7<2]*(C(r,x%7)>2and not exec('r.remove(x%7);'*3))for x in range(14))+50*C(r,5)+100*C(r,1)

Это лямбда-выражение; чтобы использовать его, назначьте его, добавив f=.

Сначала мы проверяем тройки дважды (используя модуль), удаляя тройки по ходу; затем мы просто добавляем количество 5и 1к счету и возвращаем его.

Попробуйте это на Ideone! (со всеми тестами)

Вот мое старое представление Python 2:

Python 2, 176 172 171 145 136 134 133 байта

def e(r):s=x=0;exec'x+=1;a=x%7;\nif r.count(a)>2:exec"r.remove(a);"*3;s+=[a*100,1e3][a<2]\n'*14;C=r.count;s+=50*C(5)+100*C(1);print s

Сохранение байта в решении Python 2 благодаря @ mbomb007!

BASH (sed + bc) 161

sed -re's/([1-6])(.*)\1(.*)\1/\100\2\3/g;s/([1-6])( .*)\1( .*)\1/\100\2\3/g;s/10/1/g; s/1/100/g;s/5( |$)/50 /g;s/[1-6][^0]//g;s/ +/+/g;s/(^\+|\+$)//g;s/^$/0/'|bc

Я хотел сделать все это в седе, но сложение действительно сложно ...

Объяснение:

1. Найдите триплет, добавьте 00к первому номеру и удалите другой,
   например 1 2 1 3 1 4->100 2 3 4
2. Повторите шаг 1, если есть две тройки
3. Заменить 10с 1затем 1с , 100
   например , 100-> 10-> 1000или 1->1 ->100
4. Заменить каждый 5не следует 0с50
5. Удалить любое число, которое не заканчивается 0
6. Заменить группы пространств на +
7. Удалить ведущие и конечные +с
8. Если строка пуста, добавьте 0
9. Наконец труба, чтобы bcсложить все.

Perl, 69 байт

Включает +2 для -ap

Запустите с помощью ввода на STDIN:

dice10000.pl <<< "5 1 1 1 1 1"

dice10000.pl:

#!/usr/bin/perl -ap
$_=join 0,sort@F,A;print;s%(10|\d)\1\1|10|5%$n+=$1.0||$&%eg;$_=$n.0

C # (.NET Core) , 228 227 байт

class A{static void Main(string[] a){int[] x=new int[7];int i=0,s=0;for(;i<6;i++)x[int.Parse(a[i])]++;while(i>0){while(x[i]>2){s+=i>1?10*i:100;x[i]-=3;}i--;}while(x[1]-->0)s+=10;while(x[5]-->0)s+=5;System.Console.Write(s*10);}}

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

Я чувствую, что не хватает много, много потенциальных оптимизаций, но я сделал сохранить байты путем умножения на 10 в конце. Ввод должен быть передан как отдельные аргументы командной строки.

Perl 5 -ap , 78 байт

$_=join'',sort@F;s|(\d)\1\1|!($\+=$1*($1-1?2:20))|ge;$\+=y/5//+2*y/1//}{$\*=50

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