Wprowadzenie

Dice 10,000 to gra w kości, w którą można grać za pomocą 6 kości i czegoś do napisania. Gracze rzucają kostką wiele razy na turę i na końcu zdobywają wynik. Gracz, który jako pierwszy osiągnie 10 000 punktów, wygrywa. Obliczanie wyniku jednego rzutu jest Twoim zadaniem w tym wyzwaniu.
Zajrzyj tutaj, aby zobaczyć pełne zasady.
Należy pamiętać, że zasady (zwłaszcza punktacja) zmieniają się w zależności od regionu, ponieważ gra jest powszechnie znana. Korzystamy z zasad opisanych poniżej.

Wyzwanie

Biorąc pod uwagę listę sześciu liczb od jednego do sześciu reprezentujących rzut kostką, wypisz ich wynik. Wynik obliczany jest w następujący sposób:

• Jeden liczy 100 punktów
• Piątki liczą 50 punktów
• Trojaczki liczą ich liczbę razy 100 punktów. Na przykład trzy dwójki dają 200 punktów. Wyjątkiem są trzy, które liczą 1000 punktów.
• Sześć tej samej liczby liczy się jak dwie trojaczki, jak opisano powyżej. Tak więc sześć trójek daje 600 punktów. To samo dotyczy przypadku na krawędzi: sześć z nich to 2000 punktów.
• Jedna kość nie może być użyta więcej niż raz. Jeśli kość jest częścią trypletu, nie liczy się dla innych wyników. Piątki w trojaczce nie liczą 50 punktów oprócz 500 punktów, które dają.
• Trójki są zawsze liczone jako pierwsze, aby zmaksymalizować wynik. Tak więc trzy piątki nigdy nie są liczone jako 150 punktów. Cztery piątki liczone są jako jedna trojaczka i jedna zwykła pięć, co daje następnie 550 punktów.

Notatki

• Dane wejściowe zawsze będą zawierać sześć liczb od jednego do sześciu. Nie otrzymasz nieprawidłowych danych wejściowych.
• Liczby mogą być w dowolnej kolejności. Nie możesz zakładać żadnego konkretnego zamówienia.

Zasady

• Format wejściowy zależy od Ciebie, o ile nie jest wstępnie przetworzony.
• Dozwolona funkcja lub pełny program.
• Domyślne reguły wejścia / wyjścia.
• Obowiązują standardowe luki .
• To jest golf golfowy , więc wygrywa najmniej bajtów. Tiebreaker to wcześniejsze zgłoszenie.

Przypadki testowe

[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 bajtów

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

Wyjaśnienie

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

Wypróbuj online

Python 2, 152 148 125 bajtów

Całkiem proste rozwiązanie. Można grać w golfa więcej. L.countjest trochę długi, ale nie mogłem usunąć pierwszego połączenia, ponieważ L został zaktualizowany.

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)

Wypróbuj online - (wszystkie przypadki testowe)

Nie golfowany:

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

Trochę kredytu golfowego dla @Copper , korzystając z kilku wskazówek z jego kodu

PowerShell v2 + v3 +, 147 144 137 133 bajtów

$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

_{Przekreślony 144 wygląda trochę jak 144?}

Pobiera dane wejściowe $args[0]i sortzapisuje je w $n. Następnie whilepozostały jeszcze elementy, oceniamy if/else .

Jeśli pierwszy element (temp zapisany w $xcelu zapisania niektórych bajtów) pasuje do trzeciego elementu, mamy potrójny. Dodaj do $sum wynik mnożenia 100*$xplus wartość logiczną 900tylko, jeśli $xjest to -eqprzydatne 1. To zapewnia nam niezbędność 1000trzech. Następnie oderwij pierwsze dwa elementy do $a, a $bpozostałe do $n- usunięcie trzeciego elementu potrójnego zajmie się później.

W przeciwnym razie nie mamy potrójnego, więc dodaj do $sum wynik innego dodania opartego na logice. Dodajemy, 50jeśli $xjest albo, 1lub 5dodajemy, 50jeśli jest to -eqprzydatne 1. Ta sekcja wymaga teraz v3 + dla -inoperatora.

W obu przypadkach nadal mamy element do usunięcia, więc odklej pierwszy element $ai pozostaw resztę w $n.

Na koniec, po zakończeniu pętli, umieść $sna rurociągu. Dane wyjściowe są niejawne Write-Outputna końcu wykonania.

Przypadki testowe

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 bajtów

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

Sortuje i uszeregowuje dane wejściowe, dzięki czemu kombinacje oceniania można zidentyfikować za pomocą wyrażenia regularnego. Edycja: Zapisano 1 bajt dzięki @Arnauld.

Python 2 lub 3, 123 122 121 116 109 108 104 102 100 97 bajtów

Python 2, 97 bajtów

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

Przypadki testowe są na ideone

Python 3, 97 bajtów

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

Rubinowy, 80 78 bajtów

Wypróbuj online!

-2 bajt od @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 bajtów

To nie jest wyzwanie dla Haskell. Też gram w golfa.

Dzięki @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 bajtów

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

Przypadki testowe:

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 bajtów

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)

To jest wyrażenie lambda; aby go użyć, przypisz go, przygotowując f=.

Najpierw sprawdzamy trzykrotnie dwukrotnie (używając modułu), usuwając je w miarę upływu czasu; następnie po prostu dodajemy liczby5 i 1do wyniku i go.

Wypróbuj na Ideone!(ze wszystkimi przypadkami testowymi)

Oto moje starsze zgłoszenie do Python 2:

Python 2, 176 172 171 145 136 134 133 bajtów

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

Oszczędność bajtu w rozwiązaniu Python 2 dzięki @ 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

Chciałem to zrobić w całości, ale dodawanie jest naprawdę trudne ...

Wyjaśnienie:

1. Znajdź trojaczkę, dodaj 00do pierwszego numeru i usuń drugi,
   np. 1 2 1 3 1 4->100 2 3 4
2. Powtórz krok 1, ponieważ istnieją dwie potrójne
3. Wymień 10się 1następnie 1z 100
   np 100-> 10-> 1000lub 1-> 1->100
4. Wymienić każdy 5nie następuje 0z50
5. Usuń dowolny numer, który się nie kończy 0
6. Zamień grupy spacji na +
7. Usuń wiodące i końcowe +s
8. Jeśli ciąg jest pusty, dodaj 0
9. Wreszcie potok, aby bcdodać wszystko.

Perl, 69 bajtów

Obejmuje +2 za -ap

Uruchom z wejściem na 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 bajtów

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

Wypróbuj online!

Czuję się jakbym brakuje wiele, wiele potencjalnych optymalizacje tutaj, ale nie zapisać bajt przez pomnożenie przez 10 na końcu. Dane wejściowe należy przekazywać jako osobne argumenty wiersza poleceń.

Perl 5 -ap , 78 bajtów

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

Wypróbuj online!