Giới thiệu

Dice 10.000 là một trò chơi súc sắc có thể chơi với 6 con xúc xắc và một cái gì đó để viết. Người chơi lắc xí ngầu nhiều lần trong một lượt và giành được điểm ở cuối của nó. Người chơi đạt 10.000 điểm đầu tiên sẽ thắng trò chơi. Tính điểm của một cuộn là công việc của bạn trong thử thách này.
Nhìn vào đây cho các quy tắc đầy đủ.
Xin lưu ý rằng các quy tắc (đặc biệt là tính điểm) thay đổi từ vùng này sang vùng khác kể từ khi trò chơi được biết đến rộng rãi. Chúng tôi sử dụng các quy tắc được giải thích dưới đây.

Các thách thức

Đưa ra một danh sách sáu số từ một đến sáu đại diện cho một con súc sắc, xuất ra điểm số của chúng. Điểm số được tính theo cách follwing:

• Những người được tính 100 điểm
• Số mệnh tính 50 điểm
• Bộ ba đếm số lần của họ 100 điểm. Ba twos ví dụ cho 200 điểm. Một ngoại lệ là ba cái được tính 1000 điểm.
• Sáu số giống nhau được tính như hai bộ ba như mô tả ở trên. Vì vậy, sáu phần ba cho 600 điểm. Điều tương tự cũng xảy ra đối với trường hợp cạnh với những người: Sáu người là 2.000 điểm.
• Một chết không thể được sử dụng nhiều hơn một lần. Nếu một cái chết là một phần của bộ ba, nó không được tính cho các điểm khác. Các cặp vợ chồng trong một bộ ba không được tính 50 điểm ngoài 500 điểm họ cho.
• Bộ ba luôn được tính đầu tiên để tối đa hóa điểm số. Vì vậy, ba fives không bao giờ được tính là 150 điểm. Bốn fives được tính là một bộ ba và một năm bình thường sau đó cho 550 điểm.

Ghi chú

• Đầu vào sẽ luôn chứa sáu số từ một đến sáu. Bạn sẽ không nhận được đầu vào không hợp lệ.
• Các con số có thể theo thứ tự bất kỳ. Bạn có thể không giả định bất kỳ thứ tự cụ thể.

Quy tắc

• Định dạng đầu vào tùy thuộc vào bạn miễn là nó chưa được xử lý trước.
• Chức năng hoặc chương trình đầy đủ cho phép.
• Quy tắc mặc định cho đầu vào / đầu ra.
• Tiêu chuẩn áp dụng.
• Đây là môn đánh gôn , vì vậy, số byte thấp nhất sẽ thắng. Tiebreaker là trình trước đó.

Các trường hợp thử nghiệm

[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

Giải trình

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

Dùng thử trực tuyến

Python 2, 152 148 125 byte

Giải pháp khá đơn giản. Có thể chơi golf nhiều hơn. L.counthơi dài, nhưng tôi không thể xóa cuộc gọi đầu tiên vì L được cập nhật.

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)

Dùng thử trực tuyến - (tất cả các trường hợp thử nghiệm)

Ung dung:

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

Một số tín dụng golf cho @Copper , sử dụng một số mẹo từ mã của anh ấy

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

_{Vượt qua 144 trông giống như 144?}

Đưa đầu vào $args[0]và sorts nó, lưu trữ nó vào $n. Sau đó, whilevẫn còn các yếu tố, chúng tôi đánh giá một if/ else.

Nếu phần tử đầu tiên (temp được lưu trữ $xđể lưu một số byte) khớp với phần tử thứ ba, chúng ta có bộ ba. Thêm vào $sô kết quả của một số phép nhân 100*$xcộng với 900chỉ dựa trên Boolean nếu $xlà -equal to 1. Điều này giúp chúng tôi cần thiết 1000cho ba người. Sau đó, bóc hai yếu tố đầu tiên vào $a, và $b, và số còn lại vào$n - loại bỏ các yếu tố thứ ba của ba được xử lý sau.

Mặt khác, chúng ta không có bộ ba, vì vậy hãy thêm vào $skết quả của một bổ sung dựa trên Boolean khác. Chúng tôi thêm 50nếu $xlà một trong hai 1hoặc 5, sau đó thêm vào một 50nếu nó -equal tới 1. Phần này bây giờ yêu cầu v3 + cho -intoán tử.

Trong cả hai trường hợp, chúng ta vẫn còn một phần tử chưa được loại bỏ, vì vậy hãy bóc phần tử đầu tiên vào $avà bỏ phần còn lại vào $n.

Cuối cùng, một khi vòng lặp được thực hiện, đặt $strên đường ống. Đầu ra là một ẩn Write-Outputở cuối thực hiện.

Các trường hợp thử nghiệm

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

Sắp xếp và xâu chuỗi các đầu vào để có thể xác định các kết hợp ghi điểm bằng phương pháp regrec. Chỉnh sửa: Đã lưu 1 byte nhờ @Arnauld.

Python 2 hoặc 3, 123 122 121 116 109 108 104 102 100 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))))

Các trường hợp thử nghiệm là trên 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

Hãy thử trực tuyến!

-2 byte từ @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

Đây là không phải là một thách thức cho Haskell. Ngoài ra tôi đang chơi golf này.

Cảm ơn @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

Các trường hợp thử nghiệm:

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)

Đây là một biểu thức lambda; để sử dụng nó, chỉ định nó bằng cách trả trước f=.

Trước tiên, chúng tôi kiểm tra bộ ba lần (bằng cách sử dụng mô-đun), loại bỏ bộ ba khi chúng tôi đi; sau đó chúng ta chỉ cần thêm số lượng 5và1 vào điểm số và trả lại.

Hãy thử nó trên Ideone!(với tất cả các trường hợp thử nghiệm)

Đây là bài nộp Python 2 cũ hơn của tôi:

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

Đã lưu một byte trên giải pháp Python 2 nhờ @ 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

Tôi muốn làm tất cả trong sed, nhưng việc bổ sung thực sự khó khăn ...

Giải trình:

1. Tìm một bộ ba, thêm 00vào số đầu tiên và loại bỏ số khác,
   ví dụ 1 2 1 3 1 4->100 2 3 4
2. Lặp lại bước 1 khi có hai bộ ba
3. Thay thế 10bằng 1sau đó 1bằng 100
   ví dụ 100-> 10-> 1000hoặc 1-> 1->100
4. Thay thế từng 5không tiếp theo 0với50
5. Xóa bất kỳ số nào không kết thúc bằng 0
6. Thay thế các nhóm không gian bằng +
7. Di chuyển ở đầu và đuôi +s
8. Nếu chuỗi trống, thêm một 0
9. Cuối cùng ống để bcthêm mọi thứ lên.

Perl, 69 byte

Bao gồm +2 cho -ap

Chạy với đầu vào trên 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);}}

Hãy thử trực tuyến!

Tôi cảm thấy như tôi đang thiếu rất nhiều, nhiều tối ưu hóa tiềm năng ở đây, nhưng tôi đã tiết kiệm được một byte bằng cách nhân 10 ở cuối. Đầu vào phải được thông qua như các đối số dòng lệnh riêng biệt.

Perl 5 -ap , 78 byte

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

Hãy thử trực tuyến!