421 ist ein sehr beliebtes Würfelspiel in Frankreich und einigen anderen europäischen Ländern. Es wird meistens in Bars und Pubs gespielt, um zu bestimmen, wer die nächste Runde Getränke kauft. Das komplette Spiel wird normalerweise in zwei Runden gespielt, wobei jeder Spieler versucht, die Spielsteine ​​loszuwerden, was hier jedoch nicht relevant ist. ( Wikipedia-Seite in Französisch.)

Das Spiel wird mit 3 Standardwürfeln gespielt.

Aufgabe

Ihre Aufgabe ist es, eine nicht leere Liste verschiedener 3-Würfel-Würfe [X, Y, Z] von der höchsten zur niedrigsten zu sortieren , indem Sie die Bewertungsregeln dieses Spiels anwenden.

Grundbewertung

• 4,2,1 ist die höchstmögliche Kombination. Je nach Regel kann es 8, 10 oder 11 Punkte geben. Da wir die Rollen sortieren, anstatt die Punkte zu zählen, spielt der genaue Wert keine Rolle.
• Drei Asse: 1,1,1 ist die zweithöchste Kombination und bringt 7 Punkte.
• Zwei Asse: X, 1,1 (wobei X 2 bis 6 ist) bringt X Punkte.
• Three-of-a-Kind: X, X, X (wobei X 2 bis 6 ist) bringt X Punkte.
• Straights: X, X + 1, X + 2 bringt 2 Punkte.
• Alle anderen Würfe erhalten 1 Punkt.

Krawatten schließen

Immer wenn zwei Würfe die gleiche Punktzahl ergeben, gelten folgende Regeln:

• Ein Two-Aces ist besser als ein Three-of-a-Kind. Beispiel: 5,1,1 Schläge 5,5,5 .
• Der Three-of-a-Kind 2,2,2 ist besser als eine Straße. Beispiel: 2,2,2 schlägt 4,5,6 .
• Die Geraden werden von der niedrigsten zur höchsten geordnet. Beispiel: 4,5,6 Schläge 2,3,4 .
• Alle anderen Würfe werden durch Sortieren der Würfel vom höchsten zum niedrigsten Wert abgerechnet. Beispiel: 6,5,2 schlägt 6,4,3 . (Daher ist die niedrigstmögliche Kombination im Spiel 2,2,1 .)

Nachfolgend sind die 56 möglichen unterschiedlichen Rollen aufgeführt, die vom höchsten zum niedrigsten sortiert sind:

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

Herausforderungsregeln

• Sie können die Würfel in jedem vernünftigen Format nehmen, z. B. in Form einer Liste von Listen [[3,2,1],[4,2,1]], einer Liste von Zeichenfolgen ["321","421"], einer Liste von ganzen Zahlen [321,421]usw. Jeder Würfel muss jedoch mit einem Wert von 1 bis 6 eindeutig identifizierbar sein .
• Bei jedem Wurf können Sie davon ausgehen, dass die Würfel entweder vom niedrigsten zum höchsten oder vom höchsten zum niedrigsten sortiert sind, sofern dies konsistent ist. Bitte geben Sie in Ihrer Antwort an, welche Bestellung Sie erwarten.
• Die kürzeste Antwort in Bytes gewinnt!

Testfälle

Verwenden von Saitenlisten mit den Würfeln von der höchsten zur niedrigsten Sortierung:

Eingänge

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

Erwartete Ergebnisse

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

Probieren Sie es online!

Retina 0.8.2 , 67 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung: Der numerische Sortierschlüssel wird wie folgt generiert:

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

Jelly ,  37  34 Bytes

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

Ein monadischer Link, der eine Liste mit Listen von Würfeln akzeptiert (jeweils absteigend sortiert), wodurch die sortierten Würfel absteigend sortiert werden.

Probieren Sie es online! Oder schauen Sie sich eine Testsuite an ... oder probieren Sie alle Rollen lexikographisch sortiert aus

Wie?

Diese Methode erstellt eine Liste aller Würfe vom höchsten bis zum niedrigsten * und ersetzt sie [4,2,1]durch 0(ein ungültiger Eingabe-Wurf), um jeden Wurf nach Jellys erstem Atomindex zu ordnen i.

* Die Liste enthält auch Wiederholungen und redundante Einträge, die das Verhalten nicht beeinflussen:

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

Probieren Sie es online!

• Vollständiges Programm, das eine Liste von Ganzzahlen aus stdin entnimmt und in absteigender Reihenfolge zurückgibt (dh 421 ... 221)
• Begonnen als teilweise inspiriert von @Lynn Antwort , ist jetzt im Grunde eine Portierung davon ... also Credits an @Lynn;)
• Gespeicherte 2 Bytes erhalten Divisionsrest x % 37statt111

Erklärung:

Für jede der Zahlen werden 5 Schlüssel berechnet und hierarchisch zum Sortieren des Arrays verwendet:

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>

Es stellte sich heraus, dass dies viel länger als erwartet war, aber zumindest ist es einfach zu implementieren. Mal sehen, ob ich eine bessere Lösung finden kann .. Hab die Liste jetzt von Hand gemacht, aber immer noch ein bisschen lang.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

Hier ist die aktuelle Liste, die der erste Teil des Codes generiert:

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

Probieren Sie es online aus.

Wie Sie sehen, enthält es leere Elemente. Zahlen wie 765oder 210; und Zahlen im Bereich [216, 112]. Wir können diese jedoch alle ignorieren, da die Elemente, die wir sortieren möchten, in der richtigen Reihenfolge vorliegen.

Ursprüngliche 76-Byte-Lösung:

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle (keine Testsuite, da es immer noch einen Fehler beim Sortieren mit komprimierten Zahlen gibt, bei dem die schließende Klammer nicht angezeigt wird, um das Sortieren zu stoppen ).

Erläuterung:

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

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

Alles zwischen den beiden •ist eine komprimierte Zahl , die mit dem folgenden Programm generiert wird:

Z>β 255B

Probieren Sie es online aus.

• Z>: Nimm das Maximum der Liste + 1 ( 667in diesem Fall)
• β: Konvertiert die Liste von Base- 667in eine einzelne Zahl
• 255B: Und konvertieren Sie diese einzelne Zahl in Basis 255(unter Verwendung der Codepage von 05AB1E), sodass wir unsere komprimierte Zahl haben .

Wenn Sie 667вes verwenden, wird diese komprimierte Zahl wieder in die ursprüngliche Liste konvertiert.

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

Sortiert Brötchen nach den Regeln der Wertung. Erwartet eine Reihe von Zeichenfolgen mit einzelnen Rollen in absteigender Reihenfolge des Werts, z["654"]

Probieren Sie es online!

Erläuterung

Rollenkategorien werden auf folgende Exponenten angehoben:

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

Ungolfed

Das geistige Auspacken der bedingten Schecks bereitet mir Kopfschmerzen, und ich bin mir sicher, dass es irgendwie noch weiter verbessert werden kann.

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

Nimmt eine Reihe von Zahlen, die die Rollen darstellen, wie [ 321, 654 ].

Probieren Sie es online!

Erläuterung:

Ich habe die ersten 16 der 56 möglichen verschiedenen Rollen (diejenigen , die wirklich keine Reihenfolge folgen) und ich codierte sich als String: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Jedes Zeichen dieser Zeichenfolge entspricht den ersten 16 möglichen Würfen ( ƥist 421, oist 111, ...). Jetzt überprüfen wir für jedes der beiden Elemente aund bdes Arrays nur ihren Index anhand der Zeichenfolge. Wenn sie enthalten sind, wird der Index verwendet. Andernfalls verwenden -1wir (der Index ist ) die Rollennummer selbst (wir subtrahieren sie von, 700um die Reihenfolge der Zeichenfolge umzukehren diejenigen, die nicht enthalten sind, dh um sie in absteigender Reihenfolge zu sortieren).

Sauber , 169 102 Bytes

Alle oktalen Escape-Zeichen werden als ein Byte gezählt, da der Clean-Compiler sie gerne auf diese Weise verarbeitet, TIO und SE jedoch nicht, da sie nicht in UTF-8-Form vorliegen.

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]

Probieren Sie es online!

Verwendet die Tatsache, dass alle Würfelwürfe als ganze Zahlen modulo 256 einzigartig sind.
Günstigerweise Charwird (meistens) als Modulo-256-Ganzzahl behandelt.

Pyth , 48 Bytes

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

Erwartet die Eingabe als verschachteltes Array, wobei jedes Element absteigend sortiert ist. Versuchen Sie es online hier oder überprüfen alle Testfälle auf einmal hier .

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 Byte

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

Probieren Sie es online!

Gesamtalgorithmus:

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

Einzelheiten:

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