20

Setumpuk kartu adalah produk Sjas dan Rpangkat Cartesian . Banyak, meskipun tidak semua, permainan kartu menggunakan S=4dan R∊{6,8,13}. Satu tangan Hkartu dibagikan dari geladak. Its distribusi , alias "pola tangan", adalah sebuah array yang menggambarkan berapa banyak kartu Anda dapatkan dari masing-masing sesuai, mengabaikan perintah suit (jadi, itu seperti multi-set). Mengingat distribusi Dmemuaskan len(D)=S, 1≤sum(D)=H≤S×R, 0≤D[i]≤R, D[i]≥D[i+1], menemukan kemungkinan itu terjadi.

Input: integer Rdan array D.

Output: probabilitas dengan setidaknya 5 digit setelah tanda desimal; nol tertinggal dapat dilewati; notasi ilmiah tidak apa-apa.

Celah terlarang. Kemenangan terpendek.

Tes:

R    D               probability
13   4 4 3 2     ->  0.2155117564516334148528314355068773
13   5 3 3 2     ->  0.1551684646451760586940386335649517
13   9 3 1 0     ->  0.0001004716813294328274372174524508
13   13 0 0 0    ->  0.0000000000062990780897964308603403
8    3 2 2 1     ->  0.4007096203759162602321667950144035
8    4 2 1 1     ->  0.1431105787056843786543452839337155
8    2 2 1 0     ->  0.3737486095661846496106785317018910
8    3 1 1 0     ->  0.2135706340378197997775305895439377
15   4 4 3 2 1   ->  0.1428926269185580521441708109954798
10   3 0 0       ->  0.0886699507389162561576354679802956
10   2 1 0       ->  0.6650246305418719211822660098522167
10   1 1 1       ->  0.2463054187192118226600985221674877

Lihat juga pola jembatan tangan di Wikipedia .

EDIT: menjatuhkan batasan yang tidak perlu H≤R

EDIT: kendala tambahan H≥1

— ngn
sumber

Bisakah kita berasumsi bahwa D diurutkan?

— orlp

1

@orip ya, itulah yang saya maksud dengan D [i] ≥D [i + 1]

— ngn

Kartu yang saya tahu mulai dari 1 bukan dari 0 ...

— RosLuP

@ RosLuP apa maksudmu?

— ngn

Saya yakin saya tidak mengerti sesuatu ... Jika Kartu diwakili dari nomor 1,2, ..., 13 semua * 4; jadi apa artinya "13 0 0 0" misalnya? 0 berarti kartu 0?

— RosLuP

9

APL (Dyalog Unicode) , 30 karakter

×/!⍨,z,1÷((z←!∘≢⊢)⌸⊢),×∘≢!⍨1⊥⊢

Cobalah online!

Menggunakan rumus @ orlp .

— FrownyFrog
sumber

Luar biasa, bagus sekali! Tombol "+100" mengatakan saya harus menunggu 10 jam lagi sebelum saya bisa memberi hadiah. Setelah itu saya akan menyiapkan satu lagi untuk +200.

— ngn

Yay, aku menang! terima kasih @jayprich

— FrownyFrog

@FrownyFrog Bagaimana kamu menyukai Dyalog APL dibandingkan dengan J?

— Jonah

8

Python 3, 134 byte

b=lambda n,k:k<1or n*b(n-1,k-1)/k
f=lambda R,D,i=1,s=1,t=0:D and b(R,D[0])*i/s*f(R,D[1:],i+1,(D[0]in D[1:])*s+1,t+D[0])or 1/b(~-i*R,t)

Formula adalah produk binom(R, d)untuk setiap elemen ddalam D, kali factorial(len(D)), dibagi dengan produk factorial(len(S))untuk masing-masing Sdalam pengelompokan D(misalnya [4, 4, 3, 2]memiliki pengelompokan [[4, 4], [3], [2]]), akhirnya dibagi oleh binom(len(D) * R, sum(D)).

Atau dalam notasi matematika, anggap m berisi banyaknya elemen n unik dalam D :

\frac{| D |!}{m_{1}! \cdot m_{2}! \dots m_{n}!} {(\binom{| D | \cdot R}{\sum D})}^{- 1} \prod_{d \in D} (\binom{R}{d})

$\frac{|D|!}{m_1!\cdot m_2!\cdots m_n!} \binom{|D|\cdot R}{\sum D}^{-1} \prod_{d\in D}\binom{R}{d}$

— orlp
sumber

2

untuk sesaat kau membuatku yakin PPCG sekarang mendukung LaTeX :)

— ngn

Menggarisbawahi dua fungsi yang saya dapat 136 tetapi mungkin itu bisa golf lebih (kegunaan i=0berarti b()dan kegunaan R,Duntuk n,k).

— Jonathan Allan

7

R , 90 85 83 byte

function(R,D,l=sum(D|1),K=choose)prod(K(R,D),1:l,1/gamma(1+table(D)))/K(R*l,sum(D))

Cobalah online!

Saya mengamati hal yang sama dengan orlp , tetapi saya memilih bahasa yang bagus yang memiliki kombinatorik bawaan.

Penjelasan:

function(R,D,             # next are optional arguments
 l=sum(D|1),              # alias for length of D, aka S
 K=choose)                # alias for choose
  prod(                   # take the product of:
    K(R,D),               # "choose" is vectorized over R and D
    1:l,                  # S!
    1/gamma(1+            # gamma(n+1) = n! for integer n
     table(D))            # multiplicities of unique elements of D
  ) /                     # divide by
  K(R*l, sum(D))          # R*S choose H
                          # return last computation (which is all the computation)

— Giuseppe
sumber

Anda dapat menyimpan lebih banyak dengan ini: "<"=choose(di luar fungsi) dan berpotensi menggunakan seq tergantung pada jawaban ngn untuk komentar yang saya posting pagi ini.

— JayCe

6

Jelly , 22 20 byte

-2 byte menggunakan cepat baru ʋ,, dan atom monadik baruẈ

ĠẈ!;L×c⁸S¤ʋ
L!;c@÷çP

Sebuah link diad, mengambil distribusi-ditangani, D, di sebelah kiri dan jumlah peringkat, R, di sebelah kanan, yang mengembalikan probabilitas terjadinya.

Cobalah online! atau lihat test-suite

Bagaimana?

ĠẈ!;L×c⁸S¤ʋ - Link 1, denomParts: list, distribution (D); number, ranks (R)
                                                                 e.g. [3,3,3,2,2]; 8
Ġ           - group indices of D by their values                      [[4,5],[1,2,3]]
 Ẉ          - length of each group                                    [2,3]
  !         - factorial (vectorises)                                  [2,6]
          ʋ - last four links as a dyad
            - ... i.e. totalWaysToDeal = f(list, distribution (D); number, ranks (R)):
    L       - length of D                                             5
     ×      - multiply by R = total number of cards                   40
         ¤  - nilad followed by link(s) as a nilad:
       ⁸    -   chain's left argument, D                              [3,3,3,2,2]
        S   -   sum = total cards dealt                               13
      c     - binomial                                        40C13 = 12033222880
   ;        - concatenate                                             [2,6,12033222880]                                                  

L!;c@÷çP - Main link: list, distribution (D); number, ranks (R)
         -                                                  e.g. [3,3,3,2,2]; 8
L        - length of D = number of suits                         5
 !       - factorial                                             120
   c@    - R binomial (vectorised across) D     (8C3=56;8C2=28)  [56,56,56,28,28]
  ;      - concatenate                                           [120,56,56,56,28,28]
      ç  - call the last link (1) as a dyad = denomParts(D,R)    [2,6,12033222880]
     ÷   - divide (vectorises)                                   [120/2,56/6,56/12033222880,56,28,28]
       P - product                                               0.11441900924883391

— Jonathan Allan
sumber

5

05AB1E , 21 byte

cP¹g!*¹γ€g!P¹gI*¹Oc*/

Cobalah online!

Penjelasan

 P                      # product of
c                       # bin(input1,input2)
     *                  # multiplied by
    !                   # fac of
  ¹g                    # length of input1
                    /   # divided by
           P            # product of
          !             # fac of each
        €g              # length of each
      ¹γ                # chunk of consecutive equal elements of input1
                   *    # multiplied by
                  c     # bin of
            ¹g          # length of input1
              I*        # times input2
                ¹O      # and sum of input1

— Emigna
sumber

3

Pyth , 32 byte

cc*.!lQ*F.cLvzQ*F.!hMr8Q.c*vzlQs

Coba di sini! atau Verifikasi semua test case!

Bagaimana ini bekerja?

cc *.! lQ * F.cLvzQ * F.! hMr8Q.c * vzlQs ~ Program lengkap. D = daftar, R = angka.

   .! ~ Faktorial dari ...
     lQ ~ Panjang D.
  * ~ Dikalikan dengan ...
       * F ~ Produk dari elemen ...
         .c ~ nCr di antara ...
           LQ ~ Setiap elemen D, dan ...
            vz ~ R.
 c ~ Dibagi dengan ...
               * F ~ Produk dari elemen ...
                 .! ~ Faktorial dari masing-masing ...
                   hM ~ Kepala. Hitungan elemen yang berdekatan di ...
                     r8Q ~ Pengkodean panjang run dari D.
c ~ Dibagi dengan ...
                        .c ~ nCr di antara ...
                          * ~ Produk dari ...
                           vz ~ R, dan ...
                             lQ ~ Panjang D.
                               s ~ dan jumlah D.
                                 ~ Output secara implisit.

— Tuan Xcoder
sumber

3

APL (Dyalog) , 42 byte

{×/(!≢⍵),(⍵!⍺),÷((+/⍵)!⍺×≢⍵),!≢¨⍵⊂⍨1,2≠/⍵}

Cobalah online!

Masih bermain golf.

— Uriel
sumber

tantangan: 30 byte

— ngn

@ngn tantangan diterima

— Uriel

Maaf, sebenarnya ini 30 karakter . Dengan risiko memberikan informasi: salah satu karakter saya tidak ada di karakter Klasik, saya tidak menyadarinya pada awalnya.

— ngn

@ ngn Tidak bisakah Anda menggunakan set karakter Adám untuk membuatnya 30 byte?

— Probie

@Robie ya, itulah yang saya maksud dengan "SBCS" dalam deskripsi hadiah

— ngn

2

Clojure, 153 byte

#(apply +(for[_(range 1e06):when(=(remove #{0}%)(reverse(sort(vals(frequencies(take(apply + %)(shuffle(for[i(range %2)j(range(count %))]j))))))))]1e-06))

Hanya simulasi brute-force, untuk mendapatkan presisi yang lebih baik, hitung jumlah iterasi dan nilai "1 / N" pada akhirnya. Argumen pertama adalah jumlah dan argumen ke-2 adalah jumlah kartu di dek per suite.

— NikoNyrh
sumber

2

J, 57 byte

](#@]%~[:+/[-:"1[:\:~@(#/.~)"1+/@[{."1])i.@!@(*+/)A.(##\)

Cobalah online!

Ini berjalan di O (golf) dan akan tersedak banyak kasus uji (meskipun bekerja secara teoritis), yang akan baik-baik saja jika itu golfier. Tapi saya terjebak memotongnya, terutama dengan menghindari yang berulang "1. Jika ada yang ingin membantu, inilah versi yang diuraikan ...

Sisi kanan garpu utama adalah semua penawaran yang mungkin dari dek , dan sisi kiri garpu utama adalah hanya arg tepat asli, yaitu, gugatan topeng kita pencocokan sedang melawan.

Di dalam, dari setiap dek "dikocok", kami mengambil elemen tangan pertama , lalu mengelompokkannya menggunakan kunci /.dan mengurutkan hasilnya, dan memeriksa apakah itu cocok dengan topeng setelan yang dimaksud. Kami menambahkan menjumlahkan jumlah total yang cocok, dan membaginya menjadi panjang semua deck yang mungkin.

┌─┬─────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────┐
│]│┌───────┬─────┬─────────────────────────────────────────────────────────────────────────────────┐│┌──────────────────────┬──┬─────────┐│
│ ││┌─┬─┬─┐│┌─┬─┐│┌──┬─────┬──────────────────────────────────────────────────────────────────────┐│││┌────────┬─┬─────────┐│A.│┌─┬─────┐││
│ │││#│@│]│││%│~│││[:│┌─┬─┐│┌─┬────────┬─────────────────────────────────────────────────────────┐│││││┌──┬─┬─┐│@│┌─┬─────┐││  ││#│┌─┬─┐│││
│ ││└─┴─┴─┘│└─┴─┘││  ││+│/│││[│┌──┬─┬─┐│┌──┬───────────────────────────┬────────────────────────┐│││││││i.│@│!││ ││*│┌─┬─┐│││  ││ ││#│\││││
│ ││       │     ││  │└─┴─┘││ ││-:│"│1│││[:│┌─────────────────────┬─┬─┐│┌───────────┬────────┬─┐│││││││└──┴─┴─┘│ ││ ││+│/││││  ││ │└─┴─┘│││
│ ││       │     ││  │     ││ │└──┴─┴─┘││  ││┌──────┬─┬──────────┐│"│1│││┌─────┬─┬─┐│┌──┬─┬─┐│]││││││││        │ ││ │└─┴─┘│││  │└─┴─────┘││
│ ││       │     ││  │     ││ │        ││  │││┌──┬─┐│@│┌──────┬─┐││ │ ││││┌─┬─┐│@│[│││{.│"│1││ ││││││││        │ │└─┴─────┘││  │         ││
│ ││       │     ││  │     ││ │        ││  ││││\:│~││ ││┌─┬──┐│~│││ │ │││││+│/││ │ ││└──┴─┴─┘│ │││││││└────────┴─┴─────────┘│  │         ││
│ ││       │     ││  │     ││ │        ││  │││└──┴─┘│ │││#│/.││ │││ │ ││││└─┴─┘│ │ ││        │ ││││││└──────────────────────┴──┴─────────┘│
│ ││       │     ││  │     ││ │        ││  │││      │ ││└─┴──┘│ │││ │ │││└─────┴─┴─┘│        │ ││││││                                     │
│ ││       │     ││  │     ││ │        ││  │││      │ │└──────┴─┘││ │ ││└───────────┴────────┴─┘│││││                                     │
│ ││       │     ││  │     ││ │        ││  ││└──────┴─┴──────────┘│ │ ││                        │││││                                     │
│ ││       │     ││  │     ││ │        ││  │└─────────────────────┴─┴─┘│                        │││││                                     │
│ ││       │     ││  │     ││ │        │└──┴───────────────────────────┴────────────────────────┘││││                                     │
│ ││       │     ││  │     │└─┴────────┴─────────────────────────────────────────────────────────┘│││                                     │
│ ││       │     │└──┴─────┴──────────────────────────────────────────────────────────────────────┘││                                     │
│ │└───────┴─────┴─────────────────────────────────────────────────────────────────────────────────┘│                                     │
└─┴─────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────┘

— Yunus
sumber

1

Formula Orlp memberi skor 42 untuk APL, mungkin skornya kurang dari 58 untuk J?

— Uriel

1

Saya mendapatkan 45 sejauh itu dengan f=:(([:!#)%[:*/[:!#/.~)@]**/@(]![)%+/@]![*#@] TIO

— jayprich

Pola tangan dalam permainan kartu

APL (Dyalog Unicode) , 30 karakter

Python 3, 134 byte

R , 90 85 83 byte

Jelly , 22 20 byte

Bagaimana?

05AB1E , 21 byte

Pyth , 32 byte

Bagaimana ini bekerja?

APL (Dyalog) , 42 byte

Clojure, 153 byte

J, 57 byte