Morgen ist das Mittherbstfest, und im Geiste dieses Feiertags werde ich ein Glücksspiel vorstellen, das wir (Leute aus Xiamen ) während des Feiertags spielen!

Regeln

Das Spiel wird mit sechs 6-seitigen Würfeln gespielt. Unterschiedliche Zahlenkombinationen haben unterschiedliche Ränge, wobei der Schwerpunkt auf Vieren und Einsen liegt. Ihre Aufgabe ist es, ein Programm / eine Funktion zu schreiben, die die Hand mit einem Würfelwurf von 6 würfelt. Hier sind die Ränge (ich habe die Regeln ein wenig geändert / vereinfacht):

Ich denke, nur Chinesen können diese Herausforderung bewältigen! Okay, gut, hier sind einige englische Erklärungen.

• 0: 4 vier und 2 eins.
• 1: 6 vier.
• 2: 6.
• 3: 6 jeglicher Art außer vier und eins.
• 4: 5 vier.
• 5: 5 jeglicher Art außer vier.
• 6: 4 vier.
• 7: Gerade. (1-6)
• 8: 3 vier.
• 9: 4 jeglicher Art außer 4.
• 10: 2 vier.
• 11: 1 vier.
• 12: Nichts.

Eingang

6 Zahlen, ein Array von 6 Zahlen oder eine Folge von 6 Zahlen, die die Werte der 6 Würfelwürfe von 1-6 darstellen

Ausgabe

Ihr Programm / Ihre Funktion kann alles zurückgeben / ausgeben, um den Rang anzuzeigen, solange jeder Rang durch eine Ausgabe angezeigt wird und umgekehrt. Ex. Verwenden Sie die Nummern 0-12, 1-13 usw.

Beispiele (Verwenden von 0-12 als Ausgänge)

[1,1,1,1,1,1]->2
[1,4,4,4,1,4]->0
[3,6,5,1,4,2]->7
[1,2,3,5,6,6]->12
[3,6,3,3,3,3]->5
[4,5,5,5,5,5]->5

Dies ist Code-Golf, also gewinnt die kürzeste Byte-Anzahl!

Holzkohle , 55 Bytes

≡⌈Ｅθ№θι⁶Ｉ⁻²⌕14§θχ⁵Ｉ⁻⁵⁼⁵№θ4⁴⎇⁼№θ4⁴§60⁼№θ1²9¹7Ｉ⁻¹²⌊⊘Ｘ²№θ4

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Überspringt nicht 10. Erläuterung:

≡⌈Ｅθ№θι

Berechnen Sie die höchste Frequenz einer Ziffer.

⁶Ｉ⁻²⌕14§θχ

Wenn es eine 6 von einer Art gibt, subtrahieren Sie die Position der Ziffer in der Zeichenfolge 14von 2. Dies ergibt 1 für 6 4s, 2 für 6 1s und 3 für 6 von allem anderen.

⁵Ｉ⁻⁵⁼⁵№θ4

Wenn es eine 5 von einer Art gibt, ist das Ergebnis 5, es sei denn, es gibt 5 4s, in welchem ​​Fall 1 subtrahiert wird.

⁴⎇⁼№θ4⁴§60⁼№θ1²9

Wenn es eine 4 von einer Art gibt, dann wenn es 4 4s gibt, dann ist das Ergebnis 6, es sei denn, es gibt 2 1s. In diesem Fall ist das Ergebnis 0, andernfalls ist das Ergebnis 9.

¹7

Wenn alle Ziffern unterschiedlich sind, ist das Ergebnis 7.

Ｉ⁻¹²⌊⊘Ｘ²№θ4

Andernfalls ist das Ergebnis 12 - (4 >> (3 - # von 4s)).

JavaScript (ES6), 88 Byte

a=>a.map(o=n=>[x=o[n]=-~o[n],6,,,21,9,8^o[1]][a=x<a?a:x])[5]|[,1,4,5,o[1]&2|8,2,4][o[4]]

Probieren Sie es online aus! oder Testen Sie alle möglichen Rollen!

Gibt eine Ganzzahl gemäß der folgenden Zuordnung aus:

 Rank | Output       Rank | Output
------+--------     ------+--------
   0  |  31            7  |   7
   1  |  12            8  |   5
   2  |  14            9  |  21
   3  |   8           10  |   4
   4  |  11           11  |   1
   5  |   9           12  |   0
   6  |  29

Wie?

Methode

Die Ausgabe wird berechnet, indem ein bitweises ODER zwischen:

• eine Bitmaske basierend auf : die Anzahl der 4er$F$
• eine Bitmaske basierend auf : die maximale Anzahl von Vorkommen derselben Würfel$M$

Ausnahmen:

• Wenn : Wir verwenden eine spezielle Bitmaske wenn die beiden anderen Würfel Einsen sind, oder eine Standard-Bitmaske wenn dies nicht der Fall ist .$F=4$$4b$$4a$
• Wenn : Wir verwenden eine spezielle Bitmaske wenn wir eine Sechs-von-einer-Art von Einsen haben, oder eine andere Standard-Bitmaske .$M=6$$6b$$6a$

Tabelle

Gültige Kombinationen von und sind in der folgenden Tabelle fett und blau hervorgehoben.$F$$M$

$$\begin{array}{c|c|cccccccc} &F&0&1&2&3&4a&4b&5&6\\ \hline M&\text{OR}&0&1&4&5&8&10&2&4\\ \hline 1&6&\color{grey}{6}&\color{blue}{\textbf{7}}&\color{grey}{6}&\color{grey}{7}&\color{grey}{14}&\color{grey}{14}&\color{grey}{6}&\color{grey}{6}\\ 2&0&\color{blue}{\textbf{0}}&\color{blue}{\textbf{1}}&\color{blue}{\textbf{4}}&\color{grey}{5}&\color{grey}{8}&\color{grey}{10}&\color{grey}{2}&\color{grey}{4}\\ 3&0&\color{blue}{\textbf{0}}&\color{blue}{\textbf{1}}&\color{blue}{\textbf{4}}&\color{blue}{\textbf{5}}&\color{grey}{8}&\color{grey}{10}&\color{grey}{2}&\color{grey}{4}\\ 4&21&\color{blue}{\textbf{21}}&\color{blue}{\textbf{21}}&\color{blue}{\textbf{21}}&\color{grey}{21}&\color{blue}{\textbf{29}}&\color{blue}{\textbf{31}}&\color{grey}{23}&\color{grey}{21}\\ 5&9&\color{blue}{\textbf{9}}&\color{blue}{\textbf{9}}&\color{grey}{13}&\color{grey}{13}&\color{grey}{9}&\color{grey}{11}&\color{blue}{\textbf{11}}&\color{grey}{13}\\ 6a&8&\color{blue}{\textbf{8}}&\color{grey}{9}&\color{grey}{12}&\color{grey}{13}&\color{grey}{8}&\color{grey}{10}&\color{grey}{10}&\color{blue}{\textbf{12}}\\ 6b&14&\color{blue}{\textbf{14}}&\color{grey}{15}&\color{grey}{14}&\color{grey}{15}&\color{grey}{14}&\color{grey}{14}&\color{grey}{14}&\color{grey}{14}\\ \end{array}$$

Alle anderen Kombinationen (in grau) können unmöglich vorkommen. Wenn wir zum Beispiel drei 4er haben, müssen wir . Aber weil es in einem solchen Wurf nur noch 3 andere Würfel gibt, haben wir auch . Es gibt also nur einen möglichen Wert von für .$M\ge3$$M\le3$$M$$F=3$

Beispiel

Wenn wir eine Straße haben, erscheint jeder Würfel genau einmal. Wir haben also und . Bei Verwendung der in der obigen Tabelle beschriebenen Bitmasken führt dies zu:$M=1$$F=1$

$$6 \text{ OR } 1 = 7$$

Es gibt weitere in der Tabelle, aber es ist ungültig. Daher wird eine Gerade durch eindeutig identifiziert .$7$$7$

Kommentiert

a =>                   // a[] = input array, reused as an integer to keep track of the
  a.map(               //       maximum number of occurrences of the same dice (M)
    o =                // o = object used to count the number of occurrences of each dice
    n =>               // for each dice n in a[]:
    [                  //   this is the lookup array for M-bitmasks:
      x =              //     x = o[n] = number of occurrences of the current dice
        o[n] = -~o[n], //     increment o[n] (we can't have M = 0, so this slot is not used)
      6,               //     M = 1 -> bitmask = 6
      ,                //     M = 2 -> bitmask = 0
      ,                //     M = 3 -> bitmask = 0
      21,              //     M = 4 -> bitmask = 21
      9,               //     M = 5 -> bitmask = 9
      8 ^ o[1]         //     M = 6 -> bitmask = 14 for six 1's, or 8 otherwise
    ][a =              //   take the entry corresponding to M (stored in a)
        x < a ? a : x] //   update a to max(a, x)
  )[5]                 // end of map(); keep the last value
  |                    // do a bitwise OR with the second bitmask
  [                    // this is the lookup array for F-bitmasks:
    ,                  //   F = 0 -> bitmask = 0
    1,                 //   F = 1 -> bitmask = 1
    4,                 //   F = 2 -> bitmask = 4
    5,                 //   F = 3 -> bitmask = 5
    o[1] & 2 | 8,      //   F = 4 -> bitmask = 10 if we also have two 1's, 8 otherwise
    2,                 //   F = 5 -> bitmask = 2
    4                  //   F = 6 -> bitmask = 4
  ][o[4]]              // take the entry corresponding to F (the number of 4's)

R , 100 Bytes

Codieren Sie die Partitur als eine Reihe indizierter Bedingungen. Einfacher als mein erster Stringy-Regex-Ansatz.

Fehler behoben und jetzt alle Würfe ordnen.

function(d,s=sum(d<2))min(2[s>5],c(11,10,8,6-6*!s-2,4,1)[sum(d==4)],c(7,12,12,9,5,3)[max(table(d))])

Probieren Sie es online aus!

JavaScript (Node.js) , 169 Byte

a=>-~"114444|123456".search(w=a.sort().join``,[l,t]=/(.)\1{3,}/.exec(w)||[0],l=l.length)||(l>5?3-"14".search(t):l>3?4+(5.5-l)*(t-4?4:2):[,13,12,11,9][w.split`4`.length])

Probieren Sie es online aus!

Kehrt zurück 1..13

Python 2 ,  148  119 Bytes

-27 Bytes dank ovs (1. Verwendung des .countZulassens von a map; 2. Entfernen von redundanten 0Slices; 3. Verwendung von a inanstelle von a max; 4. verkürzt (F==4)*O==2auf F==4>O==2[seit dem Golfen auf F>3>O>1])

C=map(input().count,range(1,7))
O,F=C[::3]
print[F>3>O>1,F>5,O>5,6in C,F>4,5in C,F>3,all(C),F>2,4in C,F>1,F,1].index(1)

Probieren Sie es online aus!

Pyth, 60 Bytes

eS[@[ZhZ2 4*6hq2hJuXtHG1Qm0Q8hT)@J3*5hSJ*Tq6hJ*<3KeSJ@j937TK

Karten zum umgekehrten Rang, 0-12. Versuchen Sie es online hier oder überprüfen alle Testfälle auf einmal hier .

Die vollständige Zuordnung lautet wie folgt:

12: 4 fours and 2 ones.
11: 6 fours.
10: 6 ones.
 9: 6 of any kind except fours and ones.
 8: 5 fours.
 7: 5 of any kind except for fours.
 6: 4 fours.
 5: Straight. (1-6)
 4: 3 fours.
 3: 4 of any kind except 4.
 2: 2 fours.
 1: 1 four.
 0: Nothing.

Dies funktioniert, indem die Würfelwerte Frequenzen zugeordnet werden, dann der Wert mehrerer Regeln berechnet und das Maximum des Satzes genommen wird.

Implicit: Q=eval(input()), Z=0, T=10

JuXtHG1Qm0Q   Input mapping
 u     Q      Reduce each element of the input, as H, ...
        m0Q   ...with initial value, G, as an array of 6 zeroes (map each roll to 0)
   tH           Decrement the dice roll
  X  G1         Add 1 to the frequency at that point
J             Store the result in J

@[ZhZ2 4*6hq2hJuXtHG1Qm0Q8hT)@J3   Rule 1 - Values for sets including 4
  Z                               *0
   hZ                             *1 (increment 0)
     2                            *2
       4                          *4
              JuXtHG1Qm0Q          Input mapping (as above)
             h                     First value of the above - i.e. number of 1's
           q2                      1 if the above is equal to 2, 0 otherwise
        *6h                       *Increment and multiply by 6
                                   Maps to 12 if there are 2 1's, 6 otherwise
                         8        *8
                          hT      *11 (increment 10)
 [                          )      Wrap the 7 starred results in an array
                             @J3   Get the 4th value of the input mapping - i.e. number of 4's
@                                  Get the value at that position in the array

*5hSJ   Rule 2 - Straight
  hSJ   Smallest frequency in input mapping (first, sort, J)
        For a straight, smallest value will be 1, 0 otherwise
*5      Multiply by 5

*Tq6hJ   Rule 3 - 6 1's
    hJ   Frequency of 1's (first value from input mapping)
  q6     1 if the above == 6, 0 otherwise
*T       Multiply by 10

*<3KeSJ@j937TK   Rule 4 - 4,5,6 of a kind, other than 4's
   KeSJ          Get the max frequency from input mapping, store in K
        j937T    [9,3,7]
       @     K   Get the element at K'th position in the above (modular indexing)
 <3K             1 if 3<K, 0 otherwise
*                Multiply the previous 2 results

eS[   Wrapping it all up!
  [   Wrap all the above rules in an array
eS    Take the max value of the above, implicit print

Retina , 137 126 Bytes

4
A
O`.
^11A+
0
1+$
2
^A+
1
(.)\1{5}
3
^.A+
4
.?(.)\1{4}.?
5
^..A+
6
12356A
7
.+AAA$
8
.*(.)\1{3}.*
9
.+AA$
10
.+A$
11
.{6}
12

-11 Bytes dank @Neil .

Die Ausgabe ist 0-indiziert ( 0..12).

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Ersetzen Sie alle 4 durch ein 'A':

4
A

Sortieren Sie alle Eingangsziffern (die A-Zeichen befinden sich hinten):

O`.

Alle zwei Zeilen ersetzen die Eingabe durch die erwartete Ausgabe:

Regex         Replacement  Explanation

^11A+         0            starts with "11", followed by any amount of A's
1+$           2            ends with any amount of 1s
^A+           1            starts with any amount of A's
(.)\1{5}      3            six of the same characters
^.A+          4            starts with any character, followed by any amount of A's
.?(.)\1{4}.?  5            five of the same characters,
                           with optionally a leading or trailing character
^..A+         6            starts with any two characters, followed by any amount of A's
12356A        7            literal "12356A" match
.+AAA$        8            any amount of leading characters, ending with three A's
.*(.)\1{3}.*  9            four of the same characters,
                           with optionally any amount of leading/trailing chars
.+AA$         10           any amount of leading characters, ending with two A's
.+A$          11           any amount of leading characters, ending with a A
.{6}          12           any six characters

05AB1E , 57 55 Bytes

4¢[email protected]¢©5-Di14¹нk2αë>Di5X-ë>i9X3*-¹1¢2Ê*ë®i7ë¹4¢o;ï12α

Port of @Neils Charcoal-Antwort , da mein anfänglicher Ansatz bereits bei 60 Bytes lag und ich noch nicht fertig war. Meine aktuelle Antwort kann aber wahrscheinlich noch mehr gespielt werden.

Eingabe als Ziffernliste.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

4¢              # Count the amount of 4s in the (implicit) input-list
  4@            # Check if it's larger than or equal to 4
                # (results in 1 for truthy; 0 for falsey)
    U           # Pop and store that result in variable `X`
.M              # Push the most frequent number in the (implicit) input-list
  ¢             # Pop and push the count of that number in the (implicit) input-list
   ©            # Store it in the register (without popping)
5-Di            # If the maximum count - 5 is exactly 1 (so the maximum count is 6):
    14          #  Push 14
      ¹н        #  Push the first digit of the input-list
        k       #  Get its index in 14, resulting in -1, 0, or 1
         2α     #  Take the absolute difference with 2
                #  (This covers cases 1, 2, and 3)
ë>Di            # Else-if the maximum count - 5 + 1 is exactly 1 (so the maximum count is 5):
    5           #  Push 5
     X-         #  And subtract variable `X`
                #  (This covers cases 4 and 5)
ë>i             # Else-if the maximum count - 5 + 2 is exactly 1 (so the maximum count is 4):
   9            #  Push 9
    X3*         #  Multiply variable `X` by 3
       -        #  And subtract it from the 9
        ¹1¢     #  Count the amount of 1s in the input-list
           2Ê   #  Check if it's NOT equal to 2 (1 if truthy; 0 if falsey)
             *  #  Multiply it with the 9 or 6
                #  (This covers cases 0, 6, and 9)
ë®i             # Else-if the maximum count is 1:
   7            #  Push a 7
                #  (This covers case 7)
ë               # Else (maximum count is 2 or 3):
 ¹4¢            #  Count the amount of 4s in the input-list
    o           #  Take 2 to the power this count
     ;ï         #  Halve and floor it
       12α      #  And take the absolute difference with 12
                #  (This covers cases 8, 10, 11, and 12)
                # (Output the top of the stack implicitly as result)

Ruby , 100 Bytes

->a{%w(^2.*4$ 6$ ^6 6 5$ 5 4$ ^1*$ 3$ 4 2$ 1$ .).index{|b|/#{b}/=~([1,*a,4].map{|c|a.count(c)}*'')}}

Probieren Sie es online aus!

Wie es funktioniert:

Zählen Sie das Auftreten jeder Zahl im Array, stellen Sie die Zahl 1s voran und fügen Sie die Zahl 4s hinzu.

Versuchen Sie danach, mit verschiedenen Regex-Mustern übereinzustimmen.