Herausforderung

Bar Dice ist ein einfaches Spiel, das in einer Bar mit Würfeln gespielt wird (daher der Name). Sie werfen 5 sechsseitige Würfel und versuchen, die beste Hand zu machen.

Die Wertung basiert auf der Ansammlung der meisten Würfel mit den gleichen Ziffern. Jede Hand muss mindestens ein einzelnes "Ass" oder ein einzelnes "Ass" enthalten, um eine gültige Hand zu sein. Asse fungieren als "Joker" und können mit jeder anderen Ziffer gepaart werden. Die Stärke der Hand eines Spielers hängt zuerst von der Anzahl der Ziffern und dann vom Wert dieser Ziffern ab. Zum Beispiel ist eine Hand (Wilds zählen) mit vier 3er besser als eine Hand mit drei 5er, aber nicht besser als eine Hand mit fünf 2er.
^{Aus dem Wikipedia-Artikel entnommen}

Dies bedeutet, dass die Hand mit dem höchsten Rang ausschließlich aus Sechsern und Einsen besteht, und die Hand mit dem niedrigsten Rang ist jede Hand ohne eine Eins.

Ihre Herausforderung besteht darin, zwei Hände zu nehmen und denjenigen Spieler zurückzugeben, der gewonnen hat oder der unentschieden gespielt hat.

Eingang

Zwei unsortierte Listen mit 5 Zahlen zwischen 1 und 6. Jede Liste repräsentiert die Hand eines Spielers. Das Eingabeformat ist flexibel.

Ausgabe

Drei unterschiedliche, aber konsistente statische Werte (Bereiche sind nicht zulässig), die angeben, ob Spieler 1 oder Spieler 2 gewonnen hat oder ob es ein Gleichstand war. Bitte geben Sie in Ihrer Antwort an, welche Werte Sie für was verwenden. Sie können beispielsweise zurückgeben, -1wenn P1 gewinnt, 0wenn es ein Unentschieden ist und 1wenn P2 gewinnt.

Regeln

• Die Eingabe ist immer gültig
• Nur die bestmögliche Punktzahl jeder Hand wird verwendet, um einen Gewinner zu bestimmen. Es gibt keine Krawattenbrecher. ZB [1,4,4,3,3]wird binden, [1,4,4,2,2]anstatt die 3er und 2er als Tie-Breaker zu verwenden.
• Die Ausgabe muss jedes Mal einen der 3 gewählten Werte haben. Das einfache Zuordnen aller negativen Zahlen zu P1 Winsist nicht zulässig und muss normalisiert werden.
• Ungültige Hände, dh solche ohne Einsen, verlieren gegen alle gültigen Hände, binden jedoch mit allen anderen ungültigen Händen. ZB [2,2,2,2,2]Krawatten [3,3,3,3,3].
• Eine Hand von [1,1,1,1,1]zählt als gültiger 6er-Satz für Ranglistenzwecke.
• Das ist Code-Golf, also gewinnt die kürzeste Anzahl an Bytes.

Beispiele

#You guys are pretty good at finding edge-cases that break things. Good job!
Input:  [2,1,5,6,6], [6,2,6,6,6]
Output: P1 Wins

Input:  [2,4,5,6,6], [6,2,6,6,6]
Output: Tie

Input:  [1,2,3,4,5], [5,4,3,2,1]
Output: Tie

Input:  [1,5,5,3,2], [5,4,1,6,6]
Output: P2 Wins

Input:  [3,2,2,2,1], [4,1,3,6,6]
Output: P1 Wins

Input:  [1,1,1,1,1], [6,1,1,6,6]
Output: Tie

Input:  [1,3,3,4,4], [1,2,2,5,5]
Output: P2 Wins

Input:  [1,3,3,5,5], [1,3,3,2,2]
Output: P1 Wins

Input:  [1,3,3,3,4], [1,1,3,3,3]
Output: P2 Wins

Input:  [2,2,2,6,1], [5,3,3,1,2]
Output: P1 Wins

Input:  [5,5,5,1,5], [1,1,1,1,1]
Output: P2 Wins

Input:  [1,1,1,1,1], [1,1,5,1,1]
Output: P1 Wins

Jelly , 17-14 Bytes

ċⱮ6Ḣ©+$®aĖUṀ)M

Probieren Sie es online!

Ein monadischer Link, der eine Liste der beiden Listen als Argument verwendet und [1]für Spieler 1, [2]für Spieler 2 und [1, 2]für ein Unentschieden zurückgibt , gewinnt . TIO Link räumt dies für die Anzeige auf.

Vielen Dank an @ JonathanAllan für das Speichern von 3 Bytes!

Erläuterung

            )   | For each input list (e.g. of one list 1,1,3,3,4)
ċⱮ6             | - Count each of 1..6 (e.g. 2,0,2,1,0,0)
      $         | - Following as a monad:
   Ḣ            |   - Head (number of 1s)
    ©︎           |   - Copy to register
     +          |   - Add (e.g. 2,4,3,0,0)
       ®a       | - Register logical and with this
         Ė      | - Enumerate (e.g. [1,2],[2,4],[3,3],[4,0],[5,0])
          U     | - Reverse each (e.g. [2,1],[4,2],[3,3],[0,4],[0,5])
            Ṁ   | - Max (e.g. 4,2)
              M | Index/indices of maximal score

R , 115 96 Bytes

-6 Bytes dank Giuseppe.

-6 Bytes dank Aaron Hayman.

-2 Bytes danke an Arnauld, der dem Ausgabeformat in seiner JavaScript-Antwort folgt .

function(i,j)(f(i)-f(j))/0
f=function(x,s=tabulate(x,6),l=s[1]+s[-1]*!!s[1])max(l)*6+order(l)[5]

Probieren Sie es online!

Gibt Inffür P1, NaNfür ein Unentschieden, -Inffür P2 zurück.

Verwendet die Hilfsfunktion, fdie für jede Hand eine Punktzahl berechnet. Die Punktzahl ist wie folgt definiert: Sei ddie Ziffer, die am häufigsten wiederholt wird, und ndie Häufigkeit, mit der sie wiederholt wird. Dann ist die Punktzahl, 6*n+dwenn es mindestens ein Ass gibt und 0wenn es keine Asse gibt. Wir müssen dann nur noch den Spieler mit der höchsten Punktzahl finden.

Ungolfed:

f = function(x) {
  s = tabulate(x, 6)         # number of occurrences of each integer
  l = s[1] + s[-1] * !!s[1]  # add the number of wild aces to all values; set to 0 if s[1] == 0
  max(l) * 6 +               # highest number of repetitions (apart from aces)
    order(l)[5]              # most repeated integer (take largest in case of tie)
}
function(i, j){
  sign(f(i) - f(j))
}

JavaScript (ES6),  97 bis  90 Byte

Übernimmt die Eingabe als (a)(b). Gibt +Infinityfür P1, -Infinityfür P2 oder NaNfür ein Unentschieden zurück.

a=>b=>((g=(x,m)=>x>6?m*/1/.test(a):g(-~x,a.map(k=>n+=k<2|k==x,n=x/6)|m>n?m:n))()-g(a=b))/0

Probieren Sie es online!

Kommentiert

a => b => (                 // a[] = dice of P1; b[] = dice of P2
  ( g = (                   // g is a recursive function taking:
      x,                    //   x = dice value to test; initially, it is either undefined
                            //       or set to a non-numeric value
      m                     //   m = maximum score so far, initially undefined
    ) =>                    //
      x > 6 ?               // if x is greater than 6:
        m * /1/.test(a)     //   return m, or 0 if a[] does not contain any 1 
      :                     // else:
        g(                  //   do a recursive call:
          -~x,              //     increment x (or set it to 1 if it's non-numeric)
          a.map(k =>        //     for each dice value k in a[]:
            n +=            //       add 1 to n if:
              k < 2 |       //         k is equal to 1
              k == x,       //         or k is equal to x
            n = x / 6       //       start with n = x / 6
          ) |               //     end of map()
          m > n ?           //     if m is defined and greater than n:
            m               //       pass m unchanged
          :                 //     else:
            n               //       update m to n
        )                   //   end of recursive call
  )()                       // first call to g, using a[]
  - g(a = b)                // subtract the result of a 2nd call, using b[]
) / 0                       // divide by 0 to force one of the 3 consistent output values

05AB1E , 16 15 Bytes

-1 Byte Danke an JonathanAllan

εWΘ*6L¢ć+°ƶà}ZQ

Probieren Sie es online!

Gibt [1, 0] für P1-Siege, [1, 1] für Unentschieden und [0, 1] für P2-Siege zurück.

Anstatt die lexikografische Reihenfolge für ein 2-Tupel (Würfelzahl, Würfelwert) zu verwenden, wird die Punktzahl als 10 ** Würfelzahl * Würfelwert berechnet. Hände ohne 1 Punkte 5.

ε           }           # map each hand to its computed score
 WΘ                     # minimum == 1 (1 if the hand contains a 1, 0 otherwise)
   *                    # multiply (sets hands without 1 to [0, 0, 0, 0, 0])
    6L                  # range [1..6]
      ¢                 # count occurences of each in the hand
       ć                # head extract (stack is now [2-count, ..., 6-count], 1-count)
        +               # add the 1-count to all the other counts
         °              # 10**x
          ƶ             # multiply each element by its 1-based index
           à            # take the maximum

Z                       # maximum
 Q                      # equality test (vectorizes)

Python 2 , 85 81 80 Bytes

lambda p:cmp(*[max((h.count(i)+h.count(i>1),i)*(1in h)for i in[6]+h)for h in p])

Probieren Sie es online!

Gibt 1für P1, 0für Unentschieden und -1für P2 zurück.

_{-1 Byte dank Tintenfisch}

Perl 6 , 60 49 Bytes

&[cmp]o*.map:{.{1}&&max (.{2..6}X+.{1})Z ^5}o&bag

Probieren Sie es online!

Returns More, Same, Lessfür P1 Wins, Tie, P2 Wins.

Erläuterung

       *.map:  # Map input lists
                                             &bag  # Convert to Bag
             {                             }o  # Pass to block
              .{1}&&  # Return 0 if no 1s
                    max  # Maximum of
                         .{2..6}  # number of 2s,3s,4s,5s,6s
                                X+.{1}  # plus number of 1s
                        (             )Z     # zipped with
                                         ^5  # secondary key 0,1,2,3,4
&[cmp]o  # Compare mapped values

T-SQL-Abfrage, 148 Byte

Tabellenvariable als Eingabe verwenden

p: Spieler

v: Wert für roll

DECLARE @ table(p int,v int)
INSERT @ values(1,5),(1,5),(1,5),(1,5),(1,5)
INSERT @ values(2,4),(2,3),(2,3),(2,1),(2,4)

SELECT sign(min(u)+max(u))FROM(SELECT(p*2-3)*(s+sum(sign(s)-1/v))*(s/5*5+v+30)u
FROM(SELECT*,sum(1/v)over(partition by p)s FROM @)c GROUP BY v,s,p)x

Probieren Sie es online aus

Player 1 wins returns -1
Tie returns 0 
Player 2 wins returns 1

Jelly , 21 Bytes

^{zerquetscht bevor ich es überhaupt von Nick Kennedy gepostet habe :)}

’-oÆṃṀ$$Ạ?fÆṃ$L;$o5)M

Ein monadischer Link, der eine Liste von Spielern akzeptiert, die eine Liste von (1-indizierten) Gewinnern ausgibt.

Also P1 ist [1], P2 ist [2]und ein Unentschieden ist [1,2].

Probieren Sie es online!

PowerShell , 112 126 123 121 Byte

Übernimmt die Eingabe als (a)(b). Gibt -1für P1-Sieg, 1für P2 oder 0für ein Unentschieden zurück.

$args|%{$d=$($_-ne1|group|sort c*,n*|%{$m=$_};(7*(($o=($_-eq1).Count)+$m.Count)+$m.Name+6*!$m)[!$o])-$d}
[math]::Sign($d)

Probieren Sie es online!

Testfall @( @(1,1,5,1,1), @(1,1,1,1,1), 1)hinzugefügt.

Abgerollt:

$args|%{
    $score=$(                                            # powershell creates a new scope inside expression $(...)
        $_-ne1|group|sort count,name|%{$max=$_}          # $max is an element with the widest group and the maximum digit except 1
        $ones=($_-eq1).Count                             # number of 1s in a player's hand
        $scoreRaw=7*($ones+$max.Count)+$max.Name+6*!$max # where $max.Name is digit of the widest group
        $scoreRaw[!$ones]                                # output $scoreRaw if the array contains 1, otherwise output $null 
    )                                                    # powershell deletes all variables created inside the scope on exit
    $diff=$score-$diff
}
[math]::Sign($diff)                                     # output the score difference

Wolfram Language (Mathematica) , 78 75 74 Bytes

-1 Byte von Greg Martin

Order@@(#~FreeQ~1||Last@Sort[Reverse/@Tally@Flatten[#/. 1->Range@6]]&)/@#&

Probieren Sie es online!

Gibt -1 aus, wenn Spieler 1 gewinnt, 1, wenn Spieler 2 gewinnt, und 0 für ein Unentschieden.

                                    Helper function to score a list:
FreeQ[#,1] ||                       If there are 0 1s, score is True
Last@Sort[                          Otherwise, take the largest element of
    Reverse/@Tally@                 the {frequency, number} pairs in the flat list
       Flatten[ #/. 1->Range@6]     where each 1 is replaced by {1,2,3,4,5,6}.
]&                              e.g. {1,3,3,5,5} -> {1,2,3,4,5,6,3,3,5,5} -> {3,5}

Order @@ (...) /@ #&                Apply this function to both lists,
                                    then find the ordering of the result.

Java 8, 244 240 236 215 199 Bytes

a->b->{int c[][]=new int[2][7],m[]=new int[2],p,i=5;for(;i-->0;c[1][b[i]]++)c[0][a[i]]++;for(i=14;i-->4;)m[p=i%2]=Math.max(m[p],c[p][1]>0?i/2+9*(c[p][i/2]+c[p][1]):0);return Long.compare(m[0],m[1]);}

-4 Bytes dank @someone .
-21 Bytes dank @Neil .
-16 Bytes dank @ceilingcat .

Gibt zurück, 1wenn P1 gewinnt. -1wenn P2 gewinnt; 0wenn es ein Unentschieden ist.

Probieren Sie es online aus.

Erläuterung:

a->b->{                        // Method with 2 integer-array parameters & integer return
  int c[][]=new int[2][7],     //  Create a count-array for each value of both players,
                               //  initially filled with 0s
      m[]=new int[2],          //  The maximum per player, initially 0
      p,                       //  Temp-value for the player
  i=5;for(;i-->0;              //  Loop `i` in the range (5, 0]:
    c[1]                       //   For player 2:
        [b[i]                  //    Get the value of the `i`'th die,
             ]++)              //    and increase that score-count by 1
    c[0][a[i]]++;              //   Do the same for player 1
  for(i=14;i-->4;)             //  Then loop `i` in the range (14, 4]:
    m[p=i%2]=                  //   Set the score of a player to:
                               //   (even `i` = player 1; odd `i` = player 2)
      Math.max(                //    The max between:
        m[p],                  //     The current value,
                               //     And the value we calculate as follows:
        c[p][1]>0?             //     If this player rolled at least one 1:
          i/2                  //      Use the current value `i` integer-divided by 2
          +9*                  //      With 9 times the following added:
             (c[p][i/2]        //       The amount of dice for value `i//2`
              +c[p][1])        //       Add the amount of dice for value 1
        :                      //     Else (no 1s were rolled):
         0);                   //      Use 0
  return Long.compare(m[0],m[1]);}
                               //  Finally compare the maximum scores of the players,
                               //  resulting in -1 if a<b; 0 if a==b; 1 if a>b

Gelee , 27 Bytes

’o5Rṗ5¤ṢŒr$€UẎṀ1e⁸¤×µ€_/Ṡo/

Probieren Sie es online!

1 für P1, -1 für P2, 0 für Gleichstand

Erläuterung

’o5Rṗ5¤ṢŒr$€UẎṀ1e⁸¤×µ€_/Ṡo/  Main link
                    µ€       For each list
’                            Decrement each value (so 1s become falsy)
 o                           Vectorized logical or (this replaces previous 1s (now 0s) with the test values)
  5Rṗ5¤                      1..5 cartesian-power 5 (1,1,1,1,1; 1,1,1,1,2; 1,1,1,1,3; ...)
          $€                 For each test list
       ṢŒr                   Sort and run-length encode (gives [digit, #digit])
            U                Reverse each list (gives [#digit, digit])
             Ẏ               Tighten by one (gives a list containing each possible hand for each possible wildcard)
              Ṁ              Take the maximum
               1e⁸¤×         Multiply the list values by (whether or not the original contained a 1) - becomes [0, 0] if not
                      _/Ṡ    Take the sign of the difference between the #digits and the digits
                         o/  If the number of digits differs, then 1/-1 is returned; otherwise, check the value of the digit (could still be 0)

Vorschlaghammer 0,4 , 27 Bytes

⢱⢙⢂⠠⡾⢃⠐⢈⠸⣞⠴⠻⠎⡥⡳⡐⢒⠘⢛⣩⡓⣮⡕⡠⣢⣡⠿

Dekomprimiert in diese Wolfram Language-Funktion:

Order @@ (FreeQ[#1, 1] || Last[Sort[Reverse[Tally[Flatten[#1 /. 1 -> Range[6]]], 2]]] & ) /@ #1 & 

Das ist genau das Gleiche wie meine Mathematica-Antwort .

Kohle , 48 45 Bytes

ＵＭθ⮌Ｅ⁷№ι∨λ¹ＵＭθ׬¬⊟ι⁺⊟ιιＵＭθ⟦⌈ι±⌕ι⌈ι⟧Ｉ⁻⌕θ⌈θ⌕θ⌊θ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Nimmt Eingaben als Array von Arrays und Ausgaben, -1wenn Spieler 1 gewinnt, 0für einen Gleichstand und 1wenn Spieler 2 gewinnt. Erläuterung:

ＵＭθ⮌Ｅ⁷№ι∨λ¹

Ersetzen Sie jede Hand durch die Anzahl, wie oft die Werte 6..1in der Hand erscheinen. Die Liste ist umgekehrt, weil a) es einfacher ist, den höchsten Wert mit der höchsten Anzahl zu finden, und b) es einfacher ist, die Anzahl von 1s zu entfernen . Die Anzahl von 1s wird verdoppelt, da sie zweimal entfernt werden muss, einmal, um zu überprüfen, ob sie ungleich Null ist, und einmal, um sie zu den anderen Zählern hinzuzufügen.

ＵＭθ׬¬⊟ι⁺⊟ιι

Addieren Sie die Anzahl von 1s zu den Zählungen für 6..2, setzen Sie jedoch alle Zählungen auf Null, wenn die Anzahl von 1s Null war.

ＵＭθ⟦⌈ι±⌕ι⌈ι⟧

Finden Sie für jede Hand die höchste Anzahl und den höchsten Wert mit dieser Anzahl. (Tatsächlich finden wir Wert minus, 6da das Golfspieler ist.)

Ｉ⁻⌕θ⌈θ⌕θ⌊θ

Bestimmen Sie, welche Hand gewonnen hat, indem Sie die Positionen der Gewinn- und Verlusthände abziehen. (Wenn die Hände unentschieden sind, gewinnt und verliert die erste Hand. Das Ergebnis ist also 0wie gewünscht.)

C (gcc) / 32 Bit, 117 Bytes

t;m;s(int*r){int c[6]={};for(m=0;t=*r++;m=t>m?t:m)c[--t]+=5,t=t?c[t]+t:5;t=*c?*c+m:0;}f(a,b){t=s(a)-s(b);t=(t>0)-!t;}

Probieren Sie es online!

Nimmt zwei nullterminierte Integer-Arrays auf. Returns 1, 0, -1für P1 Wins, P2 Wins, Tie.

J , ⁴⁷ 44 Bytes

*@-&([:({.([:>./#\@]+9^*@[*+)}.)1#.i.@6=/<:)

Probieren Sie es online!

Inspiriert von Nick Kennedys Idee.

ungolfed

*@-&([: ({. ([: >./ #\@] + 9 ^ *@[ * +) }.) 1 #. i.@6 =/ <:)

Perl 5 -MList::Util=max -pl , 80 Bytes

sub t{$t=pop;$_=max map$_ x$t=~s/$_//g,2..6;/./;$t&&$_.$t*($&||6)}$_=t($_)<=>t<>

Probieren Sie es online!

Eingang:

Jeder Spieler in einer separaten Zeile, keine Leerzeichen

Ausgabe:

1 Zeile eins gewinnt

0 Krawatte

-1 Zeile zwei gewinnt