20

Un jeu de cartes est le produit cartésien des Scouleurs et des Rrangs. De nombreux jeux de cartes, mais pas tous, utilisent S=4et R∊{6,8,13}. Une main de Hcartes est distribuée depuis le jeu. Sa distribution , alias "motif de main", est un tableau qui décrit le nombre de cartes que vous avez obtenues de chaque couleur, en ignorant l'ordre des couleurs (donc, c'est comme un multi-set). Compte tenu d' une distribution Dsatisfaisant len(D)=S, 1≤sum(D)=H≤S×R, 0≤D[i]≤R, D[i]≥D[i+1], trouver la probabilité qu'il se produise.

Entrée: un entier Ret un tableau D.

Sortie: la probabilité avec au moins 5 chiffres après la virgule décimale; les zéros de fin peuvent être ignorés; la notation scientifique est correcte.

Échappatoires interdites. Victoires les plus courtes.

Tests:

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

Voir aussi Modèles de main de pont dans Wikipedia .

EDIT: suppression d'une restriction inutile H≤R

EDIT: contrainte supplémentaire H≥1

code-golf combinatorics probability-theory card-games ngn
la source

Peut-on supposer que D est trié?

orlp

1

@orip oui, c'est ce que je voulais dire par D [i] ≥D [i + 1]

ngn

Les cartes que je connais commencent à 1 et non à 0 ...

RosLuP

@RosLuP que voulez-vous dire?

2017

Je suis sûr que je n'ai pas compris quelque chose ... Si les cartes sont représentées à partir du numéro 1,2, ..., 13 tout * 4; alors qu'est-ce que cela signifie "13 0 0 0" dans l'exemple? 0 signifie la carte 0?

RosLuP

9

APL (Dyalog Unicode) , 30 caractères

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

Essayez-le en ligne!

Utilisation de la formule de @ orlp .

FrownyFrog
la source

Excellent, bravo! Le bouton "+100" indique que je dois attendre 10 heures de plus avant de pouvoir attribuer la prime. Après cela, j'en installerai un autre pour +200.

ngn

Ouais je gagne! merci @jayprich

FrownyFrog

@FrownyFrog Comment aimez-vous Dyalog APL par rapport à J?

Jonah

8

Python 3, 134 octets

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)

La formule est le produit de binom(R, d)pour chaque élément ddans D, fois factorial(len(D)), divisé par le produit de factorial(len(S))pour chacun Sdans les regroupements de D(par exemple, [4, 4, 3, 2]a des regroupements [[4, 4], [3], [2]]), finalement divisé parbinom(len(D) * R, sum(D)) .

Ou en notation mathématique, en supposant que m contient les multiplicités des n éléments uniques dans D :

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

$\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
la source

2

pour un bref moment, vous m'avez fait croire que PPCG prend désormais en charge LaTeX :)

ngn

En insérant les deux fonctions, j'ai obtenu 136 mais peut-être que l'on peut jouer plus (utilise i=0pour signifier b()et utilise R,Dpour n,k).

Jonathan Allan

7

R , 90 85 83 octets

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

Essayez-le en ligne!

J'ai observé la même chose que orlp , mais j'ai choisi un joli langage qui a des intégrations combinatoires.

Explication:

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
la source

Vous pouvez en enregistrer quelques autres avec ceci: "<"=choose(en dehors de la fonction) et potentiellement utiliser seq en fonction de la réponse de ngn au commentaire que j'ai posté ce matin.

JayCe

6

Gelée , 22 20 octets

-2 octets en utilisant un nouvel ʋatome rapide et un nouvel atome monadiqueẈ

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

Un lien dyadique, prenant la distribution distribuée, D, à gauche et le nombre de rangs, R, à droite, qui renvoie la probabilité d'occurrence.

Essayez-le en ligne! ou voir la suite de tests

Comment?

ĠẈ!;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
la source

5

05AB1E , 21 octets

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

Essayez-le en ligne!

Explication

 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
la source

3

Pyth , 32 octets

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

Essayez-le ici! ou Vérifiez tous les cas de test!

Comment ça marche?

cc *.! lQ * F.cLvzQ * F.! hMr8Q.c * vzlQs ~ Programme complet. D = liste, R = nombre.

   .! ~ La factorielle de ...
     lQ ~ La longueur de D.
  * ~ Multiplié par ...
       * F ~ Le produit des éléments de ...
         .c ~ Le nCr entre ...
           LQ ~ Chaque élément de D, et ...
            vz ~ R.
 c ~ Divisé par ...
               * F ~ Le produit des éléments de ...
                 .! ~ La factorielle de chacun ...
                   hM ~ Têtes. Nombre d'éléments adjacents dans ...
                     r8Q ~ Le codage de la longueur d'exécution de D.
c ~ Divisé par ...
                        .c ~ Le nCr entre ...
                          * ~ Le produit de ...
                           vz ~ R, et ...
                             lQ ~ La longueur de D.
                               s ~ Et la somme de D.
                                 ~ Sortie implicite.

M. Xcoder
la source

3

APL (Dyalog) , 42 octets

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

Essayez-le en ligne!

Toujours au golf.

Uriel
la source

défi: 30 octets

ngn

Défi @ngn accepté

Uriel

Désolé, c'est en fait 30 caractères . Avec le risque de divulguer des informations: un de mes personnages n'est pas dans le jeu de caractères Classic, je ne m'en suis pas rendu compte au début.

2017

@ngn Ne pouvez-vous pas simplement utiliser le jeu de caractères d'Adám pour lui donner 30 octets?

Probie

@Probie yep, c'est ce que je voulais dire par "SBCS" dans la description de la prime

ngn

2

Clojure, 153 octets

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

Juste une simulation de force brute, pour obtenir plus de précision, augmentez le nombre d'itérations et la valeur "1 / N" à la fin en conséquence. Le premier argument est le nombre et le deuxième argument est le nombre de cartes dans le jeu par suite.

NikoNyrh
la source

2

J, 57 octets

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

Essayez-le en ligne!

Cela fonctionne en O (golf) et étouffera de nombreux cas de test (bien que fonctionne théoriquement), ce qui serait bien si c'était plus golfeur. Mais je suis coincé à le réduire, surtout en évitant ceux répétés "1. Si quelqu'un veut aider, voici la version analysée ...

Le côté droit de la fourche principale est toutes les offres possibles du jeu , et le côté gauche de la fourche principale est juste l'argument de droite d'origine, c'est-à-dire le masque de combinaison auquel nous correspondons.

À l'intérieur, à partir de chaque deck "mélangé", nous prenons les éléments de première main , puis les regroupons à l'aide de la clé /.et trions le résultat, et vérifions si cela correspond au masque de costume en question. Nous additionnons le nombre total qui correspond et divisons cela en la longueur de tous les ponts possibles.

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

Jonas
la source

1

La formule d'Orlp a marqué 42 pour APL, peut-être que cela marquerait moins de 58 sur J?

Uriel

1

f=:(([:!#)%[:*/[:!#/.~)@]**/@(]![)%+/@]![*#@]

J'obtiens

Modèles de main dans un jeu de cartes

Réponses:

APL (Dyalog Unicode) , 30 caractères

Python 3, 134 octets

R , 90 85 83 octets

Gelée , 22 20 octets

Comment?

05AB1E , 21 octets

Pyth , 32 octets

Comment ça marche?

APL (Dyalog) , 42 octets

Clojure, 153 octets

J, 57 octets