Tantangan

Bar Dice adalah gim sederhana yang dimainkan di Bar with Dice (karena itulah namanya). Anda melempar 5 dadu enam sisi dan berusaha membuat yang terbaik.

Penilaian didasarkan pada mengumpulkan jumlah dadu terbesar dengan angka yang sama. Setiap tangan harus menyertakan setidaknya satu "Ace", atau satu, untuk menjadi tangan yang valid; Aces bertindak sebagai "liar", dan dapat dipasangkan dengan digit lainnya. Kekuatan tangan pemain pertama-tama bergantung pada jumlah digit dan kemudian nilai dari digit tersebut. Sebagai contoh, tangan (menghitung binatang buas) dengan empat 3 lebih baik daripada tangan dengan tiga 5, tetapi tidak lebih baik dari tangan dengan lima 2.
^{Diambil dari artikel Wikipedia}

Ini berarti tangan dengan peringkat tertinggi seluruhnya terbuat dari 6 dan 1, dan peringkat terendah adalah tangan tanpa 1.

Tantangan Anda adalah mengambil dua tangan dan mengembalikan pemain mana yang menang, atau jika mereka terikat.

Memasukkan

Dua daftar yang tidak disortir dari 5 angka, mulai dari 1 hingga 6. Setiap daftar mewakili tangan pemain. Format input fleksibel.

Keluaran

Tiga nilai statis yang berbeda namun konsisten, (rentang tidak diizinkan) menandakan apakah pemain 1 atau pemain 2 menang, atau jika itu seri. Silakan sebutkan dalam jawaban Anda nilai apa yang Anda gunakan untuk apa. Misalnya, Anda dapat kembali -1jika P1 menang, 0jika seri, dan 1jika P2 menang.

Aturan

• Masukan akan selalu valid
• Hanya skor terbaik dari masing-masing tangan yang digunakan untuk menentukan pemenang. Tidak ada pemutus dasi. Misalnya, [1,4,4,3,3]akan mengikat [1,4,4,2,2]bukannya menggunakan 3's dan 2's sebagai tie-breaker.
• Output harus menjadi salah satu dari 3 nilai yang dipilih setiap kali. Cukup memetakan semua angka negatif agar P1 Winstidak diperbolehkan dan harus dinormalisasi.
• Tangan yang tidak valid, yaitu yang tidak memiliki nomor satu, kalah dari semua tangan yang valid tetapi ikat dengan semua tangan yang tidak valid lainnya. Misalnya, [2,2,2,2,2]ikatan [3,3,3,3,3].
• Sejumlah [1,1,1,1,1]dihitung sebagai set 6 yang valid untuk tujuan peringkat.
• Ini adalah kode-golf sehingga hitungan byte terpendek menang.

Contohnya

#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

Jelly , 17 14 byte

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

Cobalah online!

Tautan monadik yang menggunakan daftar kedua daftar sebagai argumennya dan mengembalikan [1]untuk pemain 1 menang, [2]untuk pemain 2 menang dan [1, 2]untuk seri. TIO link merapikan ini untuk ditampilkan.

Terima kasih kepada @JonathanAllan karena telah menghemat 3 byte!

Penjelasan

            )   | 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 terima kasih kepada Giuseppe.

-6 byte terima kasih kepada Aaron Hayman.

-2 byte terima kasih kepada Arnauld, mengikuti format output dalam jawaban JavaScript- nya .

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]

Cobalah online!

Pengembalian Infuntuk P1, NaNuntuk dasi,-Inf untuk P2.

Menggunakan fungsi helper fyang menghitung skor untuk masing-masing tangan. Skor didefinisikan sebagai berikut: biarkan dmenjadi digit yang paling banyak diulang, dan nberapa kali itu diulang. Maka skornya adalah 6*n+djika ada setidaknya satu kartu as, dan 0jika tidak ada kartu As. Kami kemudian hanya perlu menemukan pemain dengan skor tertinggi.

Tidak Disatukan:

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

Mengambil input sebagai (a)(b). Pengembalian +Infinityuntuk P1, -Infinityuntuk P2 atau NaNuntuk dasi.

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

Cobalah online!

Berkomentar

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 terima kasih kepada JonathanAllan

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

Cobalah online!

Mengembalikan [1, 0] untuk P1 menang, [1, 1] untuk dasi, [0, 1] untuk P2 menang.

Alih-alih menggunakan urutan leksikografis pada 2-tupel (jumlah dadu, nilai dadu), ini menghitung skor sebagai 10 ** jumlah dadu * nilai dadu. Tangan tanpa skor 1 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])

Cobalah online!

Pengembalian 1untuk P1, 0untuk dasi, dan -1untuk P2.

_{-1 byte, terima kasih kepada squid}

Perl 6 , 60 49 byte

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

Cobalah online!

Pengembalian More, Same, Lessuntuk P1 Wins, Tie, P2 Wins.

Penjelasan

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

Permintaan T-SQL, 148 byte

Menggunakan variabel tabel sebagai input

p: pemain

v: nilai untuk roll

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

Cobalah online

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

Jelly , 21 byte

^{hancur sebelum aku bahkan diposting oleh Nick Kennedy :)}

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

Tautan monadik yang menerima daftar pemain yang menampilkan daftar pemenang (diindeks).

Jadi P1 adalah [1], P2 adalah [2]dan seri [1,2].

Cobalah online!

PowerShell , 112 126 123 121 byte

Mengambil input sebagai (a)(b). Pengembalian -1untuk kemenangan P1, 1untuk P2 atau 0untuk seri.

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

Cobalah online!

Test case @( @(1,1,5,1,1), @(1,1,1,1,1), 1)ditambahkan.

Belum dibuka:

$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

Bahasa Wolfram (Mathematica) , 78 75 74 byte

-1 byte oleh Greg Martin

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

Cobalah online!

Output -1 saat pemain 1 menang, 1 saat pemain 2 menang, dan 0 untuk seri.

                                    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 terima kasih kepada @someone .
-21 byte terima kasih kepada @Neil .
-16 byte terima kasih @ceilingcat .

Kembali 1jika P1 menang; -1jika P2 menang;0jika itu dasi.

Cobalah online.

Penjelasan:

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

Jelly , 27 byte

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

Cobalah online!

1 untuk P1, -1 untuk P2, 0 untuk dasi

Penjelasan

’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

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

Dekompresi ke dalam fungsi Bahasa Wolfram ini:

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

yang ternyata persis sama dengan jawaban Mathematica saya .

Arang , 48 45 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Mengambil input sebagai array array dan output -1jika pemain 1 menang, 0untuk seri, dan 1jika pemain 2 menang. Penjelasan:

ＵＭθ⮌Ｅ⁷№ι∨λ¹

Ganti setiap tangan dengan hitungan berapa kali nilai 6..1muncul di tangan. Daftar dibalik karena a) membuatnya lebih mudah untuk menemukan nilai tertinggi dengan jumlah tertinggi dan b) membuatnya lebih mudah untuk menghapus hitungan 1s. Hitungan 1s digandakan karena harus dihapus dua kali, sekali untuk memeriksa bahwa itu bukan nol dan sekali lagi untuk menambahkannya ke jumlah lain.

ＵＭθ׬¬⊟ι⁺⊟ιι

Tambahkan jumlah 1s ke jumlah untuk 6..2, tetapi set semua jumlah menjadi nol jika jumlah 1s adalah nol.

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

Untuk masing-masing tangan menemukan hitungan tertinggi dan nilai tertinggi dengan penghitungan itu. (Sebenarnya kami menemukan nilai minus 6karena itu golfier.)

Ｉ⁻⌕θ⌈θ⌕θ⌊θ

Tentukan tangan mana yang dimenangkan dengan mengurangi posisi tangan yang menang dan yang kalah. (Jika tangan terikat maka tangan pertama menang dan kalah sehingga hasilnya 0seperti yang diinginkan.)

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;}

Cobalah online!

Membawa dua array bilangan nol yang diakhiri. Pengembalian 1, 0,-1 untuk P1 Wins, P2 Wins, Tie.

J , ⁴⁷ 44 byte

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

Cobalah online!

Terinspirasi oleh ide Nick Kennedy.

ungolfed

*@-&([: ({. ([: >./ #\@] + 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<>

Cobalah online!

Memasukkan:

Setiap pemain di jalur yang terpisah, tanpa spasi

Keluaran:

1 Baris satu menang

0 Dasi

-1 Baris dua menang