20

Una baraja de cartas es el producto cartesiano de Spalos y Rrangos. Muchos, aunque no todos, usan juegos de cartas S=4y R∊{6,8,13}. Se Hreparte una mano de cartas del mazo. Su distribución , también conocida como "patrón de mano", es una matriz que describe cuántas cartas obtuviste de cada palo, ignorando el orden del palo (por lo tanto, es como un conjunto múltiple). Dada una distribución de Dsatisfacer len(D)=S, 1≤sum(D)=H≤S×R, 0≤D[i]≤R, D[i]≥D[i+1], encontrar la probabilidad de que ocurra.

Entrada: un entero Ry una matriz D.

Salida: la probabilidad con al menos 5 dígitos después de la marca decimal; se pueden omitir los ceros finales; La notación científica está bien.

Lagunas prohibidas. Las victorias más cortas.

Pruebas:

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

Vea también Patrones de mano de puente en Wikipedia .

EDITAR: se eliminó la restricción innecesaria H≤R

EDITAR: restricción añadida H≥1

— ngn
fuente

¿Podemos suponer que D está ordenado?

— orlp

1

@orip sí, eso es lo que quería decir con D [i] ≥D [i + 1]

— NGN

Las cartas que conozco comienzan desde 1 no desde 0 ...

— RosLuP

@RosLuP, ¿qué quieres decir?

— ngn

Estoy seguro de que no entendí algo ... Si las Tarjetas se representan desde el número 1,2, ..., 13, todas * 4; Entonces, ¿qué significa "13 0 0 0" en el ejemplo? 0 significa tarjeta 0?

— RosLuP

9

APL (Dyalog Unicode) , 30 caracteres

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

Pruébalo en línea!

Usando la fórmula de @ orlp .

— FrownyFrog
fuente

Excelente, bien hecho! El botón "+100" dice que debo esperar 10 horas más antes de poder otorgar la recompensa. Después de eso, configuraré otro para +200.

— ngn

Yay yo gano! gracias @jayprich

— FrownyFrog

@FrownyFrog ¿Cómo te gusta Dyalog APL en comparación con J?

— Jonás

8

Python 3, 134 bytes

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 fórmula es el producto de binom(R, d)para cada elemento den D, tiempos factorial(len(D)), dividido por el producto de factorial(len(S))para cada uno Sen las agrupaciones de D(por ejemplo, [4, 4, 3, 2]tiene agrupaciones [[4, 4], [3], [2]]), finalmente dividido por binom(len(D) * R, sum(D)).

O en notación matemática, suponiendo que m contiene las multiplicidades de los n elementos únicos en 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
fuente

2

por un breve momento en el que me hizo creer PPCG ahora es compatible con LaTeX :)

— NGN

Al alinear las dos funciones obtuve 136, pero tal vez eso se pueda jugar más (usa i=0para significar b()y usa R,Dpara n,k).

— Jonathan Allan el

7

R , 90 85 83 bytes

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

Pruébalo en línea!

Observé lo mismo que orlp , pero elegí un lenguaje agradable que tiene incorporados combinatorios.

Explicación:

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
fuente

Puede guardar algunos más con esto: "<"=choose(fuera de la función) y potencialmente usar seq dependiendo de la respuesta de ngn al comentario que publiqué esta mañana.

— JayCe

6

Jalea , 22 20 bytes

-2 bytes usando un nuevo rápido ʋ, y un nuevo átomo monádicoẈ

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

Un enlace diádico, tomando la distribución repartida, D, a la izquierda y el número de rangos, R, a la derecha, que devuelve la probabilidad de ocurrencia.

Pruébalo en línea! o ver el conjunto de pruebas

¿Cómo?

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

5

05AB1E , 21 bytes

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

Pruébalo en línea!

Explicación

 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
fuente

3

Pyth , 32 bytes

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

Pruébalo aquí! o Verifique todos los casos de prueba!

¿Cómo funciona esto?

cc *.! lQ * F.cLvzQ * F.! hMr8Q.c * vzlQs ~ Programa completo. D = lista, R = número.

   .! ~ El factorial de ...
     lQ ~ La longitud de D.
  * ~ Multiplicado por ...
       * F ~ El producto de los elementos de ...
         .c ~ El nCr entre ...
           LQ ~ Cada elemento de D, y ...
            vz ~ R.
 c ~ Dividido por ...
               * F ~ El producto de los elementos de ...
                 .! ~ El factorial de cada ...
                   hM ~ Jefes. Conteo de elementos adyacentes en ...
                     r8Q ~ La codificación de longitud de ejecución de D.
c ~ Dividido por ...
                        .c ~ El nCr entre ...
                          * ~ El producto de ...
                           vz ~ R, y ...
                             lQ ~ La longitud de D.
                               s ~ Y la suma de D.
                                 ~ Salida implícitamente.

— Sr. Xcoder
fuente

3

APL (Dyalog) , 42 bytes

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

Pruébalo en línea!

Todavía jugando al golf.

— Uriel
fuente

desafío: 30 bytes

— ngn

desafío @ngn aceptado

— Uriel

Lo siento, en realidad son 30 caracteres . Con el riesgo de regalar información: uno de mis caracteres no está en el juego de caracteres clásico, al principio no me di cuenta.

— ngn

@ngn ¿No puedes usar el juego de caracteres de Adám para que sea de 30 bytes?

— Probie

@Probie sí, eso es lo que quería decir con "SBCS" en la descripción de recompensas

— NGN

2

Clojure, 153 bytes

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

Solo una simulación de fuerza bruta, para obtener más precisión, aumente el recuento de iteraciones y el valor "1 / N" al final en consecuencia. El primer argumento es el recuento y el segundo argumento es el número de cartas en el mazo por suite.

— NikoNyrh
fuente

2

J, 57 bytes

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

Pruébalo en línea!

Esto se ejecuta en O (golf) y se ahogará en muchos de los casos de prueba (aunque funciona teóricamente), lo que estaría bien si fuera más golfista. Pero estoy atascado en recortarlo, especialmente para evitar que se repitan "1. Si alguien quiere ayudar, aquí está la versión analizada ...

El lado derecho de la bifurcación principal es todas las ofertas posibles de la baraja , y el lado izquierdo de la bifurcación principal es solo el argumento derecho original, es decir, la máscara de traje con la que estamos haciendo coincidir.

En el interior, de cada mazo "barajado", tomamos los elementos de primera mano , luego los agrupamos con la llave /.y clasificamos el resultado, y verificamos si eso coincide con la máscara del traje en cuestión. Agregamos sumamos el número total que coinciden, y lo dividimos en la longitud de todas las barajas posibles.

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

— Jonás
fuente

1

La fórmula de Orlp obtuvo 42 para APL, ¿tal vez eso obtendría menos de 58 en J?

— Uriel

1

Tengo 45 hasta ahora de esa manera f=:(([:!#)%[:*/[:!#/.~)@]**/@(]![)%+/@]![*#@] TIO

— jayprich

Patrones de mano en un juego de cartas

APL (Dyalog Unicode) , 30 caracteres

Python 3, 134 bytes

R , 90 85 83 bytes

Jalea , 22 20 bytes

¿Cómo?

05AB1E , 21 bytes

Pyth , 32 bytes

¿Cómo funciona esto?

APL (Dyalog) , 42 bytes

Clojure, 153 bytes

J, 57 bytes