introduction

Dice 10,000 est un jeu de dés qui peut être joué avec 6 dés et quelque chose à écrire. Les joueurs lancent les dés plusieurs fois par tour et gagnent un score à la fin de celui-ci. Le joueur qui atteint 10 000 points en premier gagne la partie. Calculer le score d'un rouleau est votre travail dans ce défi.
Regardez ici pour les règles complètes.
Veuillez noter que les règles (en particulier le score) changent d'une région à l'autre car le jeu est largement connu. Nous utilisons les règles décrites ci-dessous.

Le défi

Étant donné une liste de six nombres de un à six représentant un lancer de dés, sortez leur score. Le score est calculé de la manière suivante:

• On compte 100 points
• Fives compte 50 points
• Les triplés comptent leur nombre multiplié par 100 points. Trois doubles donnent par exemple 200 points. Une exception sont trois qui comptent 1000 points.
• Six du même nombre comptent comme deux triplets comme décrit ci-dessus. Donc six trois donnent 600 points. Il en va de même pour le cas de bord avec ceux: Six ceux sont 2000 points.
• Un dé ne peut pas être utilisé plus d'une fois. Si un dé fait partie d'un triplet, il ne compte pas pour les autres scores. Les cinq dans un triplet ne comptent pas 50 points en plus des 500 points qu'ils donnent.
• Les triplets sont toujours comptés en premier pour maximiser le score. Donc trois cinq ne comptent jamais pour 150 points. Quatre cinq comptent pour un triplet et un cinq ordinaire, ce qui donne alors 550 points.

Remarques

• L'entrée contiendra toujours six nombres de un à six. Vous ne recevrez aucune entrée invalide.
• Les numéros peuvent être dans n'importe quel ordre. Vous ne pouvez assumer aucune commande spécifique.

Règles

• Le format d'entrée dépend de vous tant qu'il n'est pas prétraité.
• Fonction ou programme complet autorisé.
• Règles par défaut pour les entrées / sorties.
• Des échappatoires standard s'appliquent.
• Il s'agit de code-golf , donc le nombre d'octets le plus bas l'emporte. Tiebreaker est une soumission antérieure.

Cas de 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 octets

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

Explication

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

Essayez-le en ligne

Python 2, 152 148 125 octets

Solution assez simple. Peut être joué au golf plus. L.countest un peu long, mais je n'ai pas pu supprimer le premier appel car L est mis à jour.

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)

Essayez-le en ligne - (tous les cas de test)

Non 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

Un crédit de golf à @Copper , en utilisant quelques conseils de son code

PowerShell v2 + v3 +, 147 144 137 133 octets

$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

_{Barré 144 ressemble un peu à 144?}

Prend l'entrée $args[0]et la sortstocke $n. Ensuite, whileil reste des éléments, nous évaluons un if/ else.

Si le premier élément (temp stocké dans $xpour sauvegarder quelques octets) correspond au troisième élément, nous avons un triple. Ajouter sur le$s um le résultat d'une multiplication 100*$xplus un booléen 900uniquement si $xc'est -equal 1. Cela nous donne le nécessaire 1000pour trois. Ensuite, décollez les deux premiers éléments dans $a, et $b, et le reste dans $n- la suppression du troisième élément du triple est traitée plus tard.

Sinon, nous n'avons pas de triple, alors ajoutez $s résultat d'un autre ajout basé sur les booléens. Nous ajoutons 50si $xest l'un 1ou l' autre 5, puis en ajoutons un autre 50si cela est -equtile 1. Cette section nécessite désormais la v3 + pour l' -inopérateur.

Dans les deux cas, nous avons encore un élément à supprimer, alors décollez le premier élément $aet laissez le reste $n.

Enfin, une fois la boucle terminée, placez-la $ssur le pipeline. La sortie est un implicite Write-Outputà la fin de l'exécution.

Cas de 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 octets

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

Trie et stringifie l'entrée afin que les combinaisons de notation puissent être identifiées au moyen de l'expression rationnelle. Edit: 1 octet enregistré grâce à @Arnauld.

Python 2 ou 3, 123 122 121 116 109 108 104 104 102 100 97 octets

Python 2, 97 octets

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

Les cas de test sont sur idéone

Python 3, 97 octets

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

Rubis, 80 78 octets

Essayez-le en ligne!

-2 octets 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 octets

Ce n'est pas un défi pour Haskell. Je joue aussi au golf.

Merci à @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 octets

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

Cas de 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 octets

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)

Il s'agit d'une expression lambda; pour l'utiliser, affectez-le en ajoutant f=.

Nous vérifions d'abord les triplets deux fois (en utilisant le module), en supprimant les triplets au fur et à mesure; puis nous ajoutons simplement les nombres de 5et 1au score et le renvoyons.

Essayez-le sur Ideone! (avec tous les cas de test)

Voici mon ancienne soumission Python 2:

Python 2, 176 172 172 171 145 136 134 133 octets

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

Sauvegardé un octet sur la solution Python 2 grâce à @ 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

Je voulais tout faire en sed, mais l'addition est vraiment difficile ...

Explication:

1. Trouver un triplet, ajouter 00au premier numéro et supprimer l'autre
   par exemple 1 2 1 3 1 4->100 2 3 4
2. Répétez l'étape 1 au cas où il y aurait deux triplets
3. Remplacez 10par 1puis 1par 100
   exemple 100-> 10-> 1000ou1 -> 1->100
4. Remplacer chacun 5non suivi par0 des50
5. Supprimez tout nombre qui ne se termine pas par 0
6. Remplacer des groupes d'espaces par +
7. Supprimer le début et la fin + s de
8. Si la chaîne est vide, ajoutez un 0
9. Enfin pipe à bctout additionner.

Perl, 69 octets

Comprend +2 pour -ap

Exécutez avec l'entrée sur 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 octets

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

Essayez-le en ligne!

Je sens que je me manque beaucoup, beaucoup d' optimisations potentielles, mais je l'ai fait , sauf un octet en multipliant par 10 à la fin. L'entrée doit être passée sous forme d'arguments de ligne de commande distincts.

Perl 5 -ap , 78 octets

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

Essayez-le en ligne!