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

В игре используются 3 стандартных кубика.

задача

Ваша задача состоит в том, чтобы отсортировать непустой список отличных бросков с 3 кубиками [X, Y, Z] от наивысшего к низшему, применяя правила подсчета очков в этой игре.

Базовая оценка

• 4,2,1 - максимально возможная комбинация. В зависимости от правил он может набрать 8, 10 или 11 баллов. Поскольку мы сортируем броски, а не подсчитываем баллы, точное значение не имеет значения.
• Три туза: 1,1,1 - вторая по величине комбинация и набирает 7 очков.
• Two-Aces: X, 1,1 (где X от 2 до 6) набирает X очков.
• Три в своем роде: X, X, X (где X от 2 до 6) баллы X очков.
• Стриты: Х, Х + 1, Х + 2, очки 2 очка.
• Все остальные броски дают 1 очко.

Урегулирование галстуков

Когда два броска дают одинаковое количество очков, применяются следующие правила:

• Два туза лучше, чем тройка. Пример: 5,1,1 ударов 5,5,5 .
• Трехсторонняя 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" ]

Python , 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в этом случае)
• β: Преобразовать список из базы 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

Ungolfed

Мысленная распаковка условных чеков вызывает у меня головную боль, и я уверен, что это как-то может быть продолжено ...

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