421 es un juego de dados bastante popular en Francia y otros países europeos. Se juega principalmente en bares y pubs para determinar quién va a comprar la próxima ronda de bebidas. El juego completo generalmente se juega en dos rondas, con fichas de las que cada jugador intenta deshacerse, pero esto es irrelevante aquí. ( Página de Wikipedia en francés).

El juego se juega con 3 dados de cubo estándar.

Tarea

Su tarea es ordenar una lista no vacía de tiradas distintas de 3 dados [X, Y, Z] de mayor a menor, aplicando las reglas de puntuación de este juego.

Puntuación básica

• 4,2,1 es la combinación más alta posible. Dependiendo de las reglas, puede obtener 8, 10 u 11 puntos. Debido a que estamos clasificando los rollos en lugar de contar los puntos, el valor exacto no importa.
• Tres ases: 1,1,1 es la segunda combinación más alta y obtiene 7 puntos.
• Dos ases: X, 1,1 (donde X es de 2 a 6) obtiene X puntos.
• Trío: X, X, X (donde X es de 2 a 6) obtiene X puntos.
• Rectas: X, X + 1, X + 2 obtienen 2 puntos.
• Todos los otros rollos obtienen 1 punto.

Liquidación de lazos

Siempre que dos tiradas den el mismo número de puntos, se aplican las siguientes reglas:

• Un Two-Aces es mejor que un Three-of-a-Kind. Ejemplo: 5,1,1 vence a 5,5,5 .
• El Three-of-a-Kind 2,2,2 es mejor que una escalera. Ejemplo: 2,2,2 latidos 4,5,6 .
• Las rectas se ordenan de menor a mayor. Ejemplo: 4,5,6 latidos 2,3,4 .
• Todas las otras tiradas se resuelven clasificando los dados de mayor a menor. Ejemplo: 6,5,2 latidos 6,4,3 . (Por lo tanto, la combinación más baja posible en el juego es 2,2,1 .)

A continuación se muestran los 56 rollos distintos posibles ordenados de mayor a menor:

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

Reglas de desafío

• Puede tomar los rollos en cualquier formato razonable, como una lista de listas [[3,2,1],[4,2,1]], una lista de cadenas ["321","421"], una lista de enteros [321,421], etc. Sin embargo, cada dado debe ser claramente identificable con un valor del 1 al 6 .
• Para cada lanzamiento, puede suponer que los dados se ordenan de menor a mayor o de mayor a menor, siempre que sean consistentes. Indique en su respuesta el orden que espera, si corresponde.
• ¡La respuesta más corta en bytes gana!

Casos de prueba

Usando listas de cadenas con los dados ordenados de mayor a menor:

Entradas

[ "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" ]

Resultados esperados

[ "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" ]

Python , 93 bytes

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

Pruébalo en línea!

Retina 0.8.2 , 67 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación: La clave de clasificación numérica se genera de la siguiente manera:

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

Jalea ,  37  34 bytes

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

Un enlace monádico que acepta una lista de listas de tiradas de dados (cada una ordenada descendente) que produce las tiradas ordenadas descendentes.

Pruébalo en línea! O vea un conjunto de pruebas ... o pruebe todos los rollos ordenados lexicográficamente

¿Cómo?

Este método genera una lista de todos los rodillos de mayor a menor *, sustituyendo [4,2,1]con 0(un rodillo de entrada no válida), a fin de clasificar cada rollo usando primero-index-de átomo de jalea, i.

* La lista también incluye repeticiones y entradas redundantes que no afectarán el comportamiento:

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

R , 73 bytes

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

Pruébalo en línea!

• Programa completo que toma una lista de enteros de stdin y los devuelve en orden descendente (es decir 421 ... 221)
• Comenzó como parcialmente inspirado por respuesta de @Lynn , ahora es básicamente una transferencia de él ... así que los créditos a @Lynn;)
• Se guardaron 2 bytes obteniendo el resto de la división en x % 37lugar de111

Explicación

Para cada uno de los números, se calculan 5 teclas y se usan jerárquicamente para ordenar la matriz:

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

05AB1E , 76 48 45 bytes

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

Resultó ser mucho más largo de lo esperado, pero al menos es fácil de implementar. Veré si puedo encontrar una mejor solución. Hice la lista a mano ahora, pero aún un poco larga.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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)

Aquí está la lista real que genera la primera parte del código:

['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','']

Pruébalo en línea.

Como puede ver, contiene elementos vacíos; números como 765o 210; y números en el rango [216, 112]. Pero todos podemos ignorarlos, porque los elementos que queremos clasificar están en el orden correcto.

Solución original de 76 bytes:

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

Pruébelo en línea o verifique todos los casos de prueba (no hay un conjunto de pruebas porque todavía hay un error con la clasificación por números comprimidos que no ven el soporte de cierre para detener la clasificación) ).

Explicación:

Σ             # 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)

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

Todo entre los dos •es un número comprimido que se genera con el siguiente programa:

Z>β 255B

Pruébalo en línea.

• Z>: Tome el máximo de la lista + 1 ( 667en este caso)
• β: Convierta la lista de Base 667a un solo número
• 255B: Y convierta ese número único en base 255(usando la página de códigos 05AB1E), para que tengamos nuestro número comprimido .

Al usarlo 667в, este número comprimido vuelve a la lista original.

JavaScript (ES7), 96 bytes

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

Ordena los rollos siguiendo estrictamente las reglas de puntuación. Espera una serie de cadenas con rollos individuales en orden descendente de valor, por ejemplo["654"]

Pruébalo en línea!

Explicación

Las categorías de rollos se elevan a los siguientes exponentes:

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

Sin golf

Mentalmente desenvolver los cheques condicionales me da dolor de cabeza, y estoy seguro de que de alguna manera se puede seguir jugando ...

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

Javascript, 101 caracteres, 116 bytes (UTF-8)

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

Toma una serie de números que representan los rollos como [ 321, 654 ] .

Pruébalo en línea!

Explicación:

Tomé el primer 16 de los 56 posibles rollos distintas (las que en realidad no sigue ningún orden) y les codificado como una cadena: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Cada carácter de esta cadena corresponde a los primeros 16 rollos posibles ( ƥes 421, oes 111, ...). Ahora, para cada dos elementos ay bde la matriz, solo verificamos su índice de la cadena, si están incluidos, se usa el índice; de ​​lo contrario (el índice es -1), usamos el número de rollo en sí (lo restamos 700para invertir el orden de no incluidos, es decir , ordenarlos en orden decreciente).

Limpio , 169 102 bytes

Todos los escapes octales se cuentan como un byte, ya que el compilador Clean los tomará felizmente de esa manera, pero TIO y SE no lo harán porque no están bien formados 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]

Pruébalo en línea!

Utiliza el hecho de que todas las tiradas de dados, como números enteros módulo 256, son únicas.
Convenientemente, Charse trata (principalmente) como un módulo entero de 256.

Pyth , 48 bytes

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

Espera entrada como una matriz anidada, cada elemento ordenado descendente. Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

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

05AB1E , 24 bytes

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

Pruébalo en línea!

Algoritmo general:

Σ          )( # 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

Detalles:

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