Esercitiamoci con le regole del punteggio di 421!


13

421 è un gioco di dadi piuttosto popolare in Francia e in altri paesi europei. Si gioca principalmente nei bar e nei pub per determinare chi comprerà il prossimo giro di drink. Il gioco completo di solito si gioca in due turni, con gettoni che ogni giocatore cerca di eliminare, ma questo è irrilevante qui. ( Pagina Wikipedia in francese.)

Il gioco si gioca con 3 dadi cubi standard.

Compito

Il tuo compito è quello di ordinare un elenco non vuoto di tiri a 3 dadi distinti [X, Y, Z] dal più alto al più basso, applicando le regole del punteggio di questo gioco.

Punteggio di base

  • 4,2,1 è la combinazione più alta possibile. A seconda delle regole, può segnare 8, 10 o 11 punti. Poiché stiamo ordinando i tiri anziché contare i punti, il valore esatto non ha importanza.
  • Tre assi: 1,1,1 è la seconda combinazione più alta e ottiene 7 punti.
  • Due assi: X, 1,1 (dove X è da 2 a 6) segna X punti.
  • Tris: X, X, X (dove X è da 2 a 6) ottiene X punti.
  • Scala: X, X + 1, X + 2 segna 2 punti.
  • Tutti gli altri tiri segnano 1 punto.

Legami di insediamento

Ogni volta che due tiri danno lo stesso numero di punti, si applicano le seguenti regole:

  • Un due assi è meglio di un tris. Esempio: 5,1,1 battiti 5,5,5 .
  • Il Three-of-a-Kind 2,2,2 è meglio di una scala. Esempio: 2,2,2 battiti 4,5,6 .
  • I rettilinei sono ordinati dal più basso al più alto. Esempio: 4,5,6 battiti 2,3,4 .
  • Tutti gli altri tiri vengono risolti ordinando i dadi dal più alto al più basso. Esempio: 6,5,2 battiti 6,4,3 . (Pertanto, la combinazione più bassa possibile nel gioco è 2,2,1 .)

Di seguito sono riportati i 56 possibili rotoli distinti ordinati dal più alto al più basso:

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

Regole della sfida

  • Puoi prendere i tiri in qualsiasi formato ragionevole, come un elenco di elenchi [[3,2,1],[4,2,1]], un elenco di stringhe ["321","421"], un elenco di numeri interi [321,421], ecc. Tuttavia, ogni dado deve essere chiaramente identificabile con un valore compreso tra 1 e 6 .
  • Per ogni lancio, puoi presumere che i dadi siano ordinati dal più basso al più alto o dal più alto al più basso, purché sia ​​coerente. Indica nella tua risposta quale ordine ti aspetti, se presente.
  • Vince la risposta più breve in byte!

Casi test

Utilizzo di elenchi di stringhe con i dadi ordinati dal più alto al più basso:

ingressi

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

Uscite attese

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

L'ordinamento dovrebbe essere stabile?
Erik the Outgolfer,

@EriktheOutgolfer Tutti i rotoli sono distinti e due rotoli possono sempre essere ordinati in base alle regole dei legami.
Arnauld,

Sarebbe OK prendere ogni dado come 0-5 invece di 1-6 (es. 012Invece di 123)?
wastl,

@wastl sto per dire di no. Il formato è flessibile ma i valori dei dadi devono essere in [1 ... 6].
Arnauld,

Portate i dadi al pub?
Decadimento beta

Risposte:


6

Python , 93 byte

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

Provalo online!


Cosa rende questo specifico per Python 2?
Solomon Ucko,

@SolomonUcko Niente , ma immagino che sia contrassegnato come Python 2 perché è stato generato automaticamente dal modello di invio di Code Golf da TIO.
Mr. Xcoder,

1
Puoi salvare 2 byte usando il fatto che 111 = 37 * 3 (e solo le triple triple tra tutte le possibili terzine sono divisibili per 37) Provalo online!
digEmAll

1
Puoi perdere 2 byte ordinando sul posto con il sortmetodo.
Jakob,

4

Retina 0.8.2 , 67 byte

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

Provalo online! Il link include casi di test. Spiegazione: La chiave di ordinamento numerica viene generata come segue:

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

@Arnauld Siamo spiacenti, non mi ero reso conto di aver confuso quei casi. Fortunatamente penso di essere stato in grado di risolverlo per lo stesso numero di byte.
Neil,

Ora sta davvero bene.
Arnauld,

4

Gelatina ,  37  34 byte

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

Un collegamento monadico che accetta un elenco di elenchi di lanci di dadi (ciascuno in ordine decrescente) che produce i tiri in ordine decrescente.

Provalo online! O vedi una suite di test ... o prova tutti i rotoli ordinati lessicograficamente

Come?

Questo metodo crea un elenco di tutti i rotoli da decrescente *, sostituendo [4,2,1]con 0(a cilindro di ingresso valido), al fine di rango ogni rullo utilizzando Jelly primo indice dell'atomo, i.

* L'elenco include anche ripetizioni e voci ridondanti che non influiscono sul 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)

3

R , 73 byte

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

Provalo online!

  • Programma completo che prende un elenco di numeri interi da stdin e li restituisce in ordine decrescente (cioè 421 ... 221)
  • Iniziato come parzialmente ispirato dalla risposta di @Lynn , ora è sostanzialmente un porting di esso ... quindi crediti a @Lynn;)
  • Salvato 2 byte ottenendo il resto della divisione x % 37anziché111

Spiegazione :

Per ciascuno dei numeri vengono calcolate 5 chiavi e utilizzate gerarchicamente per ordinare l'array:

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

2

05AB1E , 76 48 45 byte

421X36LR©vy11«y3∍}®vy>yJ})D®3ãJsм)˜©IΣ®sk>

Questo si è rivelato molto più lungo del previsto, ma almeno è facile da implementare. Vedrò se riesco a trovare una soluzione migliore .. Ho fatto la lista a mano ora, ma ancora un po 'a lungo.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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)

Ecco l'elenco attuale generato dalla prima parte del codice:

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

Provalo online.

Come puoi vedere contiene oggetti vuoti; numeri come 765o 210; e numeri nell'intervallo [216, 112]. Ma possiamo ignorarli tutti, perché gli articoli che vogliamo effettivamente ordinare sono nell'ordine corretto.


Soluzione originale da 76 byte:

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

Provalo online o verifica tutti i casi di test (nessuna suite di test perché c'è ancora un bug con l'ordinamento con numeri compressi che non vedono la parentesi di chiusura per interrompere l'ordinamento ).

Spiegazione:

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

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

Tutto tra i due è a numero compresso che viene generato con il seguente programma:

Z 255B

Provalo online.

  • Z>: Prendi il massimo dell'elenco + 1 ( 667in questo caso)
  • β: Converti l'elenco dalla Base-667 a un singolo numero
  • 255B: E converti quel singolo numero in base 255(usando la tabella codici 05AB1E), quindi abbiamo il nostro numero compresso .

Usandolo 667вconverte questo numero compresso nella lista originale.


2

JavaScript (ES7), 96 byte

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

Ordina i rotoli aderendo strettamente alle regole del punteggio. Si aspetta una matrice di stringhe con singoli rotoli in ordine decrescente di valore, ad es["654"]

Provalo online!

Spiegazione

Le categorie di rulli vengono aumentate ai seguenti esponenti:

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

Ungolfed

Disimballare mentalmente i controlli condizionali mi dà mal di testa, e sono certo che in qualche modo può essere ulteriormente golfato ...

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

1

Javascript, 101 caratteri, 116 byte (UTF-8)

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

Prende una matrice di numeri che rappresentano i tiri come [ 321, 654 ].

Provalo online!

Spiegazione:

Presi il primo 16 dei 56 possibili lanci distinte (quelle che in realtà non seguono qualsiasi ordine) e li codificato come una stringa: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Ogni carattere di questa stringa corrisponde ai primi 16 tiri possibili ( ƥè 421, oè 111, ...). Ora per ogni due elementi ae bdell'array controlliamo semplicemente il loro indice dalla stringa, se sono inclusi viene usato l'indice, altrimenti (l'indice è -1) usiamo il numero del rotolo stesso (lo sottraggiamo da 700per invertire l'ordine del quelli non inclusi, ovvero ordinarli in ordine decrescente).


NB: Se non diversamente specificato, la lunghezza del codice viene sempre misurata in byte. Il numero di caratteri a volte può essere rilevante, ma non penso che sia qui. Meta risposta pertinente .
Arnauld,

@Arnauld Yeah! A proposito, sono io quello che ha posto questa meta domanda ;-)
ibrahim mahrir,

1
D'Oh! Ho perso del tutto questo dettaglio ...: D
Arnauld il

1

Pulito , 169 102 byte

Tutti gli escape ottali vengono conteggiati come un byte, poiché il compilatore Clean li prenderà felicemente in quel modo, ma TIO e SE non lo faranno perché non sono ben formati 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]

Provalo online!

Usa il fatto che tutti i tiri di dado, come numeri interi modulo 256, sono unici.
Convenientemente, Charviene trattato (principalmente) come un intero modulo 256.


1

Pyth , 48 byte

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

Si aspetta input come un array nidificato, ogni elemento ordinato in ordine decrescente. Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

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

1

05AB1E , 24 byte

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

Provalo online!

Algoritmo generale:

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

Dettagli:

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.