Introdução

Dados 10.000 é um jogo de dados que pode ser jogado com 6 dados e algo para escrever. Os jogadores jogam os dados várias vezes por turno e ganham uma pontuação no final do mesmo. O jogador que atingir 10.000 pontos ganha primeiro o jogo. Calcular a pontuação de um rolo é o seu trabalho neste desafio.
Veja aqui as regras completas.
Observe que as regras (principalmente a pontuação) mudam de região para região, já que o jogo é amplamente conhecido. Usamos as regras descritas abaixo.

O desafio

Dada uma lista de seis números de um a seis, representando uma jogada de dados, mostre sua pontuação. A pontuação é calculada da seguinte maneira:

• Uns contam 100 pontos
• Cincos conta 50 pontos
• Os trigêmeos contam seu número vezes 100 pontos. Três duplas, por exemplo, dão 200 pontos. Uma exceção são três que contam 1000 pontos.
• Seis do mesmo número contam como dois trigêmeos, como descrito acima. Então, seis três dão 600 pontos. O mesmo vale para os casos extremos: seis são 2.000 pontos.
• Um dado não pode ser usado mais de uma vez. Se um dado faz parte de um trigêmeo, ele não conta para outras pontuações. Os cincos em um trigêmeo não contam 50 pontos além dos 500 pontos que dão.
• Os triplos são sempre contados primeiro para maximizar a pontuação. Portanto, três cincos nunca são contados como 150 pontos. Quatro cincos são contados como um trigêmeo e um cinco ordinário, o que dá 550 pontos.

Notas

• A entrada sempre conterá seis números de um a seis. Você não receberá entradas inválidas.
• Os números podem estar em qualquer ordem. Você não pode assumir pedidos específicos.

Regras

• O formato de entrada é com você, desde que não seja pré-processado.
• Função ou programa completo permitido.
• Regras padrão para entrada / saída.
• Aplicam-se brechas padrão .
• Isso é código-golfe , portanto, a menor contagem de bytes vence. O desempate é uma submissão anterior.

Casos de teste

[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 bytes

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

Explicação

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

Experimente online

Python 2, 152 148 125 bytes

Solução bastante simples. Pode ser jogado mais. L.counté um pouco longo, mas não pude remover a primeira chamada porque L é atualizado.

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)

Experimente online - (todos os casos de teste)

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

Algum crédito de golfe para @Copper , usando algumas dicas de seu código

PowerShell v2 + v3 +, 147 144 137 133 bytes

$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

_{Riscado 144 parece meio que 144?}

Pega $args[0]e insere sort, armazena $n. Então, whileainda existem elementos restantes, avaliamos um if/ else.

Se o primeiro elemento (temp armazenado em $xpara salvar alguns bytes) corresponder ao terceiro, teremos um triplo. Adicione ao $shum o resultado de alguma multiplicação 100*$xmais um baseado em booleano 900apenas se $xfor -eqnecessário 1. Isso nos dá o requisito 1000para três. Em seguida, retire os dois primeiros elementos para $a, e $b, e o restante para $n- remover o terceiro elemento do triplo é tratado posteriormente.

Caso contrário, não temos um triplo, então adicione a $shum o resultado de outra adição baseada em booleano. Adicionamos 50if $xé um 1ou 5, e depois adicionamos outro 50se for -eqnecessário 1. Esta seção agora requer a v3 + para o -inoperador.

Em ambos os casos, ainda temos um elemento ainda para remover, assim que descolar o primeiro elemento em $ae deixar o restante no $n.

Finalmente, quando o loop estiver concluído, coloque $sno pipeline. A saída é implícita Write-Outputno final da execução.

Casos de teste

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 bytes

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

Classifica e especifica a entrada para que as combinações de pontuação possam ser identificadas por meio de regexp. Editar: salvou 1 byte graças a @Arnauld.

Python 2 ou 3, 123 122 121 116 116 108 108 102 102 100 97 bytes

Python 2, 97 bytes

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

Os casos de teste são em ideone

Python 3, 97 bytes

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

Ruby, 80 78 bytes

Experimente online!

-2 bytes de @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 bytes

Isto é não um desafio para Haskell. Também estou no golfe isso.

Graças a @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 bytes

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

Casos de teste:

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 bytes

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)

Esta é uma expressão lambda; para usá-lo, atribua-o anexandof= .

Primeiro, checamos triplos duas vezes (usando o módulo), removendo os triplos à medida que avançamos; basta adicionar as contagens de 5e1 à pontuação e a devolvemos.

Experimente no Ideone!(com todos os casos de teste)

Aqui está o meu envio mais antigo do Python 2:

Python 2, 176 172 171 145 136 134 133 bytes

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

Economizei um byte na solução Python 2 graças a @ 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

Eu queria fazer tudo no sed, mas a adição é realmente difícil ...

Explicação:

1. Encontre um trigêmeo, adicione 00ao primeiro número e remova o outro,
   por exemplo 1 2 1 3 1 4- ->100 2 3 4
2. Repita a etapa 1, caso haja duas triplas
3. Substitua 10por 1então 1por, 100
   por exemplo, 100-> 10-> 1000ou 1-> 1->100
4. Substituir cada 5não seguido por 0com50
5. Remova qualquer número que não termine em 0
6. Substitua grupos de espaços por +
7. Remover à esquerda e à direita + s
8. Se a sequência estiver vazia, adicione um 0
9. Por fim, bcadicione para adicionar tudo.

Perl, 69 bytes

Inclui +2 para -ap

Execute com a entrada em 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 bytes

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

Experimente online!

Eu sinto que eu estou perdendo muitas, muitas otimizações em potencial aqui, mas eu fiz salvar um byte multiplicando por 10 no final. A entrada deve ser passada como argumentos de linha de comando separados.

Perl 5 -ap , 78 bytes

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

Experimente online!