Défi

Bar Dice est un jeu simple joué dans un bar avec des dés (d'où le nom). Vous lancez 5 dés à six faces et tentez de faire la meilleure main.

Le score est basé sur la collecte du plus grand nombre de dés avec les mêmes chiffres. Chaque main doit comprendre au moins un seul "Ace", ou un, pour être une main valide; Les as agissent comme des "jokers" et peuvent être associés à n'importe quel autre chiffre. La force de la main d'un joueur dépend d'abord du nombre de chiffres puis de la valeur de ces chiffres. Par exemple, une main (en comptant les jokers) avec quatre 3 vaut mieux qu'une main avec trois 5, mais pas mieux qu'une main avec cinq 2.
^{Tiré de l'article Wikipedia}

Cela signifie que la main la mieux classée est entièrement composée de 6 et de 1, et la main la moins bien classée est toute main sans 1.

Votre défi est de prendre deux mains et de retourner le joueur qui a gagné, ou s'il est à égalité.

Contribution

Deux listes non triées de 5 numéros, allant de 1 à 6. Chaque liste représente la main d'un joueur. Le format d'entrée est flexible.

Sortie

Trois valeurs statiques distinctes mais cohérentes (les plages ne sont pas autorisées) indiquant si le joueur 1 ou le joueur 2 a gagné, ou s'il s'agissait d'une égalité. Veuillez indiquer dans votre réponse quelles valeurs vous utilisez pour quoi. Par exemple, vous pouvez revenir -1si P1 gagne, 0s'il s'agit d'une égalité et 1si P2 gagne.

Règles

• L'entrée sera toujours valide
• Seul le meilleur score possible de chaque main est utilisé pour déterminer un gagnant. Il n'y a pas de bris d'égalité. Par exemple, [1,4,4,3,3]liera [1,4,4,2,2]au lieu d'utiliser les 3 et les 2 comme bris d'égalité.
• La sortie doit être l'une des 3 valeurs choisies à chaque fois. Le simple mappage de tous les nombres négatifs sur P1 Winsn'est pas autorisé et doit être normalisé.
• Les mains invalides, c'est-à-dire celles qui n'ont pas de 1, perdent face à toutes les mains valides mais égalent avec toutes les autres mains invalides. Par exemple, [2,2,2,2,2]cravates[3,3,3,3,3] .
• Une main [1,1,1,1,1]compte comme un ensemble valide de 6 à des fins de classement.
• C'est le golf par code, donc le nombre d'octets le plus court l'emporte.

Exemples

#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

Gelée , 17 14 octets

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

Essayez-le en ligne!

Un lien monadique qui prend une liste des deux listes comme argument et renvoie [1]pour le joueur 1 gagne, [2]pour le joueur 2 gagne et [1, 2]pour une égalité. Le lien TIO fait le ménage pour l'affichage.

Merci à @JonathanAllan pour avoir économisé 3 octets!

Explication

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

-6 octets grâce à Giuseppe.

-6 octets grâce à Aaron Hayman.

-2 octets grâce à Arnauld, suivant le format de sortie dans sa réponse JavaScript .

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]

Essayez-le en ligne!

Retourne Infpour P1, NaNpour une égalité,-Inf pour P2.

Utilise la fonction d'assistance fqui calcule un score pour chaque main. Le score est défini comme suit: dsoit le chiffre qui se répète le plus, etn le nombre de fois qu'il se répète. Ensuite, le score est 6*n+ds'il y a au moins un as et 0s'il n'y a pas d'as. Il nous suffit alors de trouver le joueur avec le score le plus élevé.

Non golfé:

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  90 octets

Prend l'entrée comme (a)(b). Renvoie +Infinitypour P1, -Infinitypour P2 ou NaNpour une égalité.

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

Essayez-le en ligne!

Commenté

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 octets

-1 octet grâce à JonathanAllan

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

Essayez-le en ligne!

Renvoie [1, 0] pour les victoires P1, [1, 1] pour les égalités, [0, 1] pour les victoires P2.

Plutôt que d'utiliser l'ordre lexicographique sur un tuple 2 (nombre de dés, valeur des dés), cela calcule le score comme 10 ** nombre de dés * valeur des dés. Mains sans 1 score 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 octets

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

Essayez-le en ligne!

Renvoie 1pour P1, 0pour égalité et -1pour P2.

_{-1 octet, grâce au calmar}

Perl 6 , 60 49 octets

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

Essayez-le en ligne!

Retours More, Same, Lesspour P1 Wins, Tie,P2 Wins .

Explication

       *.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

Requête T-SQL, 148 octets

Utilisation d'une variable de table comme entrée

p: joueur

v: valeur pour le rouleau

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

Essayez-le en ligne

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

Gelée , 21 octets

^{écrasé avant même de l'avoir posté par Nick Kennedy :)}

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

Un lien monadique acceptant une liste de joueurs qui génère une liste de gagnants (indexés 1).

Donc P1 est [1], P2 est [2]et une égalité est [1,2].

Essayez-le en ligne!

PowerShell , 112 126 123 123 121 octets

Prend l'entrée comme (a)(b). Retourne -1pour la victoire P1, 1pour P2 ou 0pour une égalité.

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

Essayez-le en ligne!

Cas de test @( @(1,1,5,1,1), @(1,1,1,1,1), 1)ajouté.

Déroulé:

$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 octets

-1 octet par Greg Martin

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

Essayez-le en ligne!

Produit -1 lorsque le joueur 1 gagne, 1 lorsque le joueur 2 gagne et 0 pour une égalité.

                                    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 octets

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 octets grâce à @someone .
-21 octets grâce à @Neil .
-16 octets grâce à @ceilingcat .

Résultats 1 si P1 gagne; -1si P2 gagne; 0si c'est une cravate.

Essayez-le en ligne.

Explication:

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

Gelée , 27 octets

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

Essayez-le en ligne!

1 pour P1, -1 pour P2, 0 pour égalité

Explication

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

Sledgehammer 0.4 , 27 octets

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

Décompresse dans cette fonction Wolfram Language:

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

qui se révèle être exactement la même que ma réponse Mathematica .

Fusain , 48 45 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend l'entrée comme un tableau de tableaux et sort -1si le joueur 1 gagne, 0pour une égalité et 1si le joueur 2 gagne. Explication:

ＵＭθ⮌Ｅ⁷№ι∨λ¹

Remplacez chaque main par le nombre de fois où les valeurs 6..1apparaissent dans la main. La liste est inversée car a) elle facilite la recherche de la valeur la plus élevée avec le nombre le plus élevé et b) elle facilite la suppression du nombre de 1s. Le nombre de 1s est doublé car il doit être supprimé deux fois, une fois pour vérifier qu'il n'est pas nul et une fois pour l'ajouter aux autres nombres.

ＵＭθ׬¬⊟ι⁺⊟ιι

Ajoutez le nombre de 1s au nombre de 6..2, mais définissez tous les nombres sur zéro si le nombre de 1s était égal à zéro.

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

Pour chaque main, trouvez le nombre le plus élevé et la valeur la plus élevée avec ce nombre. (En fait, nous trouvons la valeur moins 6car c'est golfeur.)

Ｉ⁻⌕θ⌈θ⌕θ⌊θ

Déterminez quelle main a gagné en soustrayant les positions des mains gagnante et perdante. (Si les mains sont à égalité, la première main est à la fois gagnante et perdante, le résultat est donc 0comme souhaité.)

C (gcc) / 32 bits, 117 octets

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

Essayez-le en ligne!

Prend deux tableaux entiers terminés par zéro. Retours 1, 0, -1pour P1 Wins, P2 Wins, Tie.

J , ⁴⁷ 44 octets

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

Essayez-le en ligne!

Inspiré par l'idée de Nick Kennedy.

non golfé

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

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

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

Essayez-le en ligne!

Contribution:

Chaque joueur sur une ligne séparée, sans espaces

Sortie:

1 La première ligne gagne

0 Attacher

-1 Ligne deux victoires