421 est un jeu de dés assez populaire en France et dans certains autres pays européens. Il est principalement joué dans les bars et les pubs pour déterminer qui va acheter la prochaine série de boissons. Le jeu complet se déroule généralement en deux tours, avec des jetons dont chaque joueur essaie de se débarrasser, mais ce n'est pas pertinent ici. ( Page Wikipedia en français.)

Le jeu se joue avec 3 dés cubes standard.

Tâche

Votre tâche consiste à trier une liste non vide de jets de 3 dés distincts [X, Y, Z] du plus haut au plus bas, en appliquant les règles de score de ce jeu.

Notation de base

4,2,1 est la combinaison la plus élevée possible. Selon les règles, il peut marquer 8, 10 ou 11 points. Parce que nous trions les rouleaux plutôt que de compter les points, la valeur exacte n'a pas d'importance.
Trois As: 1,1,1 est la deuxième combinaison la plus élevée et marque 7 points.
Deux As: X, 1,1 (où X est 2 à 6) marque X points.
Trois du genre: X, X, X (où X est 2 à 6) marque X points.
Lignes droites: X, X + 1, X + 2 marque 2 points.
Tous les autres jets marquent 1 point.

Établir des liens

Chaque fois que deux jets donnent le même nombre de points, les règles suivantes s'appliquent:

Un Two-Aces est meilleur qu'un Three-of-a-Kind. Exemple: 5,1,1 bat 5,5,5 .
Le Three-of-a-Kind 2,2,2 est meilleur qu'une ligne droite. Exemple: 2,2,2 battements 4,5,6 .
Les lignes droites sont classées du plus bas au plus haut. Exemple: 4,5,6 battements 2,3,4 .
Tous les autres jets sont réglés en triant les dés du plus haut au plus bas. Exemple: 6,5,2 battements 6,4,3 . (Par conséquent, la combinaison la plus basse possible dans le jeu est 2,2,1 .)

Vous trouverez ci-dessous les 56 rouleaux distincts possibles classés du plus haut au plus bas:

421 111 611 666 511 555 411 444 311 333 211 222 654 543 432 321
665 664 663 662 661 655 653 652 651 644 643 642 641 633 632 631
622 621 554 553 552 551 544 542 541 533 532 531 522 521 443 442
441 433 431 422 332 331 322 221

Règles du challenge

Vous pouvez prendre les jets dans n'importe quel format raisonnable, comme une liste de listes [[3,2,1],[4,2,1]], une liste de chaînes ["321","421"], une liste d'entiers [321,421], etc. Cependant, chaque dé doit être clairement identifiable avec une valeur de 1 à 6 .
Pour chaque lancer, vous pouvez supposer que les dés sont triés du plus bas au plus élevé ou du plus élevé au plus bas, tant qu'ils sont cohérents. Veuillez indiquer dans votre réponse quelle commande vous attendez, le cas échéant.
La réponse la plus courte en octets gagne!

Cas de test

Utilisation de listes de chaînes avec les dés triés du plus haut au plus bas:

Contributions

[ "321", "654" ]
[ "222", "321", "211" ]
[ "333", "311", "331", "111" ]
[ "111", "222", "333", "444" ]
[ "321", "421", "521", "621" ]
[ "422", "221", "442", "421", "222" ]
[ "222", "111", "421", "211", "651", "652", "543" ]

Résultats attendus

[ "654", "321" ]
[ "211", "222", "321" ]
[ "111", "311", "333", "331" ]
[ "111", "444", "333", "222" ]
[ "421", "321", "621", "521" ]
[ "421", "222", "442", "422", "221" ]
[ "421", "111", "211", "222", "543", "652", "651" ]

code-golf game sorting Arnauld
la source

Le tri doit-il être stable?

Erik the Outgolfer le

@EriktheOutgolfer Tous les rouleaux sont distincts et deux rouleaux peuvent toujours être triés selon les règles des égalités.

Arnauld

Serait-il OK de prendre chaque dé comme 0-5 au lieu de 1-6 (par exemple 012au lieu de 123)?

wastl

@wastl je vais dire non. Le format est flexible mais les valeurs des dés doivent être dans [1 ... 6].

Arnauld

Tu portes des dés au pub?

Beta Decay

6

Python , 93 octets

lambda a:sorted(a,key=lambda x:(x!=421,x>111,-(x%100<12)*x-(x%111<1)*x*.9,(x%111==99)*-x,-x))

Essayez-le en ligne!

Lynn
la source

Qu'est-ce qui rend cela spécifique à Python 2?

Solomon Ucko

@SolomonUcko Rien , mais je suppose qu'il est marqué comme Python 2 car il a été généré automatiquement par le modèle de soumission de code de golf de TIO.

M. Xcoder

1

Vous pouvez économiser 2 octets en utilisant le fait que 111 = 37 * 3 (et seuls les triplets xxx parmi tous les triplets possibles sont divisibles par 37) Essayez-le en ligne!

digEmAll

1

Vous pouvez perdre 2 octets en triant en place avec la sortméthode.

Jakob

4

Retina 0.8.2 , 67 octets

O$#^`(421|111)|(\d)((11)|\2\2)|(654|543|432|321)|\d{3}
$1$2$#4$#5$&

Essayez-le en ligne! Le lien inclut des cas de test. Explication: La clé de tri numérique est générée comme suit:

421     42100421
111     11100111
611-211   610611-  210211
666-222   600666-  600222
654-321    01654-   01321
653-221    00653-   00221

Neil
la source

@Arnauld Désolé, je n'avais pas réalisé que j'avais mélangé ces cas. Heureusement, je pense que j'ai pu le réparer pour le même nombre d'octets.

Neil

Maintenant, ça va bien.

Arnauld

4

Gelée , 37 34 octets

;Ø1,ẋ3$)Ẏṙ-;‘r’Ɗ€;œċ3$Ṇ63¦
6RṚÇiµÞ

Un lien monadique acceptant une liste de listes de lancers de dés (chaque tri décroissant) qui donne les lancers triés décroissant.

Essayez-le en ligne! Ou consultez une suite de tests ... ou essayez tous les rouleaux triés lexicographiquement

Comment?

Cette méthode génère une liste de tous les rouleaux du plus élevé au plus bas *, en remplaçant [4,2,1]avec 0(un rouleau d'entrée invalide), afin de classer chaque rouleau à l' aide du premier indice du atome de gelée i.

* La liste comprend également des répétitions et des entrées redondantes qui n'affecteront pas le comportement:

[[1,1,1],[6,1,1],[6,6,6],[5,1,1],[5,5,5],[4,1,1],[4,4,4],[3,1,1],[3,3,3],[2,1,1],[2,2,2],[1,1,1],[7,6,5],[6,5,4],[5,4,3],[4,3,2],[3,2,1],[2,1,0],[6,6,6],[6,6,5],[6,6,4],[6,6,3],[6,6,2],[6,6,1],[6,5,5],[6,5,4],[6,5,3],[6,5,2],[6,5,1],[6,4,4],[6,4,3],[6,4,2],[6,4,1],[6,3,3],[6,3,2],[6,3,1],[6,2,2],[6,2,1],[6,1,1],[5,5,5],[5,5,4],[5,5,3],[5,5,2],[5,5,1],[5,4,4],[5,4,3],[5,4,2],[5,4,1],[5,3,3],[5,3,2],[5,3,1],[5,2,2],[5,2,1],[5,1,1],[4,4,4],[4,4,3],[4,4,2],[4,4,1],[4,3,3],[4,3,2],[4,3,1],[4,2,2],0,[4,1,1],[3,3,3],[3,3,2],[3,3,1],[3,2,2],[3,2,1],[3,1,1],[2,2,2],[2,2,1],[2,1,1],[1,1,1]]

;Ø1,ẋ3$)Ẏṙ-;‘r’Ɗ€;œċ3$Ṇ63¦ - Link 1, build rolls: descending pips, P  e.g. [6,5,4,3,2,1]
       )                   - for each:       e.g. X=5
 Ø1                        -   literal [1,1]
;                          -   concatenate        [5,1,1]
      $                    -   last two links as a monad (f(X)):
     3                     -     literal 3
    ẋ                      -     repeat           [5,5,5]
   ,                       -   pair               [[5,1,1],[5,5,5]]
        Ẏ                  - tighten (to a list of rolls rather than pairs of rolls)
          -                - literal -1
         ṙ                 - rotate left by (make rightmost [1,1,1] the leftmost entry)
               Ɗ€          - for €ach: last three links as a monad (f(X)):
            ‘              -   increment  -> X+1
              ’            -   decrement  -> X-1
             r             -   range      -> [X+1,X,X-1]
                           -   ...note: [7,6,5] and [2,1,0] are made but are redundant
           ;               - concatenate
                     $     - last two links as a monad (f(P)):
                    3      -   literal 3
                  œċ       -   combinations with replacement -> [[6,6,6],[6,6,5],...,[6,6,1],[6,5,5],...,[1,1,1]]
                 ;         - concatenate
                         ¦ - sparse application...
                       63  - ...to indices: 63
                      Ṇ    - ...what: NOT   -> replaces the [4,2,1] entry with a 0

6RṚÇiµÞ - Main Link: list of rolls
     µÞ - sort by the monadic link:
6       -   six
 R      -   range -> [1,2,3,4,5,6]
  Ṛ     -   reverse -> [6,5,4,3,2,1]
   Ç    -   call the last link as a monad -> [[1,1,1],[6,1,1],[6,6,6],[5,1,1],...]
    i   -   first index of (e.g.: [1,1,1]->1 or [6,1,1]->2 or [4,2,1]->0)

Jonathan Allan
la source

3

R , 73 octets

(x=scan())[order(x!=421,x>111,-(x%%100<12)*x-(!x%%37)*x*.9,x%%37!=25,-x)]

Essayez-le en ligne!

Programme complet prenant une liste d'entiers de stdin et les renvoyant dans l'ordre décroissant (ie 421 ... 221)
Commencé comme partiellement inspiré par la réponse de @Lynn , il s'agit maintenant essentiellement d'un portage ... donc crédit à @Lynn;)
Enregistré 2 octets obtenant le reste de la division x % 37au lieu de111

Explication:

Pour chacun des nombres, 5 clés sont calculées et utilisées hiérarchiquement pour trier le tableau:

key1 = 0 if equal to 421, 1 otherwise
key2 = 0 if equal to 111, 1 otherwise
key3 = 0 
       - 1.0*x if number is x11 numbers (2 aces)
       - 0.9*x if number is xxx numbers (3 of a kind)
key4 = 0 if number is a straight, 1 otherwise
key5 = -x

Then the array is sorted by key1 first, then by key2 in case of tie and so on...

digEmAll
la source

2

05AB1E , 76 48 45 octets

421X3∍6LR©vy11«y3∍}®vy>y<ŸJ})D®3ãJsм)˜©IΣ®sk>

~~Cela s'est avéré être beaucoup plus long que prévu, mais au moins, il est facile à mettre en œuvre. Va voir si je peux trouver une meilleure solution .. J'ai~~ fait la liste à la main maintenant, mais quand même un peu longue.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

421             # Push 421 to the stack
X3∍             # ('1' lengthened to size 3) Push 111 to the stack
6LR             # Take the range [6, 1]
   ©            # Save this range in the register so we can re-use it
   v    }       # Loop over this range:
    y11«        #  Merge '11' with the current number `y`, and push it to the stack
    y3∍         #  Lengthen the current number `y` to size 3, and push it to the stack
   ®v      }    # Load the range [6, 1] from the register, and loop over it again:
     y>y<Ÿ      #  Take the range [`y+1`, `y-1`]
          J     #  And join them together to single 3-digit numbers
)               # Push everything that's now on the stack to a single list
 D              # Duplicate this list
  ®             # Load the range [6, 1] from the register again
   3ã           # Take the cartesian repeated three times
     R          # Reverse this list
      J         # Join every inner list to a single 3-digit number
 s              # Swap, so the duplicate list of above is at the top of the stack again
  м             # And remove all those items from the cartesian list
   )            # Combine both lists (as list of lists)
    ˜           # Flatten it
     ©          # Store this full completed list (now equal to the challenge description,
                #  with some additional values we can ignore) in the register
I               # Take the input-list
 Σ              # Sort it by:
  ®             #  The list we generated above
   sk           #  Take the 0-indexed indices
     >          #  And increase it by 1 (because apparently 0 is placed at the back,
                #  so '421' would always be at the end)

Voici la liste réelle générée par la première partie du code:

['421','111','611','666','511','555','411','444','311','333','211','222','111','111','765','654','543','432','321','210','','665','664','663','662','661','656','655','','653','652','651','646','645','644','643','642','641','636','635','634','633','632','631','626','625','624','623','622','621','616','615','614','613','612','','566','565','564','563','562','561','556','','554','553','552','551','546','545','544','','542','541','536','535','534','533','532','531','526','525','524','523','522','521','516','515','514','513','512','','466','465','464','463','462','461','456','455','454','453','452','451','446','445','','443','442','441','436','435','434','433','','431','426','425','424','423','422','','416','415','414','413','412','','366','365','364','363','362','361','356','355','354','353','352','351','346','345','344','343','342','341','336','335','334','','332','331','326','325','324','323','322','','316','315','314','313','312','','266','265','264','263','262','261','256','255','254','253','252','251','246','245','244','243','242','241','236','235','234','233','232','231','226','225','224','223','','221','216','215','214','213','212','','166','165','164','163','162','161','156','155','154','153','152','151','146','145','144','143','142','141','136','135','134','133','132','131','126','125','124','123','122','121','116','115','114','113','112','']

Essayez-le en ligne.

Comme vous pouvez le voir, il contient des éléments vides; des nombres comme 765ou 210; et les nombres dans la plage [216, 112]. Mais nous pouvons tous les ignorer, car les éléments que nous voulons réellement trier sont dans le bon ordre.

Solution originale de 76 octets:

Σ•X˜„Éε´õñ€9Ú ù?ä0₅9úd5àPÎøŒccuĆYÑ,o¾eíË¿¼À8@gID=vÆOΣxjF¨O‡J₃^εR™\èv•667вsk>

Essayez-le en ligne ~~ou vérifiez tous les cas de test~~ (pas de suite de tests car il y a toujours un bogue avec le tri par les numéros compressés ne voyant pas le crochet fermant pour arrêter le tri ).

Explication:

Σ             # Sort by:
 •...•667в    #  The correctly sorted list of all possible rolls from the challenge
 sk           #  Take the 0-indexed indices
   >          #  And increase it by 1 (because apparently 0 is placed at the back,
              #  so '421' would always be at the end)

Explication •X˜„Éε´õñ€9Ú ù?ä0₅9úd5àPÎøŒccuĆYÑ,o¾eíË¿¼À8@gID=vÆOΣxjF¨O‡J₃^εR™\èv•667в:

Tout entre les deux •est un nombre compressé généré avec le programme suivant:

Z>β 255B

Essayez-le en ligne.

Z>: Prenez le maximum de la liste + 1 ( 667dans ce cas)
β: Convertir la liste de Base- 667en un seul numéro
255B: Et convertissez ce numéro unique en base 255(en utilisant la page de code de 05AB1E), nous avons donc notre numéro compressé .

En l'utilisant, 667вil convertit ce nombre compressé dans la liste d'origine.

Kevin Cruijssen
la source

2

JavaScript (ES7), 96 octets

d=>d.sort((a,b,g=(n,[x,y,z]=n)=>n**=n-421?y*z-1?x-y|y-z?~y%x|~z%y?1:2:3:x-1?3.1:5:5)=>g(b)-g(a))

Trie les rouleaux en adhérant étroitement aux règles de notation. Attend un tableau de chaînes avec des rouleaux individuels dans l'ordre décroissant de valeur, par exemple["654"]

Essayez-le en ligne!

Explication

Les catégories de rouleaux sont portées aux exposants suivants:

421                 5
Three Aces          5
Two Aces            3.1
Three-of-a-Kind     3
Straights           2
Other               1

Non golfé

Déballer mentalement les vérifications conditionnelles me donne mal à la tête, et je suis certain que cela peut en quelque sorte être approfondi ...

var f =
d => d.sort(
    (
     a, b,
     g = (n, [x, y, z] = n) =>               // destructure rolls, e.g. "321" => ["3","2","1"]
        n **=                                // differentiate scores by raising to the exponent corresponding to its category in the table above
                                             // all conditionals check for a falsy value
            n - 421
                ? y * z - 1                  // ends with "11"
                    ? x - y | y - z          // three-of-a-kind
                        ? ~y % x | ~z % y    // straights, with operators chosen to correctly convert strings to numbers
                            ? 1
                            : 2
                        : 3
                    : x - 1                  // three aces
                        ? 3.1
                        : 5
                : 5
    ) =>
    g(b) - g(a)
)

redondance
la source

1

Javascript, 101 caractères, 116 octets (UTF-8)

a=>(r=d=>(i="ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ".indexOf(String.fromCharCode(d)),i<0?700-d:i),a.sort((a,b)=>r(a)-r(b)))

Prend un tableau de nombres représentant les rouleaux comme [ 321, 654 ].

Essayez-le en ligne!

Explication:

Je pris la première 16 des 56 possibles rouleaux distincts (ceux qui ne suivent pas vraiment un ordre) et je les encodée en chaîne: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Chaque caractère de cette chaîne correspond aux 16 premiers rouleaux possibles ( ƥis 421, ois 111, ...). Maintenant, pour chacun des deux éléments aet bdu tableau, nous vérifions simplement leur index à partir de la chaîne, s'ils sont inclus, l'index est utilisé, sinon (l'index est -1) nous utilisons le numéro de rôle lui-même (nous le soustrayons 700pour inverser l'ordre des ceux non inclus, c'est- à- dire pour les trier par ordre décroissant).

ibrahim mahrir
la source

NB: Sauf indication contraire, la longueur du code est toujours mesurée en octets. Le nombre de caractères peut parfois être pertinent, mais je ne pense pas qu'il soit ici. Méta-réponse pertinente .

Arnauld

@Arnauld Ouais! BTW c'est moi qui ai posé cette méta-question ;-)

ibrahim mahrir

1

Oh! J'ai complètement raté ce détail ...: D

Arnauld

1

Nettoyer , 169 102 octets

Tous les échappements octaux sont comptés comme un octet, car le compilateur Clean les prendra volontiers de cette façon, mais TIO et SE ne le feront pas parce qu'ils ne sont pas bien formés UTF-8.

import StdEnv
$l=[e\\c<-:"\245\157\143\232\377\53\233\274\67\115\323\336\216\37\260\101\231\230\227\226\225\217\215\214\213\204\203\202\201\171\170\167\156\155\52\51\50\47\40\36\35\25\24\23\n\11\273\272\271\261\257\246\114\113\102\335",e<-l|c==toChar e]

Essayez-le en ligne!

Utilise le fait que tous les lancers de dés, en tant qu'entiers modulo 256, sont uniques.
Idéalement, il Charest traité (principalement) comme un entier modulo 256.

Οurous
la source

1

Pyth , 48 octets

oxs[]j421T]j7 2_sm+Ld,,ddjT9tS6_m_+LdS3 4.C_S6 3

Attend l'entrée en tant que tableau imbriqué, chaque élément étant ordonné décroissant. Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

oxs[]j421T]j7 2_sm+Ld,,ddjT9tS6_m_+LdS3 4.C_S6 3)NQ   Final 3 tokens inferred from context
                                                      Implicit: Q=eval(input()), T=10
    ]j421T                                            Convert 421 to base 10, wrap in array -> [[4,2,1]]
          ]j7 2                                       Convert 7 to base 2, wrap in array -> [[1,1,1]]
                 m          tS6                       Map d in [2,3,4,5,6] using:
                      ,dd                               [d,d]
                         jT9                            Convert 10 to base 9 -> [1,1]
                  +Ld,                                  Prepend d to each of the above
               _s                                     Flatten and reverse -> [[6,1,1],[6,6,6]...[2,2,2]]
                                m       4             Map d in [0,1,2,3] using:
                                  +LdS3                 [d+1,d+2,d+3]
                                 _                      Reverse the above
                               _                      Reverse the result -> [[6,5,4]...[3,2,1]]
                                           _S6        [6,5,4,3,2,1]
                                         .C    3      All 3-element combinations of the above, respecting order
  s[                                            )     Wrap the 5 previous sections in an array, concatenate
ox                                               NQ   Order Q using each element's index in the above list

Sok
la source

1

05AB1E , 24 octets

Σ5βËyθyP‚yнÃ6βyË_y¥PΘy)(

Essayez-le en ligne!

Algorithme global:

Σ          )( # sort by the following, in decreasing priority:
 5βË          # 1 for 421, 0 otherwise
 yθyP‚yнÃ6β   # 7 for 111, X for XXX and X11, 0 otherwise
 yË_          # 0 for XXX, 1 otherwise
 y¥PΘ         # 1 for sequences, 0 otherwise
 y            # the roll itself

Détails:

5β          # parse the roll as a base-5 number
  Ë         # are all digits equal? (base-5 421 is 111)

yθ          # last die (equal to the 1st die iff we have XXX)
  yP        # product of dice (equal to the 1st die iff we have X11)
    ‚       # wrap the two in an array
     yнÃ    # keep only those that are equal to the 1st die
        6β  # parse as a base-6 number (111 -> [1, 1] -> 7)

yË          # are all dice equal?
  _         # boolean negation

y¥          # deltas ([a, b, c] -> [b - a, c - b])
  P         # product
   Θ        # 1 if it's equal to 1, 0 otherwise

Grimmy
la source

Pratiquons les règles de score de 421!

Tâche

Notation de base

Établir des liens

Règles du challenge

Cas de test

Contributions

Résultats attendus

Réponses:

Python , 93 octets

Retina 0.8.2 , 67 octets

Gelée , 37 34 octets

Comment?

R , 73 octets

05AB1E , 76 48 45 octets

Solution originale de 76 octets:

JavaScript (ES7), 96 octets

Explication

Javascript, 101 caractères, 116 octets (UTF-8)

Nettoyer , 169 102 octets

Pyth , 48 octets

05AB1E , 24 octets