介绍

骰子10,000是一个骰子游戏，可以玩6个骰子和一些东西来写。玩家每回合多次掷骰子，并在骰子结束时获得分数。首先达到10,000点的玩家将赢得比赛。计算这一卷的分数是您在这项挑战中的工作。
在这里查看完整规则。
请注意，规则（尤其是得分）因地区而异，因为该游戏广为人知。我们使用下面描述的规则。

挑战

给定从一个骰子到六个骰子的六个数字列表，输出它们的分数。分数的计算方法如下：

• 算100分
• 击掌得分50分
• 三元组将其数字乘以100分。例如，三分之二可得200分。有一个例外，那就是三个1000分。
• 如上所述，六个相同数目的数字像两个三胞胎一样计数。因此，六个三分球得出600分。带有1的边缘情况也是如此：六个为2,000点。
• 一个骰子不能使用超过一次。如果骰子是三元组的一部分，则不计入其他得分。在三重含五都不会，除了500分，他们给算50分。
• 为了使得分最大化，始终会首先计算三元组。因此，三分之五绝对不能算作150分。四五分之一被算作三胞胎，一普通五数被算作550分。

笔记

• 输入将始终包含从1到6的六个数字。您将不会收到无效的输入。
• 数字可以是任何顺序。您可能不承担任何特定的订购。

规则

• 输入格式取决于您，只要不进行预处理即可。
• 允许功能或完整程序。
• 输入/输出的默认规则。
• 有标准漏洞。
• 这是代码高尔夫球，因此最低字节数获胜。Tiebreaker是较早提交的内容。

测试用例

[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，4，3，4]-> 700

05AB1E，34 31 30字节

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

说明

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

在线尝试

Python 2中，152个 148 125字节

非常简单的解决方案。可以打更多的高尔夫球。L.count有点长，但由于L已更新，所以我无法删除第一个通话。

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)

在线尝试 -（所有测试用例）

取消高尔夫：

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

使用@Copper的一些技巧，向他提供一些高尔夫信誉

PowerShell的V2 + V3 +，147个 144 137 133字节的

$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

_{划掉144看起来有点像144？}

接受输入$args[0]并将sort其存储到中$n。然后，while还剩下元素，我们求一个if/ else。

如果第一个元素（临时存储到其中$x以保存一些字节）与第三个元素匹配，则我们有一个三元组。添加到$s一些乘法庵结果100*$x加上布尔型900仅$x是-eqUAL来1。这使我们具备1000了三个条件。然后，将前两个元素剥离为$a和$b，然后将剩余的剥离为$n-除去三元组的第三个元素。

否则，我们将没有三元组，因此将$s另一个基于布尔的加法运算的结果相加。我们添加50如果$x要么是1或5，然后在另一个补充50，如果它的-eqUAL来1。现在，此部分要求-in操作员使用v3 + 。

无论哪种情况，我们仍然有一个要删除的元素，因此将第一个元素剥开，$a然后将其余元素保留在中$n。

最后，一旦循环完成，就放置$s在管道上。输出Write-Output在执行结束时是隐式的。

测试用例

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字节

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

对输入进行排序和字符串化，以便可以通过正则表达式识别得分组合。编辑：由于@Arnauld，节省了1个字节。

Python 2或3， 123122121116109109108104102100 97字节

Python 2，97个字节

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

测试用例在ideone上

Python 3，97个字节

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字节

在线尝试！

@ezrast的-2字节。

->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字节

对于Haskell而言，这不是挑战。我也在打高尔夫球。

感谢@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字节

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

测试用例：

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个字节

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)

这是一个lambda表达式；要使用它，请先添加f=。

我们首先两次检查三元组（通过使用模数），然后删除三元组。那么我们只需添加的罪名5和1把比分并返回它。

在Ideone上尝试！（所有测试用例）

这是我较早的Python 2提交内容：

Python 2中，176个 172 171 145 136 134 133字节的

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

感谢@ mbomb007，在Python 2解决方案上节省了一个字节！

重击（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

我本来想在sed中做这件事，但加法真的很难...

说明：

1. 找到一个三元组，添加00到第一个数字，然后删除另一个，
   例如1 2 1 3 1 4->100 2 3 4
2. 如果有两个三元组，请重复步骤1
3. 更换10用1然后1用100
   如100- > 10- > 1000或1- > 1- >100
4. 将每个5未替换的内容替换0为50
5. 删除所有不以结尾的数字 0
6. 将空格组替换为 +
7. 删除前导和尾随 + s
8. 如果字符串为空，请添加一个 0
9. 最后通过管道bc添加所有内容。

Perl，69个字节

包括+2 -ap

使用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核心），228个 227字节

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

在线尝试！

我觉得我在这里错过了很多潜在的优化，但是我确实通过在最后乘以10节省了一个字节。输入应作为单独的命令行参数传递。

Perl -ap 5，78个字节

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

在线尝试！