421 은 프랑스와 다른 유럽 국가에서 다소 인기있는 주사위 게임입니다. 주로 다음 술을 사러 갈 사람을 결정하기 위해 술집과 술집에서 진행됩니다. 정식 게임은 일반적으로 두 라운드에서 진행되며 각 플레이어가 제거하려고하는 토큰이 있지만 여기서는 관련이 없습니다. ( 프랑스어 위키 백과 페이지 )

이 게임은 3 개의 표준 큐브 주사위로 진행됩니다.

직무

당신의 임무는 이 게임의 점수 규칙을 적용하여 비어 있지 않은 별개의 3 주사위 롤 [X, Y, Z] 목록 을 최고에서 최저 로 정렬하는 것 입니다.

기본 점수

• 4,2,1 이 가장 높은 조합입니다. 규칙에 따라 8, 10 또는 11 점을받을 수 있습니다. 우리는 점을 세지 않고 롤을 정렬하기 때문에 정확한 값은 중요하지 않습니다.
• 3 개의 에이스 : 1,1,1 이 두 번째로 높은 조합이며 7 점을 얻습니다 .
• 투 에이스 : X, 1,1 (여기서 X 는 2 ~ 6)은 X 포인트를 기록합니다.
• 3 가지 종류 : X, X, X (여기서 X 는 2 ~ 6)는 X 포인트를 기록합니다.
• 스트레이트 : X, X + 1, X + 2 는 2 점을 얻습니다 .
• 다른 모든 롤은 1 점을 얻습니다.

유대 관계

두 롤이 같은 수의 포인트를 줄 때마다 다음 규칙이 적용됩니다.

• 2 에이스는 3 종류보다 낫습니다. 예 : 5,1,1 비트 5,5,5 .
• 3 대 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)]

온라인으로 사용해보십시오!

• 전체 프로그램의 표준 입력에서 정수의 목록을 복용하고 내림차순으로 그들을 반환 (예 421 ... 221)
• @Lynn answer 에서 부분적으로 영감을 받아 시작 되었으므로 이제는 기본적으로 포팅입니다 ... 그래서 @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в:

둘 사이의 모든 •A는 압축 된 번호 의 다음 프로그램에 의해 생성된다 :

Z>β 255B

온라인으로 사용해보십시오.

• Z>: 목록의 최대 값 + 1 ( 667이 경우)
• β: 목록을 Base- 667에서 단일 숫자로 변환
• 255B: 그 단일 숫자를 밑으로 변환 255하십시오 (05AB1E의 코드 페이지 사용) . 압축 된 숫자가 있습니다.

667в이를 사용 하여이 압축 번호를 원래 목록으로 다시 변환합니다.

자바 스크립트 (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)
)

자바 스크립트, 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) 롤 번호 자체를 사용합니다 700. 포함되지 않은 것, 즉 내림차순으로 정렬).

클린 , 169102 바이트

Clean 컴파일러는 행복하게 그 방법을 취하기 때문에 모든 8 진 이스케이프는 1 바이트로 계산되지만 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