pengantar

Dice 10.000 adalah permainan dadu yang dapat dimainkan dengan 6 dadu dan sesuatu untuk ditulis. Para pemain melempar dadu beberapa kali secara bergantian dan mendapatkan skor di bagian akhir. Pemain yang mencapai 10.000 poin pertama memenangkan permainan. Menghitung skor satu roll adalah tugas Anda dalam tantangan ini.
Lihat di sini untuk aturan lengkapnya.
Harap perhatikan bahwa aturan (terutama skor) berubah dari satu wilayah ke wilayah lain sejak game ini dikenal luas. Kami menggunakan aturan yang diuraikan di bawah ini.

Tantangan

Diberikan daftar enam angka dari satu hingga enam yang mewakili dadu roll, output skor mereka. Skor dihitung dengan cara berikut:

• Yang dihitung 100 poin
• Lima hitungan 50 poin
• Kembar tiga menghitung jumlah mereka kali 100 poin. Tiga berpasangan misalnya memberi 200 poin. Pengecualian adalah tiga yang menghitung 1000 poin.
• Enam dari jumlah yang sama dihitung seperti dua kembar tiga seperti dijelaskan di atas. Jadi enam bertiga memberi 600 poin. Hal yang sama berlaku untuk kasus tepi dengan yang: Enam yang 2.000 poin.
• Satu mati tidak dapat digunakan lebih dari sekali. Jika dadu adalah bagian dari triplet, dadu tidak dihitung untuk penilaian lainnya. Balita dalam triplet tidak menghitung 50 poin di samping 500 poin yang mereka berikan.
• Tiga kali lipat selalu dihitung pertama untuk memaksimalkan skor. Jadi tiga balita tidak pernah dihitung sebagai 150 poin. Empat balita dihitung sebagai satu triplet dan lima biasa yang kemudian memberikan 550 poin.

Catatan

• Input akan selalu berisi enam angka dari satu hingga enam. Anda tidak akan menerima input yang tidak valid.
• Jumlahnya bisa dalam urutan apa pun. Anda mungkin tidak menerima pesanan khusus apa pun.

Aturan

• Format input terserah Anda selama belum diproses.
• Fungsi atau program lengkap diizinkan.
• Aturan default untuk input / output.
• Celah standar berlaku.
• Ini adalah kode-golf , sehingga byte-count terendah akan menang. Tiebreak adalah pengiriman sebelumnya.

Uji kasus

[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

Penjelasan

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

Cobalah online

Python 2, 152 148 125 byte

Solusi yang cukup sederhana. Dapat bermain golf lebih banyak. L.countagak lama, tapi saya tidak bisa menghapus panggilan pertama karena L diperbarui.

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)

Cobalah online - (semua kasus uji)

Tidak Disatukan:

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

Beberapa kredit golf untuk @Copper , menggunakan beberapa tips dari kode nya

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

_{Dicoret 144 sepertinya 144?}

Mengambil input $args[0]dan memasukkannya sortke dalam $n. Kemudian, whilemasih ada elemen yang tersisa, kita mengevaluasi sebuah if/ else.

Jika elemen pertama (temp disimpan ke dalam $xuntuk menyimpan beberapa byte) cocok dengan elemen ketiga, kami memiliki tiga. Tambahkan ke $sum hasil dari beberapa perkalian 100*$xditambah 900hanya berbasis Boolean jika $xsudah -eqsampai 1. Ini memberi kita syarat 1000untuk tiga orang. Kemudian, lepaskan dua elemen pertama ke dalam $a, dan $b, dan sisanya ke $n- menghapus elemen ketiga dari triple ditangani kemudian.

Jika tidak, kami tidak memiliki triple, jadi tambahkan ke $sum hasil dari penambahan lain yang berbasis Boolean. Kami menambahkan 50jika $xini baik 1atau 5, kemudian tambahkan yang lain 50jika itu -equal untuk 1. Bagian ini sekarang memerlukan v3 + untuk -inoperator.

Dalam kedua kasus tersebut, kami masih memiliki elemen yang belum dihapus, jadi lepaskan elemen pertama ke dalam $adan biarkan sisanya masuk $n.

Akhirnya, setelah loop selesai, letakkan $sdi pipeline. Output adalah implisit Write-Outputpada akhir eksekusi.

Uji kasus

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

Mengurutkan dan merangkai input sehingga kombinasi pemberian skor dapat diidentifikasi dengan cara regexp. Sunting: Disimpan 1 byte berkat @Arnauld.

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

Kasus uji ada di 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))))

Ruby, 80 78 byte

Cobalah online!

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

Ini bukan tantangan bagi Haskell. Saya juga bermain golf ini.

Terima kasih kepada @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

Kasus uji:

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)

Ini adalah ungkapan lambda; untuk menggunakannya, tetapkan dengan menambahkan f=.

Kami pertama kali memeriksa triples dua kali (dengan menggunakan modulus), menghapus tiga kali lipat saat kami pergi; maka kita cukup menambahkan hitungan 5dan 1skor dan mengembalikannya.

Cobalah di Ideone! (dengan semua kasus uji)

Inilah pengajuan Python 2 saya yang lebih lama:

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

Menyimpan byte pada solusi Python 2 berkat @ 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

Saya ingin melakukan semuanya dalam sed, tetapi penambahan itu sangat sulit ...

Penjelasan:

1. Temukan triplet, tambahkan 00ke nomor pertama dan hapus
   mis. Lainnya 1 2 1 3 1 4->100 2 3 4
2. Ulangi langkah 1 jika ada dua kali lipat
3. Ganti 10dengan 1kemudian 1dengan 100
   misalnya 100-> 10-> 1000atau 1-> 1->100
4. Ganti masing 5- masing yang tidak diikuti 0dengan50
5. Hapus nomor apa pun yang tidak berakhir 0
6. Ganti grup ruang dengan +
7. Hapus leading and trailing +s
8. Jika string kosong, tambahkan a 0
9. Terakhir pipa untuk bcmenambahkan semuanya.

Perl, 69 byte

Termasuk +2 untuk -ap

Jalankan dengan input pada 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);}}

Cobalah online!

Saya merasa seperti saya kehilangan banyak, banyak potensi optimasi di sini, tetapi saya memang menyimpan satu byte dengan mengalikannya dengan 10 pada akhirnya. Input harus diberikan sebagai argumen baris perintah terpisah.

Perl 5 -ap , 78 byte

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

Cobalah online!