introduzione

Dice 10.000 è un gioco di dadi che può essere giocato con 6 dadi e qualcosa da scrivere. I giocatori tirano i dadi più volte al turno e ottengono un punteggio alla fine di esso. Il giocatore che raggiunge per primo i 10.000 punti vince la partita. Calcolare il punteggio di un tiro è il tuo compito in questa sfida.
Guarda qui per le regole complete.
Si noti che le regole (in particolare il punteggio) cambiano da regione a regione poiché il gioco è ampiamente noto. Utilizziamo le regole descritte di seguito.

La sfida

Dato un elenco di sei numeri da uno a sei che rappresentano un tiro di dadi, genera il loro punteggio. Il punteggio viene calcolato nel modo seguente:

• Uno conta 100 punti
• Five conta 50 punti
• Le terzine contano il loro numero per 100 punti. Tre due, ad esempio, danno 200 punti. Un'eccezione sono tre che contano 1000 punti.
• Sei dello stesso numero contano come due terzine come descritto sopra. Quindi sei tre danno 600 punti. Lo stesso vale per i casi limite con quelli: sei sono 2.000 punti.
• Un dado non può essere usato più di una volta. Se un dado fa parte di una tripletta, non conta per altri punteggi. I cinque in una tripletta non contano 50 punti in aggiunta ai 500 punti che danno.
• Le triple vengono sempre conteggiate per prime per massimizzare il punteggio. Quindi tre cinque non vengono mai conteggiati come 150 punti. Quattro cinque sono contati come una tripletta e una normale cinque che quindi danno 550 punti.

Appunti

• L'input conterrà sempre sei numeri da uno a sei. Non riceverai input non validi.
• I numeri possono essere in qualsiasi ordine. Non puoi assumere alcun ordine specifico.

Regole

• Il formato di input dipende da te purché non sia preelaborato.
• Funzione o programma completo consentiti.
• Regole predefinite per input / output.
• Si applicano scappatoie standard .
• Questo è code-golf , quindi vince il conteggio dei byte più basso. Tiebreaker è una presentazione precedente.

Casi test

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

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

Spiegazione

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

Provalo online

Python 2, 152 148 125 byte

Soluzione abbastanza semplice. Può essere golfato di più. L.countè un po 'lungo, ma non è stato possibile rimuovere la prima chiamata perché L è stato aggiornato.

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)

Provalo online - (tutti i casi di test)

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

Qualche credito golf a @Copper , usando alcuni consigli dal suo codice

PowerShell v2 + v3 +, 147 144 137 133 byte

$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

_{Barrato 144 sembra un po 'come 144?}

Prende l'input $args[0]e sortlo inserisce, lo memorizza $n. Quindi, whileci sono ancora elementi rimasti, valutiamo un if/ else.

Se il primo elemento (temp memorizzato in $xper salvare alcuni byte) corrisponde al terzo elemento, abbiamo una tripla. Aggiungi su $sum il risultato di una moltiplicazione 100*$xpiù un valore booleano 900solo se $xè -eqnormale 1. Questo ci rende il requisito 1000per tre. Quindi, staccare i primi due elementi in $a, e $b, e il rimanente in $n- la rimozione del terzo elemento del triplo viene gestita in seguito.

Altrimenti, non abbiamo una tripla, quindi aggiungi a $sum il risultato di un'altra aggiunta booleana. Aggiungiamo 50if $xè o 1o 5, quindi aggiungiamo un altro 50se è -eqnormale 1. Questa sezione ora richiede v3 + per l' -inoperatore.

In entrambi i casi, abbiamo ancora un elemento da rimuovere, quindi staccare il primo elemento $ae lasciare il resto $n.

Alla fine, una volta terminato il loop, posizionalo $ssulla pipeline. L'output è implicito Write-Outputalla fine dell'esecuzione.

Casi test

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 byte

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

Ordina e classifica l'input in modo che le combinazioni di punteggio possano essere identificate mediante regexp. Modifica: salvato 1 byte grazie a @Arnauld.

Python 2 o 3, 123 122 121 116 109 108 104 102 100 97 byte

Python 2, 97 byte

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

I casi di test sono su ideone

Python 3, 97 byte

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

Rubino, 80 78 byte

Provalo online!

-2 byte da @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 byte

Questa non è una sfida per Haskell. Anche io sto giocando a golf.

Grazie 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 byte

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

Casi test:

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 byte

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)

Questa è un'espressione lambda; per usarlo, assegnalo anteponendo f=.

Prima controlliamo due volte le triple (usando il modulo), rimuovendole mentre procediamo; quindi aggiungiamo semplicemente i conteggi di 5e 1al punteggio e lo restituiamo.

Provalo su Ideone! (con tutti i casi di test)

Ecco la mia precedente presentazione su Python 2:

Python 2, 176 172 171 145 136 134 133 byte

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

Salvataggio di un byte sulla soluzione Python 2 grazie 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

Volevo fare tutto in sed, ma l'aggiunta è davvero difficile ...

Spiegazione:

1. Trova una tripletta, aggiungi 00il primo numero e rimuovi l'altro,
   ad es. 1 2 1 3 1 4->100 2 3 4
2. Ripetere il passaggio 1 in caso di due triple
3. Sostituire 10con 1quindi 1con 100
   es. 100-> 10->1000 o 1-> 1->100
4. Sostituisci ciascuno 5 non seguito da 0con50
5. Rimuovi qualsiasi numero che non finisca 0
6. Sostituisci gruppi di spazi con +
7. Rimuovi il comando iniziale e finale + s
8. Se la stringa è vuota, aggiungi a 0
9. Infine pipe per bcaggiungere tutto.

Perl, 69 byte

Include +2 per -ap

Esegui con l'input su 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 byte

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

Provalo online!

Mi sento come se mi manca molti, molti potenziali ottimizzazioni qui, ma ho fatto salvare un byte moltiplicando per 10 alla fine. L'input deve essere passato come argomenti della riga di comando separati.

Perl 5 -ap , 78 byte

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

Provalo online!