421 adalah permainan dadu yang agak populer di Prancis dan beberapa negara Eropa lainnya. Sebagian besar dimainkan di bar dan pub untuk menentukan siapa yang akan membeli minuman berikutnya. Gim penuh biasanya dimainkan dalam dua putaran, dengan token yang setiap pemain coba singkirkan, tetapi ini tidak relevan di sini. ( Halaman Wikipedia dalam bahasa Prancis.)

Permainan ini dimainkan dengan 3 dadu kubus standar.

Tugas

Tugas Anda adalah untuk mengurutkan daftar gulungan 3-dadu yang tidak kosong [X, Y, Z] dari tertinggi ke terendah, dengan menerapkan aturan pemberian skor pada game ini.

Penilaian dasar

• 4,2,1 adalah kombinasi setinggi mungkin. Tergantung pada aturannya, skor mungkin 8, 10, atau 11 poin. Karena kami menyortir gulungan daripada menghitung poin, nilai pastinya tidak masalah.
• Three Aces: 1,1,1 adalah kombinasi tertinggi kedua dan skor 7 poin.
• Two-Aces: X, 1,1 (di mana X adalah 2 hingga 6) mencetak poin X.
• Three-of-a-Kind: X, X, X (di mana X adalah 2 hingga 6) mencetak poin X.
• Straights: X, X + 1, X + 2 skor 2 poin.
• Semua gulungan lainnya menghasilkan 1 poin.

Menyelesaikan ikatan

Setiap kali dua gulungan memberikan jumlah poin yang sama, aturan berikut ini berlaku:

• Two-Aces lebih baik daripada Three-of-a-Kind. Contoh: 5,1,1 ketukan 5,5,5 .
• The Three-of-a-Kind 2,2,2 lebih baik daripada yang lurus. Contoh: 2,2,2 ketukan 4,5,6 .
• Straights dipesan dari terendah ke tertinggi. Contoh: 4,5,6 ketukan 2,3,4 .
• Semua gulungan lainnya diselesaikan dengan menyortir dadu dari tertinggi ke terendah. Contoh: 6,5,2 ketukan 6,4,3 . (Oleh karena itu, kombinasi serendah mungkin dalam permainan adalah 2,2,1 .)

Di bawah ini adalah 56 gulungan berbeda yang mungkin dipesan dari tertinggi ke terendah:

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

Aturan tantangan

• Anda dapat mengambil gulungan dalam format apa pun yang wajar, seperti daftar daftar [[3,2,1],[4,2,1]], daftar string ["321","421"], daftar bilangan bulat [321,421], dll. Namun, setiap dadu harus dapat diidentifikasi dengan jelas dengan nilai dari 1 hingga 6 .
• Untuk setiap gulungan, Anda dapat mengasumsikan bahwa dadu diurutkan baik dari terendah ke tertinggi atau dari tertinggi ke terendah, selama konsisten. Silakan sebutkan jawaban yang Anda harapkan, jika ada.
• Jawaban terpendek dalam byte menang!

Uji kasus

Menggunakan daftar string dengan dadu diurutkan dari tertinggi ke terendah:

Input

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

Output yang diharapkan

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

Cobalah online!

Retina 0.8.2 , 67 byte

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

Cobalah online! Tautan termasuk kasus uji. Penjelasan: Tombol pengurutan angka dibuat sebagai berikut:

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

Jelly ,  37  34 byte

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

Tautan monadik yang menerima daftar daftar dadu gulungan (masing-masing turun diurutkan) yang menghasilkan gulungan diurutkan turun.

Cobalah online! Atau lihat test-suite ... atau coba semua gulungan yang diurutkan secara leksikografis

Bagaimana?

Metode ini membangun daftar semua gulungan dari tertinggi ke terendah *, menggantikan [4,2,1]dengan 0(input roll tidak valid), untuk menentukan peringkat setiap roll menggunakan indeks-indeks-atom pertama Jelly i,.

* Daftar ini juga termasuk pengulangan dan entri berlebihan yang tidak akan mempengaruhi perilaku:

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

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

Cobalah online!

• Program lengkap mengambil daftar integer dari stdin dan mengembalikannya dalam urutan menurun (yaitu 421 ... 221)
• Dimulai sebagian terinspirasi oleh jawaban @ Lynn , sekarang pada dasarnya adalah porting ... jadi kredit ke @ Lynyn;)
• Disimpan 2 byte mendapatkan sisa pembagian x % 37bukannya111

Penjelasan:

Untuk masing-masing angka 5 kunci dihitung dan digunakan secara hierarkis untuk mengurutkan 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...

05AB1E , 76 48 45 byte

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

Ini ternyata jauh lebih lama dari yang diharapkan, tetapi setidaknya itu mudah diterapkan. Akan melihat apakah saya dapat menemukan solusi yang lebih baik .. Membuat daftar dengan tangan sekarang, tetapi masih agak lama.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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)

Berikut adalah daftar aktual yang dihasilkan oleh bagian pertama dari kode:

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

Cobalah online.

Seperti yang Anda lihat itu berisi barang-barang kosong; angka seperti 765atau 210; dan angka dalam kisaran[216, 112] . Tapi kita semua bisa mengabaikannya, karena barang yang ingin kita sortir berada dalam urutan yang benar.

Solusi 76 byte asli:

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

Coba online atau verifikasi semua test case (tidak ada test suite karena masih ada bug dengan sort-by dengan angka terkompresi tidak melihat bracket penutupan untuk menghentikan sortir ).

Penjelasan:

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

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

Segala sesuatu di antara keduanya •adalah angka terkompresi yang dihasilkan dengan program berikut:

Z>β 255B

Cobalah online.

• Z>: Ambil maks daftar + 1 ( 667dalam hal ini)
• β: Konversikan daftar dari Pangkalan 667ke satu nomor
• 255B: Dan konversi nomor tunggal itu menjadi basis 255(menggunakan halaman kode 05AB1E), jadi kami memiliki nomor terkompresi kami .

Dengan menggunakannya 667в, konversi nomor terkompresi ini kembali ke daftar semula.

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

Mengurutkan bergulir dengan mematuhi aturan penilaian. Mengharapkan array string dengan gulungan individual dalam urutan nilai yang menurun, misalnya["654"]

Cobalah online!

Penjelasan

Kategori gulungan dinaikkan ke eksponen berikut:

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

Tidak disatukan

Secara mental membuka bungkusan pemeriksaan bersyarat membuat saya sakit kepala, dan saya yakin itu entah bagaimana bisa lebih lanjut golf.

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

Mengambil array angka yang mewakili gulungan seperti [ 321, 654 ] .

Cobalah online!

Penjelasan:

Aku mengambil pertama 16 dari 56 mungkin gulungan yang berbeda (orang-orang yang tidak benar-benar mengikuti urutan apapun) dan saya dikodekan mereka sebagai string: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Setiap karakter dari string ini sesuai dengan 16 kemungkinan gulungan pertama ( ƥis 421, ois 111, ...). Sekarang untuk setiap dua elemen adan bdari array kita hanya memeriksa indeks mereka dari string, jika mereka termasuk indeks yang digunakan, jika tidak (indeksnya -1) kita menggunakan nomor roll itu sendiri (kita kurangi dari 700untuk membalik urutan urutan yang tidak termasuk, yaitu untuk mengurutkannya dalam urutan menurun).

Bersih , 169 102 byte

Semua lolos oktal dihitung sebagai satu byte, karena Clean compiler akan dengan senang hati mengambilnya, tetapi TIO dan SE tidak akan melakukannya karena mereka tidak terbentuk dengan baik 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]

Cobalah online!

Menggunakan fakta bahwa semua gulungan dadu, sebagai bilangan bulat modulo 256, adalah unik.
Mudah, Chardiperlakukan (sebagian besar) sebagai bilangan bulat 256 modulo.

Pyth , 48 byte

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

Diharapkan input sebagai array bersarang, setiap elemen dipesan menurun. Coba online di sini , atau verifikasi semua uji sekaligus di sini .

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

Cobalah online!

Algoritma keseluruhan:

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

Detail:

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