Yahtzee是一款带有五个六面骰子和一个计分表的游戏，其中有13个不同的盒子来填充得分。每个盒子都有自己的计分规则：

• 1s，2s，3s，4s，5s，6s的所有得分均等于相应骰子的总和（即，以3s得分的[3，2，3，1，5]一卷将获得6分：3每3）。
• 同类3个和同类4个（听起来很像，三个或四个骰子滚动相同）的得分点等于所有五个骰子的总和。
• 满屋（两个骰子显示一个值，其他三个显示另一个值）得分25分
• 小笔直（四个连续的值）得分30分
• 大笔直（所有连续值）得分40点
• Yahtzee（所有骰子都显示相同的值）得分50分

第十三（机会）在游戏中很有意义，但对这个挑战而言意义不大；此外，游戏还有额外的Yahtzees奖励，在这里没有意义。因为挑战是...

给定五个骰子作为输入（五个整数1-6，但是输入很方便，可以假设输入始终有效），输出该“手”可能的最高分。出于挑战的目的，只有上面列表中的评分方法有效（特别是，机会不是此挑战的有效得分框）。分数应以其十进制数值输出，无论是整数还是字符串表示形式。应该立即将其识别为数字。前导/尾随空格很好，这是关于获得分数而不是表示。

编码高尔夫，这样，使用给定语言的字节最少的答案就可以获胜。禁止出现标准漏洞。

测试用例

（请注意，这些都是独立的，面临的挑战是取得一个骰子的“手”）：

in: 1 5 4 3 2
out: 40
in: 1 1 4 3 1
out: 10
in: 2 2 6 5 3
out: 6
in: 2 4 2 4 6
out: 8
in: 1 1 1 1 1
out: 50
in: 5 2 5 3 6
out: 10
in: 1 6 3 4 2
out: 30
in: 1 3 1 1 3
out: 25
in: 6 5 5 6 6
out: 28
in: 1 2 3 5 6
out: 6

R，146141字节

function(d)max(unique(d<-sort(d))*(g=table(d)),any(g>2)*sum(d),all(2:3%in%g)*25,(s=sum((R=diff(d))==1))<4&all(R<2)*30,(s>3)*40,(0==sd(d))*50)

在线尝试！

远远超出了Plannapus

将输入作为列表，并返回分数。

松散一点：

function(d){
 d <- sort(d)
 u <- unique(d)                  # unique dice
 g <- table(d)                   # table of counts
 Ns <- u*g                       # scores as 1s, 2s, ... etc.
 NKind <- any(g>2)*sum(d)        # 3 or 4 of a kind if any counts are at least 3
 FHouse <- all(2:3%in%g)*25      # full house is 25 if 2 & 3 are in counts
 R <- diff(d)                    # consecutive differences
 s <- sum(R==1)                  # sum of differences equal to 1
 sStraight <- s<4 &              # if the number of 1s is 3 and
               all(R<2)*30       # no consecutive numbers are 2 apart
 bStraight <- (s>3)*40           # all 1s means big straight
 Yahtzee <- sd(d)==0             # sd = 0 means all are equal
 max(Ns,NKind,FHouse,sStraight,bStraight,Yahtzee)
}

Python 2中，187个 184 167 165字节

-17字节由于@mypetlion
-2由于字节@chrstphrchvz

def f(d):r=range(1,7);c=d.count;m=map(c,r);s=`m`[1::3];return max([i*c(i)for i in r]+[sum(d)*(max(m)>2),25*(set(m)>{2,3}),30*(4*'1'in s),40*(5*'1'in s),50*(5 in m)])

在线尝试！

R，136134字节

function(n,y=table(factor(n,1:6)),z=sum(!diff(diff(sort(n)))))max(1:6*y,c(25,sum(n),10*3:5)[c(all(y<4&y-1),any(y>2),z>1,z>2,any(y>4))])

Golfed下降2个字节感谢@Giuseppe！

缩进

function(n, #vector of die scores
         y=table(factor(n,1:6)), #Contingency table
         z=sum(!diff(diff(sort(n))))) #Diff of diff of ordered scores
    max(1:6*y,
        c(25,sum(n),10*3:5)*c(all(y<4&y-1), #Full house
                            any(y>2), #3 and 4 of a kind
                            z>1, #Small straight
                            z>2, #Long straight
                            any(y>4))] #Yahtzee

一些测试用例：

> f=function(n,y=table(factor(n,1:6)),z=sum(!diff(diff(sort(n)))))max(1:6*y,c(25,sum(n),10*3:5)*c(all(y<4&y-1),any(y>2),z>1,z>2,any(y>4)))
> f(c(2,4,2,4,6))
[1] 8
> f(c(1,2,3,5,6))
[1] 6
> f(c(6,5,5,6,6))
[1] 28
> f(c(6,5,3,1,4))
[1] 30
> f(c(6,5,3,2,4))
[1] 40

批处理，359字节

@echo off
set/at=s=m=r1=r2=r3=r4=r5=r6=0
for %%r in (%*)do set/a"m+=!(m-r%%r),r%%r+=1,t+=%%r,p=s-r%%r*%%r,p&=p>>9,s-=p
goto %m%
:1
if %r1% neq %r6% set s=40&goto g
:2
set/at=r3*r4*(r2*(r1+r5)+r5*r6)
if %t% gtr 0 set s=30
goto g
:3
set/a"s=r1^r2^r3^r4^r5^r6"
if %s%==1 if %t% lss 25 set s=25&goto g
:4
set/as=t
goto g
:5
set s=50
:g
echo %s%

说明：

@echo off
set/at=s=m=r1=r2=r3=r4=r5=r6=0
for %%r in (%*)do set/a"m+=!(m-r%%r),r%%r+=1,t+=%%r,p=s-r%%r*%%r,p&=p>>9,s-=p
goto %m%

计算每个数字的骰子数量，再加上最大值，再加上所有骰子的总数，再加上相同数字的最高骰子总数。

:1
if %r1% neq %r6% set s=40&goto g

如果所有骰子都不相同，则可能是长直牌，但必须为no 1或no 6。

:2
set/at=r3*r4*(r2*(r1+r5)+r5*r6)
if %t% gtr 0 set s=30
goto g

否则，或者如果最多两个骰子相同，那么这可能仍然是短直。必须至少有a 3和a 4以及其他四个数字的组合。

:3
set/a"s=r1^r2^r3^r4^r5^r6"
if %s%==1 set s=25&goto g

如果有三个相同的骰子，请检查是否已满座3^2==1。但是，有些满堂红（例如6s和5s）得分为3分。

:4
set/as=t
goto g

否则，或者如果有四个相同，则对总分进行评分。

:5
set s=50

如果有五个相同，那么Yahtzee！

:g
echo %s%

输出最佳分数。

果冻，58字节

ċЀ`Ṁ>2ȧS
ṢI=1Ạµ-ƤẸ,E;ṢI$E$;⁸Lƙ`Ṣ⁼2,3¤a3,5,4,2.Ṁ×⁵»Ç»Sƙ`Ṁ$

在线尝试！

Perl 6、159字节

->\b{max map {$_(b)},|(1..6).map({*{$_}*$_}),{.kxxv.sum*?.values.grep(*>2)},{25*(6==[*]
.values)},30*?*{3&4&(1&2|2&5|5&6)},40*?*{2&3&4&5&(1|6)},50*(*.keys==1)}

在线尝试！

由于可以“无论如何方便”都可以接受输入，因此我的函数将其作为Bag类的实例，该类是一个具有多重性的容器。A Bag也是一个关联容器；$bag{$key}返回$key袋子中发生的次数。

该函数的大部分只是评估每个Yahtzee手牌的函数列表，如果该手牌的条件不满足，则返回该手牌的得分或返回零。

• |(1..6).map({ *{$_} * $_ })是六个功能的列表，这些功能根据数字1-6的重复运行来评估手牌。领导者|将此列表平整为周围的列表。
• {.kxxv.sum * ?.values.grep(* > 2) }评估3种和4种手。 .kxxv在a上Bag返回以每个人的多重性重复的键，恢复原始.sum的骰子列表，当然还有骰子的总和。该总和乘以一个布尔值（?），如果袋子.values（即多重性）的值大于2 ，则为true 。
• { 25 * (6 == [*] .values) }评估满手牌。25乘以布尔值，如果乘积的乘积为6，则布尔值为true，这对于五个骰子仅在一个为3且另一个为2时才会发生。
• 30 * ?*{ 3 & 4 & (1 & 2 | 2 & 5 | 5 & 6) }评估小直手。这是一个WhateverCode功能；第二颗星*是Bag。大括号之间的表达式是值3和4以及1和2或2和5或5和6的连接点。在Bag结果中查找此连接点将得到对应的多重性的连接点。如果3和4的多元性，1和2或2和5或5和6中的至少一个非零，则在强制为布尔值（带有?）时，结点为true ，并且此布尔值乘以30得到分数。
• 40 * ?*{ 2 & 3 & 4 & 5 & (1 | 6) }同样评估大笔直牌。这比较简单，因为骰子必须包含数字2-5和1或6。
• 50 * (*.keys == 1)评估Yahtzee手。它只是布尔值的50倍，如果不同骰子的数量为1，则为true。

点，65 63字节

n:_NgM\,6MXn*\,6AL[2<MXn23=JSNn3<Y#MX Jn^0MXn=5]*[$+g25--y*t50]

将骰子作为五个命令行参数。在线尝试！

脱节+说明

（这是原始版本。）

                    g is list of cmdline args; t is 10 (implicit)

Y                   Yank into y:
  _Ng                function that counts occurrences of its argument in g
 M                   mapped to
  \,6                inclusive range from 1 to 6
                    This gives us how many dice are showing each number 1-6

s:                  Assign to s:
  # MX               length of max of
      Jy ^ 0         join y into string and split on zeros
                    This gives us the length of the longest straight

MX                  Max of
   y * \,6           each die frequency in y, times its value
 AL                  to which list append
   [                 this list:
                      3- and 4-of-a-kind:
    MXy > 2 & $+g      If max frequency is 3 or more, sum of g (else 0)
                      Full house:
    23 = J SNy & 25    Sort y and join into string; if it's 000023, 25 (else 0)
                      Straights:
    s > 3 & --s*t      If s is 4 or more, (s-1)*10 (else 0)
                      Yahtzee:
    MXy = 5 & 50       If max frequency is 5, 50 (else 0)
   ]
                    The result of the last expression is autoprinted

红宝石，184字节

完整程序。为了更容易测试输入，请添加$/=' '在顶部以“用空格分隔的数字”格式阅读。（191个字符）

a=$<.map &:to_i
b=a.|c=[]
d=(1..6).map{|x|e=a.count x
c<<x*e
e}
e=a.sum
p !b[1]?50:b[4]&&!(a&[1,6])[1]?40:(1..3).any?{|x|(a&[*x..x+3])[3]}?30:(d-[0,2,3])[0]?d.max>2?e:c.max: [25,e].max

我设定了突破200个字节的屏障，然后轻松地用剩下的十二个字节销毁了它！

在线尝试！

说明

虽然不是很好。希望你有一些Ruby的知识〜

a=$<.map &:to_i # a: input as [number]*5
b=a.|c=[]       # c: [], b: a.uniq
d=(1..6).map{|x|
    e=a.count x # e: occurrence count in a 
    c<<x*e      # add (number * occurrence count) to c
    e           # return value in d
}
e=a.sum         # e: sum of input
p !b[1] ? 50 :  #   condition to print 50 <= if a.uniq has length 0 (el 1 is nil)
  b[4] &&       #   condition to print 40 <= if a.uniq has length 5 (el 4 exists)
  !(a&[1,6])[1] ? 40 : # <- arr & [mask]  # and a does not have both 1 and 6
  (1..3).any?{|x| # condition to print 30 <= if any of 1..4, 2..5, 3..6
  (a&[*x..x+3])[3]} ? 30 : # [3] to assert entire mask is found in a
  (d-[0,2,3])[0] ? # if, after removing 0 (not found) 2 (a pair) 3 (a triple)
                   # and something is found, this is not full house
  d.max > 2 ?   # is triple / quadruple ?
     e :        # weakly dominating alternatives
     c.max      # choose best by-suit
  : [25,e].max  # choose best by-score