421 to dość popularna gra w kości we Francji i niektórych innych krajach europejskich. Najczęściej gra się w barach i pubach, aby ustalić, kto kupi kolejną rundę drinków. Pełna gra jest zwykle rozgrywana w dwóch rundach, z tokenami, których każdy gracz próbuje się pozbyć, ale tutaj nie ma to znaczenia. ( Strona Wikipedii w języku francuskim.)

W grę wchodzą 3 standardowe kostki kostki.

Zadanie

Twoim zadaniem jest posortowanie niepustej listy odrębnych rzutów 3-kostkami [X, Y, Z] od najwyższej do najniższej, stosując zasady punktacji w tej grze.

Podstawowa punktacja

• 4,2,1 to najwyższa możliwa kombinacja. W zależności od zasad może zdobyć 8, 10 lub 11 punktów. Ponieważ sortujemy rzuty, a nie liczymy punkty, dokładna wartość nie ma znaczenia.
• Three Aces: 1,1,1 jest drugą najwyższą kombinacją i zdobywa 7 punktów.
• Dwa asy: X, 1,1 (gdzie X wynosi od 2 do 6) zdobywa X punktów.
• Trójka: X, X, X (gdzie X wynosi od 2 do 6) zdobywa X punktów.
• Prostych: x, x + 1, x + 2 zdobywa 2 punkty.
• Wszystkie pozostałe rzuty dają 1 punkt.

Rozstrzyganie więzi

Ilekroć dwa rzuty dają tę samą liczbę punktów, obowiązują następujące zasady:

• Dwa asy są lepsze niż trójka. Przykład: 5,1,1 bije 5,5,5 .
• Trójka 2,2,2 jest lepsza niż strit. Przykład: 2,2,2 uderzenia 4,5,6 .
• Proste są uporządkowane od najniższej do najwyższej. Przykład: 4,5,6 bije 2,3,4 .
• Wszystkie pozostałe rzuty są rozstrzygane przez sortowanie kości od najwyższej do najniższej. Przykład: 6,5,2 uderzeń 6,4,3 . (Dlatego najniższa możliwa kombinacja w grze to 2,2,1 .)

Poniżej znajduje się 56 możliwych różnych rzutów uporządkowanych od najwyższej do najniższej:

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

Zasady wyzwania

• Możesz wziąć rzuty w dowolnym rozsądnym formacie, takim jak lista list [[3,2,1],[4,2,1]], lista ciągów ["321","421"], lista liczb całkowitych [321,421]itp. Jednak każda kość musi być wyraźnie identyfikowalna o wartości od 1 do 6 .
• Dla każdego rzutu można założyć, że kości są sortowane od najniższej do najwyższej lub od najwyższej do najniższej, o ile jest ona spójna. Podaj w swojej odpowiedzi, jakiej kolejności się spodziewasz.
• Najkrótsza odpowiedź w bajtach wygrywa!

Przypadki testowe

Używając list ciągów z kostkami posortowanymi od najwyższej do najniższej:

Wejścia

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

Oczekiwane wyniki

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

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

Wypróbuj online!

Retina 0.8.2 , 67 bajtów

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

Wypróbuj online! Link zawiera przypadki testowe. Objaśnienie: Numeryczny klucz sortowania jest generowany w następujący sposób:

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

Galaretka ,  37  34 bajtów

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

Monadyczny link akceptujący listę list rzutów kostką (każda posortowana malejąco), która daje posortowane wyniki malejące.

Wypróbuj online! Lub zobacz zestaw testowy ... lub wypróbuj wszystkie rolki posortowane leksykograficznie

W jaki sposób?

Metoda ta opiera się wszystkie rolki z najwyższej do najniższej *, zastępując [4,2,1]w 0(nieprawidłowej wałka wejściowego), aby przy pomocy stopnia każda rolka Jelly pierwszej Indeksu z atomu i.

* Lista obejmuje również powtórzenia i zbędne wpisy, które nie wpływają na zachowanie:

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

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

Wypróbuj online!

• Pełny program pobierający listę liczb całkowitych ze standardowego wejścia i zwracający je w malejącej kolejności (tj. 421 ... 221)
• Rozpoczęty jako częściowo zainspirowany odpowiedzią @Lynn , teraz jest w zasadzie przeniesieniem go ... więc przypisuje @Lynn;)
• Zaoszczędzono 2 bajty, x % 37zamiast reszty dzielenia111

Objaśnienie:

Dla każdej z liczb 5 kluczy jest obliczanych i używanych hierarchicznie do sortowania tablicy:

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 bajtów

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

Okazało się to o wiele dłużej niż oczekiwano, ale przynajmniej jest łatwe do wdrożenia. Zobaczę, czy uda mi się znaleźć lepsze rozwiązanie. Teraz sporządziłem listę ręcznie, ale wciąż trochę.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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)

Oto faktyczna lista, którą generuje pierwsza część kodu:

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

Wypróbuj online.

Jak widać, zawiera puste przedmioty; liczby takie jak 765lub 210; i liczby w zakresie [216, 112]. Ale wszyscy możemy je zignorować, ponieważ przedmioty, które chcemy sortować, są w odpowiedniej kolejności.

Oryginalne rozwiązanie o wielkości 76 bajtów:

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

Wypróbuj online lub sprawdź wszystkie przypadki testowe (brak zestawu testów, ponieważ nadal występuje błąd z sortowaniem według skompresowanych liczb, które nie widzą nawiasu zamykającego, aby zatrzymać sortowanie ).

Wyjaśnienie:

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

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

Wszystko między nimi •jest liczbą skompresowaną, która jest generowana za pomocą następującego programu:

Z>β 255B

Wypróbuj online.

• Z>: Weź maksimum z listy + 1 ( 667w tym przypadku)
• β: Konwertuj listę z Base- 667na pojedynczy numer
• 255B: I przekonwertuj ten pojedynczy numer na bazowy 255(używając strony kodowej 05AB1E), więc mamy nasz skompresowany numer .

Za pomocą 667вtego konwertuje ten skompresowany numer z powrotem do oryginalnej listy.

JavaScript (ES7), 96 bajtów

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

Sortuje rzuty, ściśle przestrzegając zasad punktacji. Oczekuje tablicy ciągów z pojedynczymi rolkami w malejącej kolejności wartości, np["654"]

Wypróbuj online!

Wyjaśnienie

Kategorie rzutów są podnoszone do następujących wykładników:

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

Nie golfił

Umysłowe rozpakowanie czeków warunkowych wywołuje u mnie ból głowy i jestem pewien, że można w jakiś sposób pograć w golfa ...

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 znaków, 116 bajtów (UTF-8)

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

Pobiera tablicę liczb reprezentujących rolki [ 321, 654 ].

Wypróbuj online!

Wyjaśnienie:

Wzięłam pierwszą 16 56 możliwych różnych rolkach (te, które naprawdę nie następują dowolnej kolejności), a ja je zakodowane jako ciąg: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Każdy znak tego ciągu odpowiada pierwszym 16 możliwym rolkom ( ƥjest 421, ojest 111, ...). Teraz dla każdego z dwóch elementów ai btablicy po prostu sprawdzamy ich indeks z ciągu, jeśli są uwzględnione, indeks jest używany, w przeciwnym razie (indeks to -1) używamy samego numeru rzutu (odejmujemy go, 700aby odwrócić kolejność te nie są uwzględnione, tzn. posortować je w malejącej kolejności).

Czysty , 169 102 bajtów

Wszystkie znaki ósemkowe są liczone jako jeden bajt, ponieważ kompilator Clean z radością je zabierze w ten sposób, ale TIO i SE nie zrobią tego, ponieważ nie są dobrze uformowanym 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]

Wypróbuj online!

Wykorzystuje fakt, że wszystkie rzuty kostkami, jako liczby całkowite modulo 256, są unikalne.
Dogodnie Charjest traktowane (głównie) jako liczba całkowita modulo 256.

Pyth , 48 bajtów

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

Oczekuje danych wejściowych jako zagnieżdżonej tablicy, a każdy element uporządkowany malejąco. Spróbuj go online tutaj , lub sprawdzić wszystkie przypadki testowe od razu tutaj .

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 bajty

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

Wypróbuj online!

Ogólny algorytm:

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

Detale:

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