Thử thách

Bar Dice là một trò chơi đơn giản được chơi trong một Bar với Dice (do đó có tên). Bạn cuộn 5 con xúc xắc sáu mặt và cố gắng để làm cho bàn tay tốt nhất.

Ghi điểm dựa trên việc tích lũy số lượng xúc xắc lớn nhất có cùng chữ số. Mỗi tay phải bao gồm ít nhất một "Ace", hoặc một, để trở thành một tay hợp lệ; Ách đóng vai trò là "người hoang dã" và có thể ghép với bất kỳ chữ số nào khác. Sức mạnh của tay người chơi trước tiên phụ thuộc vào số chữ số và sau đó là giá trị của các chữ số đó. Ví dụ, một bàn tay (đếm số lần hoang dã) với bốn 3 giây tốt hơn một bàn tay với ba 5 giây, nhưng không tốt hơn một bàn tay với năm 2 giây.
^{Lấy từ bài viết Wikipedia}

Điều này có nghĩa là tay xếp hạng cao nhất được làm hoàn toàn bằng 6 và 1, và tay thấp nhất là tay không có 1.

Thử thách của bạn là nắm lấy hai tay và trả lại cầu thủ nào thắng, hoặc nếu họ buộc.

Đầu vào

Hai danh sách chưa sắp xếp gồm 5 số, từ 1 đến 6. Mỗi danh sách đại diện cho tay của người chơi. Các định dạng đầu vào là linh hoạt.

Đầu ra

Bất kỳ ba giá trị tĩnh, nhất quán, nhất quán (phạm vi nào đều không được phép) biểu thị cho dù người chơi 1 hay người chơi 2 thắng hay nếu đó là hòa. Vui lòng nêu trong câu trả lời của bạn những giá trị bạn đang sử dụng cho những gì. Ví dụ: bạn có thể quay lại -1nếu P1 thắng, 0nếu đó là hòa và 1nếu P2 thắng.

Quy tắc

• Đầu vào sẽ luôn hợp lệ
• Chỉ có điểm số tốt nhất có thể của mỗi tay được sử dụng để xác định người chiến thắng. Không có tie-breakers. Ví dụ, [1,4,4,3,3]sẽ buộc [1,4,4,2,2]thay vì sử dụng 3 và 2 như một bộ ngắt kết nối.
• Đầu ra phải là một trong 3 giá trị được chọn mỗi lần. Đơn giản chỉ cần ánh xạ tất cả các số âm thành P1 Winskhông được phép và phải được chuẩn hóa.
• Tay không hợp lệ, tức là những người không có 1, mất tất cả các tay hợp lệ nhưng buộc với tất cả các tay không hợp lệ khác. Ví dụ: cà [2,2,2,2,2]vạt[3,3,3,3,3] .
• Một bàn tay [1,1,1,1,1]được tính là một bộ 6 hợp lệ cho mục đích xếp hạng.
• Đây là mã golf nên số byte ngắn nhất sẽ thắng.

Ví dụ

#You guys are pretty good at finding edge-cases that break things. Good job!
Input:  [2,1,5,6,6], [6,2,6,6,6]
Output: P1 Wins

Input:  [2,4,5,6,6], [6,2,6,6,6]
Output: Tie

Input:  [1,2,3,4,5], [5,4,3,2,1]
Output: Tie

Input:  [1,5,5,3,2], [5,4,1,6,6]
Output: P2 Wins

Input:  [3,2,2,2,1], [4,1,3,6,6]
Output: P1 Wins

Input:  [1,1,1,1,1], [6,1,1,6,6]
Output: Tie

Input:  [1,3,3,4,4], [1,2,2,5,5]
Output: P2 Wins

Input:  [1,3,3,5,5], [1,3,3,2,2]
Output: P1 Wins

Input:  [1,3,3,3,4], [1,1,3,3,3]
Output: P2 Wins

Input:  [2,2,2,6,1], [5,3,3,1,2]
Output: P1 Wins

Input:  [5,5,5,1,5], [1,1,1,1,1]
Output: P2 Wins

Input:  [1,1,1,1,1], [1,1,5,1,1]
Output: P1 Wins

Thạch , 17 14 byte

ċⱮ6Ḣ©+$®aĖUṀ)M

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

Một liên kết đơn âm lấy danh sách hai danh sách làm đối số và trả về [1]cho người chơi 1 trận thắng, [2]cho người chơi 2 trận thắng và [1, 2]hòa. Liên kết TIO điều này để hiển thị.

Cảm ơn @Jonathan ALLan vì đã tiết kiệm 3 byte!

Giải trình

            )   | For each input list (e.g. of one list 1,1,3,3,4)
ċⱮ6             | - Count each of 1..6 (e.g. 2,0,2,1,0,0)
      $         | - Following as a monad:
   Ḣ            |   - Head (number of 1s)
    ©︎           |   - Copy to register
     +          |   - Add (e.g. 2,4,3,0,0)
       ®a       | - Register logical and with this
         Ė      | - Enumerate (e.g. [1,2],[2,4],[3,3],[4,0],[5,0])
          U     | - Reverse each (e.g. [2,1],[4,2],[3,3],[0,4],[0,5])
            Ṁ   | - Max (e.g. 4,2)
              M | Index/indices of maximal score

R , 115 96 byte

-6 byte nhờ Giuseppe.

-6 byte nhờ Aaron Hayman.

-2 byte nhờ Arnauld, theo định dạng đầu ra trong câu trả lời JavaScript của anh ấy .

function(i,j)(f(i)-f(j))/0
f=function(x,s=tabulate(x,6),l=s[1]+s[-1]*!!s[1])max(l)*6+order(l)[5]

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

Trả về Infcho P1, NaNcho một cà vạt,-Inf cho P2.

Sử dụng chức năng trợ giúp f để tính điểm cho mỗi tay. Điểm số được xác định như sau: hãy dlà chữ số được lặp lại nhiều nhất và nsố lần được lặp lại. Sau đó, điểm số là 6*n+dnếu có ít nhất một con át chủ bài, và 0nếu không có con át chủ bài. Chúng tôi sau đó chỉ cần tìm người chơi có số điểm cao nhất.

Ung dung:

f = function(x) {
  s = tabulate(x, 6)         # number of occurrences of each integer
  l = s[1] + s[-1] * !!s[1]  # add the number of wild aces to all values; set to 0 if s[1] == 0
  max(l) * 6 +               # highest number of repetitions (apart from aces)
    order(l)[5]              # most repeated integer (take largest in case of tie)
}
function(i, j){
  sign(f(i) - f(j))
}

JavaScript (ES6),  97  90 byte

Đưa đầu vào là (a)(b). Trả về +Infinitycho P1, -Infinitycho P2 hoặc NaNcho cà vạt.

a=>b=>((g=(x,m)=>x>6?m*/1/.test(a):g(-~x,a.map(k=>n+=k<2|k==x,n=x/6)|m>n?m:n))()-g(a=b))/0

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

Đã bình luận

a => b => (                 // a[] = dice of P1; b[] = dice of P2
  ( g = (                   // g is a recursive function taking:
      x,                    //   x = dice value to test; initially, it is either undefined
                            //       or set to a non-numeric value
      m                     //   m = maximum score so far, initially undefined
    ) =>                    //
      x > 6 ?               // if x is greater than 6:
        m * /1/.test(a)     //   return m, or 0 if a[] does not contain any 1 
      :                     // else:
        g(                  //   do a recursive call:
          -~x,              //     increment x (or set it to 1 if it's non-numeric)
          a.map(k =>        //     for each dice value k in a[]:
            n +=            //       add 1 to n if:
              k < 2 |       //         k is equal to 1
              k == x,       //         or k is equal to x
            n = x / 6       //       start with n = x / 6
          ) |               //     end of map()
          m > n ?           //     if m is defined and greater than n:
            m               //       pass m unchanged
          :                 //     else:
            n               //       update m to n
        )                   //   end of recursive call
  )()                       // first call to g, using a[]
  - g(a = b)                // subtract the result of a 2nd call, using b[]
) / 0                       // divide by 0 to force one of the 3 consistent output values

05AB1E , 16 15 byte

-1 byte nhờ Jonathan ALLan

εWΘ*6L¢ć+°ƶà}ZQ

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

Trả về [1, 0] cho các chiến thắng P1, [1, 1] cho các mối quan hệ, [0, 1] cho các chiến thắng P2.

Thay vì sử dụng thứ tự từ vựng trên 2 tuple (số xúc xắc, giá trị xúc xắc), điều này sẽ tính điểm là 10 ** số xúc xắc * giá trị xúc xắc. Tay không có 1 điểm 5.

ε           }           # map each hand to its computed score
 WΘ                     # minimum == 1 (1 if the hand contains a 1, 0 otherwise)
   *                    # multiply (sets hands without 1 to [0, 0, 0, 0, 0])
    6L                  # range [1..6]
      ¢                 # count occurences of each in the hand
       ć                # head extract (stack is now [2-count, ..., 6-count], 1-count)
        +               # add the 1-count to all the other counts
         °              # 10**x
          ƶ             # multiply each element by its 1-based index
           à            # take the maximum

Z                       # maximum
 Q                      # equality test (vectorizes)

Python 2 , 85 81 80 byte

lambda p:cmp(*[max((h.count(i)+h.count(i>1),i)*(1in h)for i in[6]+h)for h in p])

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

Trả về 1cho P1, 0cho cà vạt và -1cho P2.

_{-1 byte, nhờ mực}

Perl 6 , 60 49 byte

&[cmp]o*.map:{.{1}&&max (.{2..6}X+.{1})Z ^5}o&bag

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

Returns More, Same, LesschoP1 Wins , Tie,P2 Wins .

Giải trình

       *.map:  # Map input lists
                                             &bag  # Convert to Bag
             {                             }o  # Pass to block
              .{1}&&  # Return 0 if no 1s
                    max  # Maximum of
                         .{2..6}  # number of 2s,3s,4s,5s,6s
                                X+.{1}  # plus number of 1s
                        (             )Z     # zipped with
                                         ^5  # secondary key 0,1,2,3,4
&[cmp]o  # Compare mapped values

Truy vấn T-SQL, 148 byte

Sử dụng biến bảng làm đầu vào

p: người chơi

v: giá trị cho cuộn

DECLARE @ table(p int,v int)
INSERT @ values(1,5),(1,5),(1,5),(1,5),(1,5)
INSERT @ values(2,4),(2,3),(2,3),(2,1),(2,4)

SELECT sign(min(u)+max(u))FROM(SELECT(p*2-3)*(s+sum(sign(s)-1/v))*(s/5*5+v+30)u
FROM(SELECT*,sum(1/v)over(partition by p)s FROM @)c GROUP BY v,s,p)x

Dùng thử trực tuyến

Player 1 wins returns -1
Tie returns 0 
Player 2 wins returns 1

Thạch , 21 byte

^{bị nghiền nát trước khi tôi thậm chí đăng nó bởi Nick Kennedy :)}

’-oÆṃṀ$$Ạ?fÆṃ$L;$o5)M

Liên kết đơn thể chấp nhận danh sách người chơi đưa ra danh sách người chiến thắng (1 chỉ mục).

Vậy P1 là [1], P2 là [2]và hòa là [1,2].

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

PowerShell , 112 126 123 121 byte

Đưa đầu vào là (a)(b). Trả về -1cho chiến thắng P1, 1cho P2 hoặc 0cho hòa.

$args|%{$d=$($_-ne1|group|sort c*,n*|%{$m=$_};(7*(($o=($_-eq1).Count)+$m.Count)+$m.Name+6*!$m)[!$o])-$d}
[math]::Sign($d)

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

Trường hợp thử nghiệm @( @(1,1,5,1,1), @(1,1,1,1,1), 1)thêm.

Chưa được kiểm soát:

$args|%{
    $score=$(                                            # powershell creates a new scope inside expression $(...)
        $_-ne1|group|sort count,name|%{$max=$_}          # $max is an element with the widest group and the maximum digit except 1
        $ones=($_-eq1).Count                             # number of 1s in a player's hand
        $scoreRaw=7*($ones+$max.Count)+$max.Name+6*!$max # where $max.Name is digit of the widest group
        $scoreRaw[!$ones]                                # output $scoreRaw if the array contains 1, otherwise output $null 
    )                                                    # powershell deletes all variables created inside the scope on exit
    $diff=$score-$diff
}
[math]::Sign($diff)                                     # output the score difference

Ngôn ngữ Wolfram (Mathicala) , 78 75 74 byte

-1 byte bởi Greg Martin

Order@@(#~FreeQ~1||Last@Sort[Reverse/@Tally@Flatten[#/. 1->Range@6]]&)/@#&

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

Kết quả -1 khi người chơi 1 thắng, 1 khi người chơi 2 thắng và 0 cho hòa.

                                    Helper function to score a list:
FreeQ[#,1] ||                       If there are 0 1s, score is True
Last@Sort[                          Otherwise, take the largest element of
    Reverse/@Tally@                 the {frequency, number} pairs in the flat list
       Flatten[ #/. 1->Range@6]     where each 1 is replaced by {1,2,3,4,5,6}.
]&                              e.g. {1,3,3,5,5} -> {1,2,3,4,5,6,3,3,5,5} -> {3,5}

Order @@ (...) /@ #&                Apply this function to both lists,
                                    then find the ordering of the result.

Java 8, 244 240 236 215 199 byte

a->b->{int c[][]=new int[2][7],m[]=new int[2],p,i=5;for(;i-->0;c[1][b[i]]++)c[0][a[i]]++;for(i=14;i-->4;)m[p=i%2]=Math.max(m[p],c[p][1]>0?i/2+9*(c[p][i/2]+c[p][1]):0);return Long.compare(m[0],m[1]);}

-4 byte nhờ @someone .
-21 byte nhờ @Neil .
-16 byte nhờ @ceilingcat .

Trả về 1nếu P1 thắng; -1nếu P2 thắng; 0nếu đó là cà vạt.

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

Giải trình:

a->b->{                        // Method with 2 integer-array parameters & integer return
  int c[][]=new int[2][7],     //  Create a count-array for each value of both players,
                               //  initially filled with 0s
      m[]=new int[2],          //  The maximum per player, initially 0
      p,                       //  Temp-value for the player
  i=5;for(;i-->0;              //  Loop `i` in the range (5, 0]:
    c[1]                       //   For player 2:
        [b[i]                  //    Get the value of the `i`'th die,
             ]++)              //    and increase that score-count by 1
    c[0][a[i]]++;              //   Do the same for player 1
  for(i=14;i-->4;)             //  Then loop `i` in the range (14, 4]:
    m[p=i%2]=                  //   Set the score of a player to:
                               //   (even `i` = player 1; odd `i` = player 2)
      Math.max(                //    The max between:
        m[p],                  //     The current value,
                               //     And the value we calculate as follows:
        c[p][1]>0?             //     If this player rolled at least one 1:
          i/2                  //      Use the current value `i` integer-divided by 2
          +9*                  //      With 9 times the following added:
             (c[p][i/2]        //       The amount of dice for value `i//2`
              +c[p][1])        //       Add the amount of dice for value 1
        :                      //     Else (no 1s were rolled):
         0);                   //      Use 0
  return Long.compare(m[0],m[1]);}
                               //  Finally compare the maximum scores of the players,
                               //  resulting in -1 if a<b; 0 if a==b; 1 if a>b

Thạch , 27 byte

’o5Rṗ5¤ṢŒr$€UẎṀ1e⁸¤×µ€_/Ṡo/

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

1 cho P1, -1 cho P2, 0 cho cà vạt

Giải trình

’o5Rṗ5¤ṢŒr$€UẎṀ1e⁸¤×µ€_/Ṡo/  Main link
                    µ€       For each list
’                            Decrement each value (so 1s become falsy)
 o                           Vectorized logical or (this replaces previous 1s (now 0s) with the test values)
  5Rṗ5¤                      1..5 cartesian-power 5 (1,1,1,1,1; 1,1,1,1,2; 1,1,1,1,3; ...)
          $€                 For each test list
       ṢŒr                   Sort and run-length encode (gives [digit, #digit])
            U                Reverse each list (gives [#digit, digit])
             Ẏ               Tighten by one (gives a list containing each possible hand for each possible wildcard)
              Ṁ              Take the maximum
               1e⁸¤×         Multiply the list values by (whether or not the original contained a 1) - becomes [0, 0] if not
                      _/Ṡ    Take the sign of the difference between the #digits and the digits
                         o/  If the number of digits differs, then 1/-1 is returned; otherwise, check the value of the digit (could still be 0)

Sledgehammer 0,4 , 27 byte

⢱⢙⢂⠠⡾⢃⠐⢈⠸⣞⠴⠻⠎⡥⡳⡐⢒⠘⢛⣩⡓⣮⡕⡠⣢⣡⠿

Giải nén vào chức năng Ngôn ngữ Wolfram này:

Order @@ (FreeQ[#1, 1] || Last[Sort[Reverse[Tally[Flatten[#1 /. 1 -> Range[6]]], 2]]] & ) /@ #1 & 

mà hóa ra là giống hệt như câu trả lời Mathicala của tôi .

Than , 48 45 byte

ＵＭθ⮌Ｅ⁷№ι∨λ¹ＵＭθ׬¬⊟ι⁺⊟ιιＵＭθ⟦⌈ι±⌕ι⌈ι⟧Ｉ⁻⌕θ⌈θ⌕θ⌊θ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy đầu vào dưới dạng một mảng các mảng và đầu ra -1nếu người chơi 1 thắng, 0hòa, và 1nếu người chơi 2 thắng. Giải trình:

ＵＭθ⮌Ｅ⁷№ι∨λ¹

Thay thế mỗi bàn tay bằng số lần giá trị 6..1xuất hiện trong tay. Danh sách bị đảo ngược vì a) nó giúp dễ dàng tìm thấy giá trị cao nhất với số đếm cao nhất và b) nó giúp việc loại bỏ số 1s dễ dàng hơn . Số lượng1 s được nhân đôi bởi vì nó cần phải được loại bỏ hai lần, một lần để kiểm tra xem nó có khác không và một lần để thêm nó vào các số đếm khác.

ＵＭθ׬¬⊟ι⁺⊟ιι

Thêm số 1s vào số đếm cho 6..2, nhưng đặt tất cả số đếm thành 0 nếu số 1s bằng 0.

ＵＭθ⟦⌈ι±⌕ι⌈ι⟧

Đối với mỗi tay tìm số cao nhất và giá trị cao nhất với số đó. (Trên thực tế, chúng tôi tìm thấy giá trị trừ 6khi đó là gôn thủ.)

Ｉ⁻⌕θ⌈θ⌕θ⌊θ

Xác định tay nào thắng bằng cách trừ đi các vị trí thắng và thua. (Nếu hai tay bị trói thì tay đầu tiên vừa thắng vừa thua nên kết quả 0như mong muốn.)

C (gcc) / 32 bit, 117 byte

t;m;s(int*r){int c[6]={};for(m=0;t=*r++;m=t>m?t:m)c[--t]+=5,t=t?c[t]+t:5;t=*c?*c+m:0;}f(a,b){t=s(a)-s(b);t=(t>0)-!t;}

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

Có hai mảng số nguyên không kết thúc. Returns 1, 0, -1cho P1 Wins, P2 Wins, Tie.

J , ⁴⁷ 44 byte

*@-&([:({.([:>./#\@]+9^*@[*+)}.)1#.i.@6=/<:)

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

Lấy cảm hứng từ ý tưởng của Nick Kennedy.

vô dụng

*@-&([: ({. ([: >./ #\@] + 9 ^ *@[ * +) }.) 1 #. i.@6 =/ <:)

Perl 5 -MList::Util=max -pl , 80 byte

sub t{$t=pop;$_=max map$_ x$t=~s/$_//g,2..6;/./;$t&&$_.$t*($&||6)}$_=t($_)<=>t<>

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

Đầu vào:

Mỗi người chơi trên một dòng riêng biệt, không có khoảng trắng

Đầu ra:

1 Dòng một chiến thắng

0 Cà vạt

-1 Dòng hai chiến thắng