Yahtzee ist ein Spiel, das mit fünf sechsseitigen Würfeln und einem Punktebogen mit dreizehn verschiedenen Feldern gespielt wird, um eine Punktzahl auszufüllen. Jedes Feld hat seine eigenen Bewertungsregeln:

• 1s, 2s, 3s, 4s, 5s, 6s - alle Punkte entsprechen der Summe der jeweiligen Würfel (dh ein Wurf von [3, 2, 3, 1, 5], der als 3s gewertet wird, wird mit 6 Punkten bewertet: 3 für jeweils 3).
• 3-of-a-kind und 4-of-a-kind (so wie sie klingen, haben drei oder vier Würfel das gleiche Ergebnis erzielt) entsprechen der Summe aller fünf Würfel.
• Full House (zwei Würfel zeigen einen Wert, die anderen drei zeigen einen anderen) erhält 25 Punkte
• Kleine Gerade (vier aufeinanderfolgende Werte) bringt 30 Punkte
• Große Straße (alle aufeinanderfolgenden Werte) bringt 40 Punkte
• Yahtzee (alle Würfel zeigen den gleichen Wert) erhält 50 Punkte

Der dreizehnte (Zufall) macht im Spiel Sinn, aber nicht so sehr für diese Herausforderung; Zusätzlich bietet das Spiel Boni für zusätzliche Yahtzees, die hier keinen Sinn ergeben. Weil die Herausforderung ist ...

Bei fünf Würfeln als Eingabe (fünf Ganzzahlen von 1 bis 6, Eingabe ist jedoch praktisch, Sie können davon ausgehen, dass die Eingabe immer gültig ist), wird die höchstmögliche Punktzahl für diese 'Hand' ausgegeben. Für die Zwecke dieser Herausforderung sind nur die Bewertungsmethoden in der obigen Liste gültig (insbesondere ist der Zufall keine gültige Bewertungsbox für diese Herausforderung). Die Bewertung sollte als dezimaler numerischer Wert ausgegeben werden, unabhängig davon, ob es sich um eine Ganzzahl oder eine Zeichenfolgendarstellung handelt. Es sollte sofort als Zahl erkennbar sein. Führende / nachfolgende Leerzeichen sind in Ordnung, hier geht es darum, die Punktzahl und nicht die Präsentation zu erhalten.

Code Golf, also gewinnt die Antwort mit den wenigsten Bytes in einer gegebenen Sprache. Standardlücken verboten.

Testfälle

(Beachten Sie, dass diese alle unabhängig voneinander sind. Die Herausforderung besteht darin, eine Hand Würfel zu erzielen. )

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 , 146 141 Bytes

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)

Probieren Sie es online!

Vom Plannapus überfordert

Nimmt Eingaben als Liste und gibt die Punktzahl zurück.

etwas ungolfed:

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 Bytes

-17 Bytes dank @mypetlion
-2 Bytes dank @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)])

Probieren Sie es online!

R, 136 134 Bytes

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

2 Bytes weniger dank @Giuseppe !

Eingerückt,

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

Einige Testfälle:

> 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

Batch, 359 Bytes

@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%

Erläuterung:

@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%

Berechnen Sie die Anzahl der Würfel für jede Zahl plus das Maximum plus die Summe aller Würfel plus die höchste Summe der Würfel derselben Zahl.

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

Wenn alle Würfel unterschiedlich sind, kann dies eine lange Straße sein, aber es muss entweder keine 1oder keine geben 6.

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

Andernfalls oder wenn höchstens zwei Würfel gleich sind, könnte dies immer noch eine kurze Straße sein. Es muss mindestens ein 3und ein 4und auch eine Kombination der anderen vier Zahlen geben.

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

Wenn es drei gleiche Würfel gibt, prüfen Sie, ob das Haus voll ist 3^2==1. Einige volle Häuser, wie z. B. 6er und 5er, erzielen jedoch eine höhere Punktzahl als 3er.

:4
set/as=t
goto g

Andernfalls oder wenn vier gleich sind, wird die Gesamtsumme gewertet.

:5
set s=50

Und wenn es fünf sind, dann Yahtzee!

:g
echo %s%

Die beste Punktzahl ausgeben.

Jelly , 58 Bytes

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

Probieren Sie es online!

Perl 6 , 159 Bytes

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

Probieren Sie es online!

Da Eingaben akzeptiert werden können, "die jedoch bequem sind", nimmt meine Funktion sie als eine Instanz der BagKlasse, bei der es sich um einen Container mit einer Vielzahl handelt. A Bagist auch ein assoziativer Container; $bag{$key}Gibt zurück, wie oft $keyin der Tasche vorkommt.

Der Hauptteil der Funktion ist nur eine Liste von Funktionen, die jede mögliche Yahtzee-Hand auswerten und die Punktzahl für diese Hand oder Null zurückgeben, wenn die Bedingungen für die Hand nicht erfüllt sind.

• |(1..6).map({ *{$_} * $_ })ist eine Liste von sechs Funktionen, die Hände basierend auf wiederholten Läufen der Nummern 1-6 bewerten. Der Anführer |verflacht diese Liste in der umgebenden Liste.
• {.kxxv.sum * ?.values.grep(* > 2) }bewertet die 3- und 4-of-a-kind Hände. .kxxvbei a werden Bagdie schlüssel mit der multiplizität der einzelnen wiederholt, wobei die ursprüngliche liste der würfelwürfe wiederhergestellt wird und .sumnatürlich die würfel addiert werden. Diese Summe wird mit einem booleschen Wert ( ?) multipliziert. Dies ist der Fall, wenn der Beutel .values(dh die Multiplizitäten) einen Wert größer als 2 enthält.
• { 25 * (6 == [*] .values) }wertet die Full House Hand aus. 25 wird mit einem booleschen Wert multipliziert, der wahr ist, wenn das Produkt der Multiplizitäten 6 ist, was für fünf Würfel nur passieren kann, wenn einer 3 und der andere 2 ist.
• 30 * ?*{ 3 & 4 & (1 & 2 | 2 & 5 | 5 & 6) }wertet die kleine gerade Hand aus. Es ist eine WhateverCodeFunktion; der zweite stern *ist der Bag. Der Ausdruck zwischen den geschweiften Klammern ist die Verknüpfung der Werte 3 und 4 und entweder 1 und 2 oder 2 und 5 oder 5 und 6. Wenn Sie diese Verknüpfung in den BagErgebnissen nachschlagen, erhalten Sie eine Verknüpfung der entsprechenden Multiplizitäten. Wenn die Multiplizitäten von 3 und 4 und mindestens eine von 1 und 2 oder 2 und 5 oder 5 und 6 ungleich Null sind, ist die Verknüpfung wahr, wenn sie zu einem Booleschen Wert (mit ?) gezwungen wird , und dieser Boolesche Wert wird mit 30 multipliziert um die Punktzahl zu bekommen.
• 40 * ?*{ 2 & 3 & 4 & 5 & (1 | 6) }Ebenso bewertet die große gerade Hand. Es ist einfacher, weil die Würfel jede der Zahlen 2-5 und entweder 1 oder 6 enthalten müssen.
• 50 * (*.keys == 1)bewertet die Yahtzee Hand. Es ist einfach das 50-fache eines Booleschen Wertes, was wahr ist, wenn die Anzahl der unterschiedlichen Würfel eins ist.

Pip , 65 63 Bytes

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

Nimmt die Würfel als fünf Befehlszeilenargumente. Probieren Sie es online!

Ungolfed + Erklärung

(Dies ist die Originalversion.)

                    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

Ruby , 184 Bytes

Volles Programm. Um das Testen der Eingabe zu vereinfachen, fügen Sie die Zeichen $/=' 'oben hinzu, um das Format "Durch Leerzeichen getrennte Ziffer" einzulesen. (191 Zeichen)

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

Ich habe die 200-Byte-Barriere durchbrochen und es geschafft, sie mit Leichtigkeit mit einem Dutzend verbleibender Bytes zu zerstören!

Probieren Sie es online!

Erläuterung

Nicht sehr gut. Hoffe du hast etwas Ruby Wissen ~

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