421 - досить популярна гра з кубиками у Франції та деяких інших європейських країнах. В основному він грається в барах і пабах, щоб визначити, хто збирається придбати наступний раунд напоїв. Повна гра зазвичай грається в два раунди, з жетонами, яких намагається позбутися кожен гравець, але це тут не має значення. ( Сторінка Вікіпедії французькою мовою.)

Гра проводиться з 3-х стандартних кубиків.

Завдання

Ваше завдання полягає в сортуванні не порожнього списку чітких 3-х кубикових рулонів [X, Y, Z] від найвищої до найнижчої, застосовуючи правила оцінки цієї гри.

Основні бали

• 4,2,1 - це найвища можлива комбінація. Залежно від правил, він може набрати 8, 10 або 11 балів. Оскільки ми сортуємо рулони, а не підраховуємо очки, точне значення не має значення.
• Три тузи: 1,1,1 - це друга за висотою комбінація і набирає 7 балів.
• Дві тузи: X, 1,1 (де X - 2 до 6) набирає X балів.
• Вибір три зразка: X, X, X (де X - 6 до 6) набирає X балів.
• Прямі: X, X + 1, X + 2 набирає 2 бали.
• Усі інші рулони набирають 1 бал.

Налагодження зв’язків

Щоразу, коли два рулони дають однакову кількість балів, застосовуються такі правила:

• "Дві тузи" краще, ніж "Тричі з роду". Приклад: 5,1,1 уд 5,5,5 .
• Три з-а-Kind 2,2,2 краще , ніж пряма. Приклад: 2,2,2 удару 4,5,6 .
• Прямі впорядковані від найнижчих до найвищих. Приклад: 4,5,6 удару 2,3,4 .
• Всі інші рулони осідають шляхом сортування кісток від найвищого до нижчого. Приклад: 6,5,2 удару 6,4,3 . (Тому найнижча можлива комбінація в грі - 2,2,1 .)

Нижче наведено 56 можливих чітких рулонів, упорядкованих від найвищої до нижньої:

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

Правила виклику

• Ви можете приймати рулони в будь-якому розумному форматі, наприклад, список списків [[3,2,1],[4,2,1]], список рядків ["321","421"], список цілих чисел [321,421]тощо. Однак кожен штрих повинен бути чітко ідентифікованим зі значенням від 1 до 6 .
• Для кожного рулону ви можете припустити, що кістки сортуються або від найнижчого до найвищого, або від найвищого до найнижчого, доки це буде послідовно. Будь ласка, вкажіть у своїй відповіді, яке замовлення ви очікуєте, якщо воно є.
• Найкоротша відповідь у байтах виграє!

Тестові справи

Використовуючи списки рядків з кубиками, відсортованими від найвищого до нижнього:

Вхідні дані

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

Очікувані результати

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

Пітон , 93 байти

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

Спробуйте в Інтернеті!

Сітківка 0,8,2 , 67 байт

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

Спробуйте в Інтернеті! Посилання включає тестові випадки. Пояснення: Числовий ключ сортування створюється наступним чином:

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

Желе ,  37  34 байт

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

Монадічна посилання, що приймає список списків рулонів з кістки (кожен відсортований за спаданням), який дає відсортовані рулони за спаданням.

Спробуйте в Інтернеті! Або подивіться тестовий набір ... або спробуйте всі рулони, відсортовані лексикографічно

Як?

Цей метод створює список всіх рулонів від вищого до нижчого *, замінюючи [4,2,1]з 0(неприпустимого вхідного рулону), для того , щоб рангу кожен рулон з використанням першого індексу-желе в атомі, i.

* Список також включає повторення та зайві записи, які не впливають на поведінку:

[[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 байти

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

Спробуйте в Інтернеті!

• Повна програма, що приймає список цілих чисел від stdin та повертає їх у порядку зменшення (тобто 421 ... 221)
• Розпочато як частково натхнене відповіддю @Lynn , тепер це, головним чином, його перенесення ... тому кредити @Lynn;)
• Збережено 2 байти, отримуючи залишок розділення x % 37замість111

Пояснення:

Для кожного з чисел обчислюється 5 клавіш і використовується ієрархічно для сортування масиву:

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 байт

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

Це виявилося набагато довше, ніж очікувалося, але принаймні це легко здійснити. Побачу, чи зможу я знайти краще рішення .. Склав список вручну зараз, але все ж трохи довгий.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

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)

Ось фактичний список, який генерує перша частина коду:

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

Спробуйте в Інтернеті.

Як бачите, він містить порожні елементи; числа, як 765або 210; і числа в діапазоні [216, 112]. Але ми всі можемо їх ігнорувати, оскільки предмети, які ми хочемо насправді сортувати, є у правильному порядку.

Оригінальне рішення для 76 байт:

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

Спробуйте в Інтернеті або перевірте всі тестові випадки (немає тестового набору, тому що все ще є помилка з сортуванням із стиснутими номерами, не побачивши закриває дужку для зупинки сортування ).

Пояснення:

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

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

Все між ними •- це стиснене число, яке генерується за допомогою наступної програми:

Z>β 255B

Спробуйте в Інтернеті.

• Z>: Візьміть максимум списку + 1 ( 667у цьому випадку)
• β: Перетворення списку з Base- 667в одне число
• 255B: І конвертуйте це єдине число в базове 255(використовуючи кодову сторінку 05AB1E), щоб у нас було стиснене число .

Використовуючи 667вйого, перетворює це стиснене число назад у вихідний список.

JavaScript (ES7), 96 байт

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

Сортуйте рулони, уважно дотримуючись правил скорингу. Очікує масив рядків з окремими рулонами у порядку зменшення значення, наприклад["654"]

Спробуйте в Інтернеті!

Пояснення

Категорії рулонів піднімаються до таких показників:

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

Безумовно

Психічне розгортання умовних чеків дає мені головний біль, і я впевнений, що це якимось чином може бути надалі гольф ....

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 символів, 116 байт (UTF-8)

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

Бере масив чисел, що представляють рулони, як [ 321, 654 ].

Спробуйте в Інтернеті!

Пояснення:

Я взяв перший 16 з 56 можливих різних рулонів (ті , які на насправді не слід якого - або замовлення) , і я закодований їх у вигляді рядка: "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Кожному символу цього рядка відповідає перші 16 можливих роликів ( ƥє 421, oє 111, ...). Тепер для кожного з двох елементів aта bмасиву ми просто перевіряємо їх індекс із рядка, якщо вони включені, використовується індекс, в іншому випадку (індекс є -1) ми використовуємо сам номер рулону (підсумовуємо його, 700щоб перевернути порядок ті, що не включаються, тобто сортувати їх у порядку зменшення).

Чистота , 169 102 байти

Усі восьмеричні виходи зараховуються як один байт, оскільки компілятор Clean з радістю сприйме їх таким чином, але TIO і SE не будуть, оскільки вони не є добре сформованими 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]

Спробуйте в Інтернеті!

Використовує той факт, що всі рулони кісток, як цілі числа по модулю 256, унікальні.
Зручно, Charтрактується (в основному) як ціле число модуля 256.

Pyth , 48 байт

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

Очікує введення у вигляді вкладеного масиву, кожен елемент впорядкований за спаданням. Спробуйте це в Інтернеті тут або перевірити всі тестові випадки тут .

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 байти

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

Спробуйте в Інтернеті!

Загальний алгоритм:

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

Деталі:

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