Hãy thực hành các quy tắc tính điểm của 421!


13

421 là một trò chơi súc sắc khá phổ biến ở Pháp và một số nước châu Âu khác. Nó chủ yếu được chơi trong các quán bar và quán rượu để xác định ai sẽ mua đồ uống tiếp theo. Toàn bộ trò chơi thường được chơi trong hai vòng, với các mã thông báo mà mỗi người chơi cố gắng loại bỏ, nhưng điều này không liên quan ở đây. ( Trang Wikipedia bằng tiếng Pháp.)

Trò chơi được chơi với 3 viên xí ngầu tiêu chuẩn.

Bài tập

Nhiệm vụ của bạn là sắp xếp một danh sách không có các cuộn 3 con xúc xắc riêng biệt [X, Y, Z] từ cao nhất đến thấp nhất, bằng cách áp dụng các quy tắc tính điểm của trò chơi này.

Điểm cơ bản

  • 4.2,1 là sự kết hợp cao nhất có thể. Tùy thuộc vào các quy tắc, nó có thể ghi được 8, 10 hoặc 11 điểm. Bởi vì chúng tôi đang sắp xếp các cuộn thay vì đếm các điểm, giá trị chính xác không thành vấn đề.
  • Three Aces: 1,1,1 là sự kết hợp và điểm số cao thứ hai 7 điểm.
  • Two-Aces: X, 1,1 (trong đó X là 2 đến 6) điểm X điểm.
  • Ba loại: X, X, X (trong đó X là 2 đến 6) điểm X điểm.
  • Các điểm: X, X + 1, X + 2 điểm 2 điểm.
  • Tất cả các cuộn khác ghi 1 điểm.

Giải quyết các mối quan hệ

Bất cứ khi nào hai cuộn cho cùng một số điểm, các quy tắc sau sẽ được áp dụng:

  • Two-Aces tốt hơn Three-of-a-Kind. Ví dụ: 5,1,1 nhịp 5,5,5 .
  • Ba-of-a- 2,2,2 tốt hơn so với thẳng. Ví dụ: 2,2,2 nhịp 4,5,6 .
  • Dây đai được đặt hàng từ thấp nhất đến cao nhất. Ví dụ: 4,5,6 nhịp 2,3,4 .
  • Tất cả các cuộn khác được giải quyết bằng cách sắp xếp xúc xắc từ cao nhất đến thấp nhất. Ví dụ: 6,5,2 nhịp 6,4,3 . (Do đó, sự kết hợp thấp nhất có thể có trong trò chơi là 2,2,1 .)

Dưới đây là 56 cuộn riêng biệt có thể được đặt hàng từ cao nhất đến thấp nhất:

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

Quy tắc thử thách

  • Bạn có thể lấy các cuộn ở bất kỳ định dạng hợp lý nào, chẳng hạn như danh sách các danh sách [[3,2,1],[4,2,1]], danh sách các chuỗi ["321","421"], danh sách các số nguyên [321,421], v.v. Tuy nhiên, mỗi khuôn phải được xác định rõ ràng với giá trị từ 1 đến 6 .
  • Đối với mỗi cuộn, bạn có thể giả sử rằng xúc xắc được sắp xếp từ thấp nhất đến cao nhất hoặc từ cao nhất đến thấp nhất, miễn là phù hợp. Vui lòng nêu trong câu trả lời của bạn mà bạn mong đợi, nếu có.
  • Câu trả lời ngắn nhất bằng byte thắng!

Các trường hợp thử nghiệm

Sử dụng danh sách các chuỗi với xúc xắc được sắp xếp từ cao nhất đến thấp nhất:

Đầu vào

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

Kết quả dự kiến

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

Có nên sắp xếp ổn định?
Erik the Outgolfer 28/07/18

@EriktheOutgolfer Tất cả các cuộn đều khác biệt và hai cuộn luôn có thể được sắp xếp theo các quy tắc quan hệ.
Arnauld

Có thể chấp nhận mỗi lần chết là 0-5 thay vì 1-6 (ví dụ 012thay vì 123) không?
lãng phí

@wastl Tôi sẽ nói không. Định dạng linh hoạt nhưng các giá trị xúc xắc phải ở [1 ... 6].
Arnauld

Bạn mang xúc xắc đến quán rượu?
Beta Decay

Câu trả lời:


6

Python , 93 byte

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

Hãy thử trực tuyến!


Điều gì làm cho điều này cụ thể với Python 2?
Solomon Ucko

@SolomonUcko Không có gì , nhưng tôi đoán nó được đánh dấu là Python 2 vì nó được tạo tự động bởi mẫu Gửi mã Golf từ TIO.
Ông Xcoder

1
Bạn có thể lưu 2 byte bằng cách sử dụng thực tế là 111 = 37 * 3 (và chỉ có ba lần xxx trong số tất cả các bộ ba có thể chia hết cho 37) Hãy thử trực tuyến!
digEmAll

1
Bạn có thể mất 2 byte bằng cách sắp xếp tại chỗ với sortphương thức.
Jakob

4

Võng mạc 0.8.2 , 67 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải thích: Khóa sắp xếp số được tạo như sau:

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

@Arnauld Xin lỗi, tôi đã không nhận ra mình đã trộn lẫn những trường hợp đó. May mắn thay, tôi nghĩ rằng tôi đã có thể sửa nó cho cùng một số byte.
Neil

Bây giờ nó trông rất ổn.
Arnauld

4

Thạch ,  37  34 byte

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

Một liên kết đơn âm chấp nhận một danh sách các danh sách các cuộn súc sắc (mỗi lần giảm dần được sắp xếp) sẽ mang lại các cuộn được sắp xếp giảm dần.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm ... hoặc thử tất cả các cuộn được sắp xếp theo từ vựng

Làm sao?

Phương pháp này xây dựng danh sách tất cả các cuộn từ cao nhất đến thấp nhất *, thay thế [4,2,1]bằng 0(một cuộn đầu vào không hợp lệ), để xếp hạng từng cuộn bằng cách sử dụng nguyên tử đầu tiên của Jelly i.

* Danh sách này cũng bao gồm các lần lặp lại và các mục thừa không ảnh hưởng đến hành vi:

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

3

R , 73 byte

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

Hãy thử trực tuyến!

  • Chương trình đầy đủ lấy danh sách số nguyên từ stdin và trả chúng theo thứ tự giảm dần (nghĩa là 421 ... 221)
  • Bắt đầu như một phần lấy cảm hứng từ câu trả lời @Lynn , bây giờ về cơ bản là một phần của nó ... vì vậy tín dụng cho @Lynn;)
  • Đã lưu 2 byte nhận phần còn lại x % 37thay vì111

Giải trình :

Đối với mỗi số, 5 phím được tính toán và sử dụng theo thứ bậc để sắp xếp mảng:

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

2

05AB1E , 76 48 45 byte

421X36LR©vy11«y3∍}®vy>yJ})D®3ãJsм)˜©IΣ®sk>

Điều này hóa ra dài hơn nhiều so với dự kiến, nhưng ít nhất nó cũng dễ thực hiện. Sẽ xem liệu tôi có thể tìm ra giải pháp tốt hơn không .. Lập danh sách bằng tay ngay bây giờ, nhưng vẫn còn một chút dài.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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)

Đây là danh sách thực tế phần đầu tiên của mã tạo ra:

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

Hãy thử trực tuyến.

Như bạn có thể thấy nó chứa các mục trống; số thích 765hoặc 210; và số trong phạm vi [216, 112]. Nhưng tất cả chúng ta đều có thể bỏ qua những thứ này, bởi vì các mục chúng ta muốn sắp xếp thực sự theo đúng thứ tự.


Giải pháp 76 byte gốc:

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

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp kiểm tra (không có bộ kiểm tra vì vẫn còn một lỗi với sắp xếp với các số nén không thấy dấu ngoặc đóng để dừng sắp xếp ).

Giải trình:

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

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

Tất cả mọi thứ giữa hai là một số nén được tạo bằng chương trình sau:

Z 255B

Hãy thử trực tuyến.

  • Z>: Lấy tối đa danh sách + 1 ( 667trong trường hợp này)
  • β: Chuyển đổi danh sách từ Base- 667thành một số duy nhất
  • 255B: Và chuyển đổi số đơn đó thành cơ sở 255(sử dụng trang mã của 05AB1E), vì vậy chúng tôi có số nén của chúng tôi .

Bằng cách sử dụng 667вnó sẽ chuyển đổi số nén này trở lại danh sách ban đầu.


2

JavaScript (ES7), 96 byte

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

Sắp xếp cuộn bằng cách tuân thủ chặt chẽ các quy tắc tính điểm. Yêu cầu một chuỗi các chuỗi với các cuộn riêng lẻ theo thứ tự giá trị giảm dần, vd["654"]

Hãy thử trực tuyến!

Giải trình

Các loại cuộn được nâng lên theo số mũ sau:

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

Ung dung

Việc bỏ qua các kiểm tra có điều kiện khiến tôi đau đầu và tôi chắc chắn rằng bằng cách nào đó nó có thể được đánh gôn thêm ....

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

1

Javascript, 101 ký tự, 116 byte (UTF-8)

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

Có một dãy số đại diện cho các cuộn như thế nào [ 321, 654 ].

Hãy thử trực tuyến!

Giải trình:

Tôi đã lấy 16 trong số 56 cuộn riêng biệt đầu tiên có thể (những cuộn không thực sự tuân theo bất kỳ thứ tự nào) và tôi đã mã hóa chúng thành một chuỗi : "ƥoɣʚǿȫƛƼķōÓÞʎȟưŁ". Mỗi ký tự của chuỗi này tương ứng với 16 cuộn đầu tiên có thể ( ƥis 421, ois 111, ...). Bây giờ, đối với mỗi hai phần tử abcủa mảng, chúng ta chỉ cần kiểm tra chỉ mục của chúng từ chuỗi, nếu chúng được bao gồm thì chỉ mục được sử dụng, nếu không (chỉ mục là -1) chúng ta sử dụng chính số cuộn (chúng ta trừ nó 700để đảo ngược thứ tự của những cái không được bao gồm, tức là sắp xếp chúng theo thứ tự giảm dần).


NB: Trừ khi có quy định khác, độ dài mã luôn được đo bằng byte. Số lượng ký tự đôi khi có thể có liên quan, nhưng tôi không nghĩ rằng nó ở đây. Câu trả lời meta có liên quan .
Arnauld

@Arnauld Vâng! BTW Tôi là người đã hỏi câu hỏi meta đó ;-)
ibrahim mahrir 30/07/18

1
Ôi! Tôi đã bỏ lỡ chi tiết này hoàn toàn ...: D
Arnauld

1

Sạch , 169 102 byte

Tất cả các lần thoát bát phân được tính là một byte, vì trình biên dịch Clean sẽ vui vẻ thực hiện theo cách đó, nhưng TIO và SE sẽ không vì UTF-8 được tạo thành tốt.

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]

Hãy thử trực tuyến!

Sử dụng thực tế là tất cả các cuộn súc sắc, như số nguyên modulo 256, là duy nhất.
Thuận tiện, Charđược coi (hầu hết) là một số nguyên modulo 256.


1

Bình thường , 48 byte

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

Yêu cầu đầu vào là một mảng lồng nhau, mỗi phần tử được sắp xếp giảm dần. Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

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

1

05AB1E , 24 byte

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

Hãy thử trực tuyến!

Thuật toán tổng thể:

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

Chi tiết:

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
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.