Wzory rąk w grze karcianej

20

Talia kart to kartezjański produkt w Skolorach i Rszeregach. Wiele, choć nie wszystkie, używa gier karcianych S=4i R∊{6,8,13}. Układ Hkart jest rozdawany z talii. Jego rozkład , zwany również „wzorem ręki”, jest tablicą, która opisuje liczbę kart, które otrzymałeś z każdego koloru, ignorując kolejność kolorów (więc jest to jak zestaw wielokrotny). Biorąc pod uwagę rozkład Dsatysfakcjonujące len(D)=S, 1≤sum(D)=H≤S×R, 0≤D[i]≤R, D[i]≥D[i+1], znaleźć prawdopodobieństwo jej wystąpienia.

Dane wejściowe: liczba całkowita Ri tablica D.

Wyjście: prawdopodobieństwo, że co najmniej 5 cyfr po znaku dziesiętnym; końcowe zera mogą być pomijane; notacja naukowa jest w porządku.

Luki zabronione. Najkrótsze wygrane.

Testy:

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

Zobacz także Most wzory ręcznie w Wikipedii .

EDYCJA: usunięto niepotrzebne ograniczenia H≤R

EDYCJA: dodano ograniczenie H≥1

code-golf  combinatorics  probability-theory  card-games 
— ngn
źródło
Czy możemy założyć, że D jest posortowane?
— orlp
1
@orip tak, to właśnie miałem na myśli D [i] ≥D [i + 1]
— ngn
— Znane
@RosLuP co masz na myśli?
— ngn
Jestem pewien, że czegoś nie zrozumiałem ... Jeśli Karty są reprezentowane od numeru 1,2, ..., 13 wszystkie * 4; co to znaczy na przykład „13 0 0 0”? 0 oznacza kartę 0?
— RosLuP,

Odpowiedzi:

8

Python 3, 134 bajty

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 jest iloczynem binom(R, d)każdego elementu dw Dczasie factorial(len(D)), podzielonym przez iloczyn factorial(len(S))każdego Sz grup D(np. [4, 4, 3, 2]Ma grupy [[4, 4], [3], [2]]), ostatecznie podzielonych przez binom(len(D) * R, sum(D)).

Lub w notacji matematycznej, zakładając, że m zawiera krotność n unikalnych elementów w D :

|re|!m1!⋅m2)!⋯mn!(|re|⋅R∑re)-1∏re∈re(Rre)

— orlp
źródło
2
przez krótką chwilę sprawiłeś, że uwierzyłem, że PPCG obsługuje teraz LaTeX :)
— ngn
Biorąc pod uwagę te dwie funkcje, otrzymałem 136, ale może to może być bardziej gra w golfa (używa i=0na myśli b()i używa R,Dna n,k).
— Jonathan Allan,
7

R , 90 85 83 bajtów

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

Wypróbuj online!

Obserwowałem to samo co orlp , ale wybrałem fajny język, który ma wbudowane kombinatoryki.

Wyjaśnienie:

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
źródło
Możesz zaoszczędzić jeszcze kilka: "<"=choose(poza funkcją) i potencjalnie użyć sekw. W zależności od odpowiedzi ngn na komentarz, który opublikowałem dziś rano.
— JayCe
6

Galaretka ,  22  20 bajtów

-2 bajty przy użyciu nowego szybkiego ʋi nowego atomu monadycznegoẈ

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

Diadadicowe połączenie, biorąc rozkład zadany, D, po lewej i liczbę stopni, R, po prawej, co zwraca prawdopodobieństwo wystąpienia.

Wypróbuj online! lub zobacz zestaw testowy

W jaki sposób?

ĠẈ!;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
źródło
5

05AB1E , 21 bajtów

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

Wypróbuj online!

Wyjaśnienie

 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
źródło
3

Pyth , 32 bajty

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

Wypróbuj tutaj! lub Zweryfikuj wszystkie przypadki testowe!

Jak to działa

cc *.! lQ * F.cLvzQ * F.! hMr8Q.c * vzlQs ~ Pełny program. D = lista, R = liczba.

   .! ~ Silnia ...
     lQ ~ długość D.
  * ~ Pomnożone przez ...
       * F ~ Produkt elementów ...
         .c ~ nCr między ...
           LQ ~ Każdy element D i ...
            vz ~ R.
 c ~ Podzielone przez ...
               * F ~ Produkt elementów ...
                 .! ~ Silnia każdego ...
                   hM ~ Heads. Liczba sąsiednich elementów w ...
                     r8Q ~ Kodowanie długości przebiegu D.
c ~ Podzielone przez ...
                        .c ~ nCr między ...
                          * ~ Produkt ...
                           vz ~ R i ...
                             lQ ~ długość D.
                               s ~ I suma D.
                                 ~ Wynik niejawnie.
— Pan Xcoder
źródło
3

APL (Dyalog) , 42 bajty

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

Wypróbuj online!

Wciąż gra w golfa.

— Uriel
źródło
wyzwanie: 30 bajtów
— ngn
Przyjęte wyzwanie @ngn
— Uriel
Przepraszamy, to w rzeczywistości 30 znaków . Ryzykując, że przekażę informacje: jednego z moich znaków nie ma w klasycznym zestawie znaków, na początku nie zdawałem sobie z tego sprawy.
— ngn
@ngn Czy nie możesz po prostu użyć zestawu znaków Adáma, aby mieć 30 bajtów?
— Probie
@Probie tak, to właśnie miałem na myśli przez „SBCS” w opisie nagrody
— ngn
2

Clojure, 153 bajty

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

Tylko symulacja brutalnej siły, aby uzyskać większą precyzję, odpowiednio zwiększ liczbę iteracji i wartość „1 / N” na końcu. Pierwszy argument to liczby, a drugi argument to liczba kart w talii na zestaw.

— NikoNyrh
źródło
2

J, 57 bajtów

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

Wypróbuj online!

Działa to w trybie O (golf) i dusi wiele przypadków testowych (choć działa teoretycznie), co byłoby w porządku, gdyby były bardziej golfowe. Ale utknąłem przy przycinaniu go, szczególnie z unikaniem tych powtarzających się "1. Jeśli ktoś chce pomóc, oto przeanalizowana wersja ...

Prawa strona głównego rozwidlenia to wszystkie możliwe oferty talii , a lewa strona głównego rozwidlenia to tylko oryginalny prawy argument, tj. Maska koloru, z którą się dopasowujemy.

Wewnątrz, z każdej „tasowanej” talii, bierzemy elementy z pierwszej ręki , następnie grupujemy je za pomocą klucza /.i sortujemy wynik, i sprawdzamy, czy pasuje do danej maski koloru. Dodajemy całkowitą liczbę pasujących elementów i dzielimy ją na długość wszystkich możliwych talii.

┌─┬─────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────┐
│]│┌───────┬─────┬─────────────────────────────────────────────────────────────────────────────────┐│┌──────────────────────┬──┬─────────┐│
│ ││┌─┬─┬─┐│┌─┬─┐│┌──┬─────┬──────────────────────────────────────────────────────────────────────┐│││┌────────┬─┬─────────┐│A.│┌─┬─────┐││
│ │││#│@│]│││%│~│││[:│┌─┬─┐│┌─┬────────┬─────────────────────────────────────────────────────────┐│││││┌──┬─┬─┐│@│┌─┬─────┐││  ││#│┌─┬─┐│││
│ ││└─┴─┴─┘│└─┴─┘││  ││+│/│││[│┌──┬─┬─┐│┌──┬───────────────────────────┬────────────────────────┐│││││││i.│@│!││ ││*│┌─┬─┐│││  ││ ││#│\││││
│ ││       │     ││  │└─┴─┘││ ││-:│"│1│││[:│┌─────────────────────┬─┬─┐│┌───────────┬────────┬─┐│││││││└──┴─┴─┘│ ││ ││+│/││││  ││ │└─┴─┘│││
│ ││       │     ││  │     ││ │└──┴─┴─┘││  ││┌──────┬─┬──────────┐│"│1│││┌─────┬─┬─┐│┌──┬─┬─┐│]││││││││        │ ││ │└─┴─┘│││  │└─┴─────┘││
│ ││       │     ││  │     ││ │        ││  │││┌──┬─┐│@│┌──────┬─┐││ │ ││││┌─┬─┐│@│[│││{.│"│1││ ││││││││        │ │└─┴─────┘││  │         ││
│ ││       │     ││  │     ││ │        ││  ││││\:│~││ ││┌─┬──┐│~│││ │ │││││+│/││ │ ││└──┴─┴─┘│ │││││││└────────┴─┴─────────┘│  │         ││
│ ││       │     ││  │     ││ │        ││  │││└──┴─┘│ │││#│/.││ │││ │ ││││└─┴─┘│ │ ││        │ ││││││└──────────────────────┴──┴─────────┘│
│ ││       │     ││  │     ││ │        ││  │││      │ ││└─┴──┘│ │││ │ │││└─────┴─┴─┘│        │ ││││││                                     │
│ ││       │     ││  │     ││ │        ││  │││      │ │└──────┴─┘││ │ ││└───────────┴────────┴─┘│││││                                     │
│ ││       │     ││  │     ││ │        ││  ││└──────┴─┴──────────┘│ │ ││                        │││││                                     │
│ ││       │     ││  │     ││ │        ││  │└─────────────────────┴─┴─┘│                        │││││                                     │
│ ││       │     ││  │     ││ │        │└──┴───────────────────────────┴────────────────────────┘││││                                     │
│ ││       │     ││  │     │└─┴────────┴─────────────────────────────────────────────────────────┘│││                                     │
│ ││       │     │└──┴─────┴──────────────────────────────────────────────────────────────────────┘││                                     │
│ │└───────┴─────┴─────────────────────────────────────────────────────────────────────────────────┘│                                     │
└─┴─────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────┘
— Jonasz
źródło
1
Formuła Orlpa uzyskała 42 za APL, może to oznaczałoby mniej niż 58 na J?
— Uriel,
1
Do tej pory mam 45 f=:(([:!#)%[:*/[:!#/.~)@]**/@(]![)%+/@]![*#@] TIO
— jayprich
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.