Yahtzee는 5 개의 6 면체 주사위와 13 개의 다른 상자로 점수를 채울 수있는 점수 표로 플레이하는 게임입니다. 각 상자에는 자체 점수 규칙이 있습니다.

• 1, 2, 3, 4, 5, 6 초의 모든 점수는 해당 주사위의 합과 같습니다 (즉, 3 점으로 점수를 매긴 [3, 2, 3, 1, 5]의 롤은 6 포인트를받습니다 : 3 각 3).
• 3 종 및 4 종 (사운드에 따라 3 개 또는 4 개의 주사위가 동일하게 굴림) 점수는 5 개 주사위의 합과 같습니다.
• 풀 하우스 (2 개의 주사위는 하나의 가치를, 다른 3 개는 다른 가치를 나타냄)
• 작은 직선 (4 개의 연속 값)으로 30 점
• 큰 직선 (모든 연속 값)으로 40 점
• Yahtzee (모든 주사위는 같은 값을 나타냄)

열세 번째 (기회)는 게임 내에서 의미가 있지만이 도전에는 그다지 중요하지 않습니다. 또한 게임에는 추가 Yahtzee에 대한 보너스가 있습니다. 도전은 ...

입력으로 5 개의 주사위가 주어지면 (5 개의 정수 1-6, 입력이 편리하지만 입력이 항상 유효하다고 가정 할 수 있음) 해당 '손'에 대해 가능한 최고 점수를 출력하십시오. 이 챌린지의 목적 상, 위 목록에있는 점수 매기기 방법 만 유효합니다 (특히, 이 챌린지에 대해 기회는 유효한 점수 상자 가 아닙니다 ). 점수는 정수이든 문자열이든 관계없이 10 진수로 출력되어야합니다. 숫자로 즉시 인식 할 수 있어야합니다. 선행 / 트레일 링 공백은 괜찮습니다. 이것은 점수를 얻는 것이지 프리젠 테이션이 아닌 것입니다.

코드 골프이므로 주어진 언어에서 가장 적은 바이트를 가진 답이 이깁니다. 표준 허점은 금지되어 있습니다.

테스트 사례

(이것들은 모두 독립적이므로 도전은 주사위의 한 손 을 얻는 것 입니다) :

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에 의해 outgolfed

입력을 목록으로 가져 와서 점수를 반환합니다.

언 골프 :

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

파이썬 (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))])

@Giuseppe 덕분에 2 바이트가 줄었습니다 !

들여 쓰기,

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

그렇지 않으면, 또는 최대 2 개의 주사위가 동일하다면, 이것은 여전히 ​​짧은 직선 일 수 있습니다. 적어도 a 3와 a 가 있어야하며 4다른 4 개의 숫자가 조합되어 있어야합니다.

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

주사위 3 개가 같은 경우에는 전체 집을 확인하십시오 3^2==1. 그러나 6과 5와 같은 일부 풀 하우스는 3 등급으로 더 높습니다.

:4
set/as=t
goto g

그렇지 않으면, 또는 같은 네 개가 있으면 합계를 기록하십시오.

:5
set s=50

그리고 5가 동일하다면 Yahtzee!

:g
echo %s%

최고 점수를 출력합니다.

젤리 , 58 바이트

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

온라인으로 사용해보십시오!

펄 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 핸드를 평가하여 해당 핸드에 대한 점수를 반환하거나 해당 핸드의 조건이 충족되지 않으면 0을 반환하는 함수 목록입니다.

• |(1..6).map({ *{$_} * $_ })숫자 1-6의 반복 실행을 기반으로 손을 평가하는 6 가지 기능 목록입니다. 선행은 |이 목록을 주변 목록으로 병합합니다.
• {.kxxv.sum * ?.values.grep(* > 2) }3 가지 종류와 4 가지 종류의 손을 평가합니다. .kxxvon a Bag는 각각의 다중성으로 반복되는 키를 반환하여 원래의 주사위 목록을 복구하고 .sum물론 주사위를 합산합니다. 그 합계에 부울 값 ( ?)을 곱 하면 가방이.values (즉, 다중도)에 2보다 큰 값이 포함되어 입니다.
• { 25 * (6 == [*] .values) }풀 하우스의 손을 평가합니다. 25의 곱은 곱의 곱이 6 인 경우 참인 부울 값을 곱합니다. 5의 주사위에 대해 하나는 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 중 적어도 하나가 0이 아닌 경우, 부울 ( ?)로 강제 변환 될 때 정션이 true이고이 부울에 30을 곱합니다. 점수를 얻을 수 있습니다.
• 40 * ?*{ 2 & 3 & 4 & 5 & (1 | 6) }비슷하게 큰 스트레이트 핸드를 평가합니다. 주사위에는 숫자 2-5와 1 또는 6이 포함되어야하기 때문에 더 간단합니다.
• 50 * (*.keys == 1)Yahtzee 손을 평가합니다. 부울 값의 50 배에 불과하며, 별개의 주사위 수가 1이면 참입니다.

핍 , 65 63 바이트

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

주사위를 5 개의 명령 줄 인수로 사용합니다. 온라인으로 사용해보십시오!

언 골프 + 설명

(이것은 원본 버전입니다.)

                    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 바이트의 장벽을 깨뜨리고 수십 바이트를 남겨서 쉽게 파괴 할 수 있었다!

온라인으로 사용해보십시오!

설명

그래도 좋지는 않습니다. 루비 지식이 있으시길 바랍니다 ~

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