Introducción

Dice 10,000 es un juego de dados que se puede jugar con 6 dados y algo para escribir. Los jugadores tiran los dados varias veces por turno y obtienen un puntaje al final. El jugador que alcanza los 10.000 puntos primero gana el juego. Calcular el puntaje de un rollo es tu trabajo en este desafío.
Mira aquí las reglas completas.
Tenga en cuenta que las reglas (especialmente la puntuación) cambian de región a región ya que el juego es ampliamente conocido. Usamos las reglas descritas a continuación.

El reto

Dada una lista de seis números del uno al seis que representan una tirada de dados, genera su puntaje. La puntuación se calcula de la siguiente manera:

• Unos cuenta 100 puntos
• Fives cuenta 50 puntos
• Los trillizos cuentan su número multiplicado por 100 puntos. Tres dos por ejemplo dan 200 puntos. Una excepción son tres que cuentan 1000 puntos.
• Seis del mismo número cuentan como dos trillizos como se describió anteriormente. Entonces seis tres dan 600 puntos. Lo mismo ocurre con el caso límite: los seis son 2.000 puntos.
• Un dado no puede usarse más de una vez. Si un dado es parte de un triplete, no cuenta para otras puntuaciones. Los cinco en un triplete no cuentan 50 puntos además de los 500 puntos que dan.
• Los triples siempre se cuentan primero para maximizar la puntuación. Entonces tres cinco nunca se cuentan como 150 puntos. Cuatro cinco se cuentan como un triplete y un cinco ordinario que luego da 550 puntos.

Notas

• La entrada siempre contendrá seis números del uno al seis. No recibirá entradas inválidas.
• Los números pueden estar en cualquier orden. No puede asumir ningún pedido específico.

Reglas

• El formato de entrada depende de usted siempre que no esté preprocesado.
• Función o programa completo permitido.
• Reglas predeterminadas para entrada / salida.
• Se aplican lagunas estándar .
• Este es el código de golf , por lo que gana el conteo de bytes más bajo. Tiebreaker es una presentación anterior.

Casos de prueba

[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

Explicación

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

Pruébalo en línea

Python 2, 152 148 125 bytes

Solución bastante simple. Se puede jugar más al golf. L.countes un poco largo, pero no pude eliminar la primera llamada porque L está actualizada.

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)

Pruébelo en línea - (todos los casos de prueba)

Sin golf:

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

Algún crédito de golf a @Copper , usando algunos consejos de su código

PowerShell v2 + v3 +, de 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

_{Tachado 144 se parece un poco a 144?}

Toma información $args[0]y sortla guarda, la almacena $n. Luego, whiletodavía quedan elementos, evaluamos un if/ else.

Si el primer elemento (temperatura almacenada $xpara guardar algunos bytes) coincide con el tercer elemento, tenemos un triple. Agregue a $sum el resultado de alguna multiplicación 100*$xmás un booleano 900solo si $xes -equal 1. Esto nos da el requisito 1000para tres. Luego, retire los primeros dos elementos en $a, y $b, y el resto en $n- la eliminación del tercer elemento del triple se maneja más tarde.

De lo contrario, no tenemos un triple, así que agregue a $sum el resultado de otra adición basada en Boole. Agregamos 50si $xes uno 1o 5, luego agregamos otro 50si es -eqnormal 1. Esta sección ahora requiere v3 + para el -inoperador.

En cualquier caso, todavía tenemos un elemento que eliminar, así que retire el primer elemento $ay deje el resto $n.

Finalmente, una vez que finalice el bucle, colóquelo $sen la tubería. La salida es implícita Write-Outputal final de la ejecución.

Casos de prueba

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

Ordena y stringifica la entrada para que las combinaciones de puntuación se puedan identificar mediante regexp. Editar: guardado 1 byte gracias a @Arnauld.

Python 2 o 3, 123 122 121 116 109 108 104 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))))

Los casos de prueba están en ideona

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

Rubí, 80 78 bytes

Pruébalo en línea!

-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

Esto no es un desafío para Haskell. También estoy jugando al golf.

Gracias 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 prueba:

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 es una expresión lambda; para usarlo, asígnelo anteponiendo f=.

Primero buscamos triples dos veces (usando el módulo), eliminando los triples a medida que avanzamos; entonces simplemente agregamos los recuentos de5 y1 al puntaje y lo devolvemos.

Pruébalo en Ideone!(con todos los casos de prueba)

Aquí está mi presentación anterior de 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

¡Ahorré un byte en la solución Python 2 gracias 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

Quería hacerlo todo en sed, pero la adición es realmente difícil ...

Explicación:

1. Encuentre un triplete, agregue 00al primer número y elimine el otro,
   por ejemplo, 1 2 1 3 1 4->100 2 3 4
2. Repita el paso 1 en caso de que haya dos triples.
3. Reemplace 10con 1luego 1con, 100
   por ejemplo, 100-> 10-> 1000o 1-> 1->100
4. Reemplazar cada 5no seguido de 0con50
5. Eliminar cualquier número que no termine en 0
6. Reemplazar grupos de espacios con +
7. Eliminar los +s iniciales y finales
8. Si la cadena está vacía, agregue un 0
9. Por último, canalizar para bcagregar todo.

Perl, 69 bytes

Incluye +2 para -ap

Ejecutar con la entrada en 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);}}

Pruébalo en línea!

Siento que me estoy perdiendo muchas, muchas optimizaciones posibles aquí, pero yo hice guardar un byte multiplicando por 10 al final. La entrada debe pasarse como argumentos de línea 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

Pruébalo en línea!