421は、フランスや他のヨーロッパ諸国では​​かなり人気のあるサイコロゲームです。主に次の飲み物を買う人を決めるために、バーやパブで演奏されます。通常、完全なゲームは2ラウンドでプレイされ、各プレイヤーはトークンを使用して除去しようとしますが、ここでは関係ありません。（フランス語のWikipediaページ。）

ゲームは3つの標準的なサイコロでプレイされます。

仕事

あなたの仕事は、このゲームのスコアリングルールを適用することにより、明確な3ダイスロール[X、Y、Z]の空でないリストを最高のものから最低のものに並べ替えることです。

基本的なスコアリング

• 4,2,1は可能な限り高い組み合わせです。ルールに応じて、8、10、または11ポイントを獲得できます。ポイントをカウントするのではなく、ロールをソートするため、正確な値は重要ではありません。
• 3つのエース：1,1,1は2番目に高い組み合わせで、7ポイントを獲得します。
• 2エース：X、1,1（Xは2から6）はXポイントを獲得します。
• Three-of-a-Kind：X、X、X（Xは2〜6）はXポイントを獲得します。
• ストレート：X、X + 1、X + 2つのスコア2点。
• 他のすべてのロールは1ポイントを獲得します。

ネクタイの定着

2つのロールが同じ数のポイントを与えるたびに、次のルールが適用されます。

• ツーエースはスリーオブアカインドよりも優れています。例：5,1,1ビート5,5,5。
• Three-of-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" ]

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

オンラインでお試しください！

Retina 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の功績です;）
• のx % 37代わりに除算剰余を取得する2バイトを保存しました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 ]。

オンラインでお試しください！

説明：

56の異なる可能性のあるロール（実際には順序に従わないロール）の最初の16を取り、それらを文字列としてエンコードしました"ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ"。この文字列の各文字は、最初の16の可能なロール（ƥis 421、ois 111、...）に対応します。今、各二つの要素のためにaとb、彼らはインデックスが使用されている含まれている場合、私たちは（インデックスがあるそうでない場合は、文字列から自分のインデックスを確認し、配列の-1我々は、我々はそれをからsubstract（ロール番号そのものを使用）700の順序を逆します含まれていないもの、つまり、降順に並べ替えます）。

クリーン、169 102バイト

すべての8進エスケープは1バイトとしてカウントされます。Cleanコンパイラーは喜んでそのように処理しますが、整形式のUTF-8ではないため、TIOとSEはそうしません。

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