421เป็นเกมลูกเต๋าที่ได้รับความนิยมในประเทศฝรั่งเศสและประเทศอื่น ๆ ในยุโรป ส่วนใหญ่เล่นในบาร์และผับเพื่อตัดสินว่าใครกำลังจะซื้อเครื่องดื่มรอบต่อไป เกมเต็มรูปแบบมักจะเล่นเป็นสองรอบด้วยโทเค็นที่ผู้เล่นแต่ละคนพยายามที่จะกำจัด แต่นี่ไม่เกี่ยวข้องเลย ( หน้า Wikipediaในภาษาฝรั่งเศส)

เกมนี้เล่นโดยใช้ลูกเต๋ามาตรฐาน 3 ลูก

งาน

งานของคุณคือจัดเรียงรายการที่ไม่ว่างเปล่าของลูกเต๋า 3 ลูกที่แตกต่างกัน[X, Y, Z]จากสูงไปหาต่ำสุดโดยใช้กฎการให้คะแนนของเกมนี้

เกณฑ์การให้คะแนนขั้นพื้นฐาน

• 4,2,1เป็นชุดค่าผสมที่เป็นไปได้สูงสุด ขึ้นอยู่กับกฎนั้นอาจมีคะแนน 8, 10 หรือ 11 คะแนน เนื่องจากเราเรียงลำดับม้วนแทนที่จะนับคะแนนค่าที่แน่นอนจึงไม่สำคัญ
• Three Aces: 1,1,1เป็นชุดค่าผสมที่สูงที่สุดอันดับสองและได้คะแนน7คะแนน
• Two-Aces: X, 1,1 (โดยXคือ 2 ถึง 6) คะแนนXคะแนน
• Three-of-a-Kind: X, X, X (โดยXคือ 2 ถึง 6) คะแนนXคะแนน
• Straights: X, X + 1, X + 2คะแนน2คะแนน
• ม้วนอื่น ๆ ทั้งหมดคะแนน1จุด

การสร้างความสัมพันธ์

เมื่อใดก็ตามที่สองม้วนให้คะแนนเท่ากันกฎต่อไปนี้ใช้:

• สองเอซนั้นดีกว่าของสามอย่าง ตัวอย่าง: 5,1,1เต้น5,5,5
• Three-of-a-Kind 2,2,2ดีกว่าแบบตรง ตัวอย่าง: 2,2,2เต้น4,5,6
• Straights มีคำสั่งจากต่ำสุดไปสูงสุด ตัวอย่าง: 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µÞ

ลิงค์ monadic ยอมรับรายการของลูกเต๋ากลิ้ง (เรียงจากมากไปน้อยเรียง) ซึ่งทำให้ม้วนเรียงเรียงจากมากไปน้อย

ลองออนไลน์! หรือดูชุดทดสอบ ... หรือลองเรียงม้วนพจนานุกรมทั้งหมด

อย่างไร?

วิธีการนี้จะสร้างรายชื่อของม้วนทั้งหมดจากสูงสุดไปต่ำสุด * แทนที่[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 chars, 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