Einführung

Dice 10,000 ist ein Würfelspiel, das mit 6 Würfeln und etwas zum Schreiben gespielt werden kann. Die Spieler würfeln mehrmals pro Runde und erhalten am Ende eine Punktzahl. Der Spieler, der zuerst 10.000 Punkte erreicht, gewinnt das Spiel. Die Punktzahl eines Wurfs zu berechnen, ist Ihre Aufgabe bei dieser Herausforderung.
Hier finden Sie die vollständigen Regeln.
Bitte beachten Sie, dass sich die Regeln (insbesondere die Wertung) von Region zu Region ändern, da das Spiel allgemein bekannt ist. Wir verwenden die unten beschriebenen Regeln.

Die Herausforderung

Geben Sie bei einer Liste von sechs Zahlen von eins bis sechs, die einen Würfelwurf darstellen, deren Punktzahl aus. Die Punktzahl wird folgendermaßen berechnet:

• Einer zählt 100 Punkte
• Fives zählt 50 Punkte
• Drillinge zählen die Anzahl mal 100 Punkte. Drei Zweien zum Beispiel ergeben 200 Punkte. Eine Ausnahme sind drei, die 1000 Punkte zählen.
• Sechs gleiche Zahlen zählen wie zwei Drillinge, wie oben beschrieben. Sechs Dreien ergeben also 600 Punkte. Gleiches gilt für den Edge-Fall mit denen: Sechs sind 2.000 Punkte.
• Ein Würfel kann nur einmal verwendet werden. Wenn ein Würfel Teil eines Drillings ist, zählt er nicht für andere Bewertungen. Die Fünfer in einem Triplett zählen nicht 50 Punkte zusätzlich zu den 500 Punkten, die sie geben.
• Dreiergruppen werden immer zuerst gezählt, um die Punktzahl zu maximieren. Drei Fünfer zählen also nie als 150 Punkte. Vier Fünfer zählen als ein Triplett und ein gewöhnliches Fünfer, was dann 550 Punkte ergibt.

Anmerkungen

• Die Eingabe enthält immer sechs Zahlen von eins bis sechs. Sie erhalten keine ungültigen Eingaben.
• Die Nummern können in beliebiger Reihenfolge sein. Sie dürfen keine bestimmte Bestellung annehmen.

Regeln

• Das Eingabeformat bleibt Ihnen überlassen, solange es nicht vorverarbeitet wurde.
• Funktion oder Vollprogramm erlaubt.
• Standardregeln für die Eingabe / Ausgabe.
• Es gelten Standardlücken .
• Dies ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl. Tiebreaker ist eine frühere Vorlage.

Testfälle

[1, 2, 3, 4, 5, 6] -> 150
[1, 1, 1, 2, 3, 5] -> 1050
[1, 1, 1, 1, 1] -> 2000
[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

Erläuterung

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

Probieren Sie es online aus

Python 2, 152 148 125 Bytes

Ziemlich einfache Lösung. Kann mehr golfen werden. L.countist ein bisschen lang, aber ich konnte den ersten Anruf nicht entfernen, da L aktualisiert wird.

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)

Online ausprobieren - (alle Testfälle)

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

Etwas Golfguthaben an @Copper , unter Verwendung einiger Tipps aus seinem Code

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

_{Durchgestrichen 144 sieht irgendwie aus wie 144?}

Nimmt Eingaben auf $args[0]und sortspeichert sie $n. Dann whilesind noch Elemente übrig, wir werten ein if/ aus else.

Wenn das erste Element (temporär gespeichert $x, um einige Bytes zu speichern) mit dem dritten Element übereinstimmt, haben wir ein Tripel. In auf das $sum das Ergebnis einer Multiplikation 100*$xplus ein Boolean-basierte 900nur , wenn $xist -equal zu 1. Damit haben wir die Voraussetzung 1000für drei. Ziehen Sie dann die ersten beiden Elemente in $aund ab $b, und das verbleibende in $n- Entfernen des dritten Elements des Tripels wird später behandelt.

Ansonsten haben wir kein Triple, also addiere es zu $sdem Ergebnis einer anderen Booleschen Addition. Wir fügen hinzu, 50wenn $xentweder 1oder ist 5, und fügen dann eine weitere hinzu, 50wenn dies der -eqFall ist 1. Dieser Abschnitt erfordert jetzt v3 + für den -inBediener.

In beiden Fällen muss noch ein Element entfernt werden. Ziehen Sie also das erste Element ab $aund lassen Sie das verbleibende Element darin $n.

Sobald die Schleife fertig ist, platzieren Sie sie $sin der Pipeline. Die Ausgabe erfolgt implizit Write-Outputam Ende der Ausführung.

Testfälle

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

Sortiert und stringifiziert die Eingabe, sodass Bewertungskombinationen mithilfe von regulären Ausdrücken identifiziert werden können. Bearbeiten: 1 Byte dank @Arnauld gespeichert.

Python 2 oder 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))))

Testfälle sind auf 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

Probieren Sie es online!

-2 Byte von @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

Dies ist keine Herausforderung für Haskell. Ich spiele auch Golf.

Vielen Dank an @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

Testfälle:

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)

Dies ist ein Lambda-Ausdruck; Um es zu verwenden, weisen Sie es zu, indem Sie es voranstellen f=.

Wir prüfen zuerst zweimal nach Tripeln (indem wir den Modul verwenden) und entfernen dabei die Tripel. dann addieren wir einfach die Zählwerte von 5und 1zur Punktzahl und geben sie zurück.

Probieren Sie es auf Ideone! (mit allen Testfällen)

Hier ist meine ältere Python 2-Einsendung:

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

Dank @ mbomb007 wurde ein Byte in der Python 2-Lösung gespeichert!

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

Ich wollte alles in sed machen, aber das Hinzufügen ist wirklich schwer ...

Erläuterung:

1. Finde ein Triplett, addiere 00die erste Zahl und entferne die andere,
   zB 1 2 1 3 1 4->100 2 3 4
2. Wiederholen Sie Schritt 1, falls es zwei Tripel gibt
3. Ersetzen Sie 10mit 1dann 1mit 100
   zB 100-> 10-> 1000oder 1-> 1->100
4. Ersetzen Sie jeweils 5nicht gefolgt von 0mit50
5. Entfernen Sie alle Zahlen, die nicht auf enden 0
6. Ersetzen Sie Gruppen von Leerzeichen durch +
7. Führende und nachfolgende +s entfernen
8. Wenn die Zeichenfolge leer ist, fügen Sie a hinzu 0
9. Zum Schluss die Pfeife drücken, bcum alles zu addieren.

Perl, 69 Bytes

Beinhaltet +2 für -ap

Führen Sie mit der Eingabe auf STDIN aus:

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

Probieren Sie es online!

Ich habe das Gefühl, dass ich hier viele, viele mögliche Optimierungen verpasse, aber ich habe ein Byte gespart, indem ich am Ende mit 10 multipliziert habe. Die Eingabe sollte als separate Befehlszeilenargumente übergeben werden.

Perl 5 -ap , 78 Bytes

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

Probieren Sie es online!