421 é um jogo de dados bastante popular na França e em alguns outros países europeus. É tocado principalmente em bares e pubs para determinar quem vai comprar a próxima rodada de bebidas. O jogo completo geralmente é jogado em duas rodadas, com fichas das quais cada jogador tenta se livrar, mas isso é irrelevante aqui. ( Página da Wikipedia em francês.)

O jogo é jogado com 3 dados de cubo padrão.

Tarefa

Sua tarefa é classificar uma lista não vazia de jogadas distintas de 3 dados [X, Y, Z] do maior para o menor, aplicando as regras de pontuação deste jogo.

Pontuação básica

• 4,2,1 é a combinação mais alta possível. Dependendo das regras, pode marcar 8, 10 ou 11 pontos. Como estamos classificando as jogadas em vez de contar os pontos, o valor exato não importa.
• Three Ases: 1,1,1 é a segunda combinação mais alta e marca 7 pontos.
• Dois Ases: X, 1,1 (onde X é 2 a 6) marca X pontos.
• Três do tipo: X, X, X (onde X é 2 a 6) obtém X pontos.
• Retas: X, X + 1, X + 2 marcam 2 pontos.
• Todos os outros testes marcam 1 ponto.

Estabelecendo laços

Sempre que duas jogadas dão o mesmo número de pontos, as seguintes regras se aplicam:

• Um dois ases é melhor que um três. Exemplo: 5,1,1 bate 5,5,5 .
• O Three-of-a-Kind 2,2,2 é melhor que um straight. Exemplo: 2,2,2 bate 4,5,6 .
• As retas são ordenadas do menor para o maior. Exemplo: 4,5,6 bate 2,3,4 .
• Todos os outros lançamentos são resolvidos ordenando os dados do maior para o menor. Exemplo: 6,5,2 bate 6,4,3 . (Portanto, a menor combinação possível no jogo é 2,2,1 .)

Abaixo estão os 56 possíveis rolos distintos, ordenados do maior para o 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

Regras do desafio

• Você pode fazer os testes em qualquer formato razoável, como uma lista de listas [[3,2,1],[4,2,1]], uma lista de strings ["321","421"], uma lista de números inteiros [321,421], etc. No entanto, cada dado deve ser claramente identificável com um valor de 1 a 6 .
• Para cada rolagem, você pode assumir que os dados são classificados do menor para o maior ou do maior para o menor, desde que sejam consistentes. Informe na sua resposta qual ordem você espera, se houver.
• A resposta mais curta em bytes vence!

Casos de teste

Usando listas de strings com os dados classificados do mais alto para o mais baixo:

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

Experimente online!

Retina 0.8.2 , 67 bytes

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

Experimente online! O link inclui casos de teste. Explicação: A chave de classificação numérica é gerada da seguinte maneira:

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

Geléia ,  37  34 bytes

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

Um link monádico que aceita uma lista de listas de jogadas de dados (cada uma descendente classificada) que produz as jogadas ordenadas descendentes.

Experimente online! Ou consulte uma suíte de testes ... ou tente todos os rolos classificados lexicograficamente

Quão?

Esse método cria uma lista de todos os rolos do maior para o menor *, substituindo [4,2,1]por 0(um rolo de entrada inválido), para classificar cada rolo usando o primeiro átomo de Jelly do índice de Jelly i,.

* A lista também inclui entradas repetidas e redundantes que não afetam o comportamento:

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

Experimente online!

• Programa completo, pegando uma lista de números inteiros de stdin e retornando-os em ordem decrescente (ou seja, 421 ... 221 )
• Iniciado como parcialmente inspirado por resposta @Lynn , agora é basicamente uma transferência ... portanto, créditos para @Lynn;)
• Economizou 2 bytes, obtendo o restante da divisão em x % 37vez de111

Explicação:

Para cada um dos números, 5 chaves são calculadas e usadas hierarquicamente para classificar a 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>

Acabou sendo muito mais longo do que o esperado, mas pelo menos é fácil de implementar. Vou ver se consigo encontrar uma solução melhor. Fiz a lista à mão agora, mas ainda um pouco longa.

Experimente online ou verifique todos os casos de teste .

Explicação:

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)

Aqui está a lista real que a primeira parte do código gera:

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

Experimente online.

Como você pode ver, ele contém itens vazios; números como 765ou 210; e números no intervalo [216, 112]. Mas todos podemos ignorá-los, porque os itens que realmente queremos classificar estão na ordem correta.

Solução 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>

Experimente on-line ou verifique todos os casos de teste (não há suíte de testes porque ainda há um erro de classificação por números compactados que não vê o colchete de fechamento para interromper a classificação ).

Explicação:

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

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

Tudo entre os dois •é um número compactado que é gerado com o seguinte programa:

Z>β 255B

Experimente online.

• Z>: Tire o máximo da lista + 1 ( 667neste caso)
• β: Converta a lista da Base 667em um único número
• 255B: E converta esse número único em base 255(usando a página de códigos do 05AB1E), para que tenhamos nosso número compactado .

Ao usá- 667вlo, esse número compactado é convertido novamente na 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))

Classifica os rolos aderindo de perto às regras de pontuação. Espera uma matriz de strings com rolos individuais em ordem decrescente de valor, por exemplo["654"]

Experimente online!

Explicação

As categorias de rolos são aumentadas para os seguintes expoentes:

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

Ungolfed

Desembrulhar mentalmente as verificações condicionais me dá dor de cabeça, e tenho certeza de que de alguma forma pode ser ainda mais jogado ....

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 uma matriz de números representando os rolos como [ 321, 654 ].

Experimente online!

Explicação:

Tomei o primeiro 16 dos 56 possíveis rolos distintos (os que realmente não seguem qualquer ordem) e eu codificado-los como uma string: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Cada caractere dessa sequência corresponde aos 16 primeiros lançamentos possíveis ( ƥé 421, oé 111, ...). Agora, para cada dois elementos ae bda matriz, apenas verificamos seu índice a partir da string; se eles estão incluídos, o índice é usado; caso contrário (o índice é -1), usamos o número do rolo (subtraímos o valor 700para inverter a ordem do não incluídas, ou seja , para classificá-las em ordem decrescente).

Limpo , 169 102 bytes

Todas as fugas octais são contadas como um byte, pois o compilador Clean as aceita dessa maneira, mas o TIO e o SE não o fazem porque não são UTF-8 bem formados.

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]

Experimente online!

Usa o fato de que todos os lançamentos de dados, como números inteiros no módulo 256, são únicos.
Convenientemente, Charé tratado (principalmente) como um número inteiro de módulo 256.

Pitão , 48 bytes

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

Espera a entrada como uma matriz aninhada, cada elemento ordenado decrescente. Experimente online aqui ou verifique todos os casos de teste de uma vez aqui .

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

Experimente online!

Algoritmo geral:

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

Detalhes:

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