20

Un mazzo di carte è il prodotto cartesiano di Ssemi e Rgradi. Molti, sebbene non tutti, i giochi di carte utilizzano S=4e R∊{6,8,13}. Una mano di Hcarte viene distribuita dal mazzo. La sua distribuzione , nota anche come "modello mano", è un array che descrive quante carte hai ottenuto da ogni seme, ignorando l'ordine dei semi (quindi, è come un multi-set). Dato una distribuzione Dsoddisfacente len(D)=S, 1≤sum(D)=H≤S×R, 0≤D[i]≤R, D[i]≥D[i+1], la probabilità che esso si manifesti.

Input: un numero intero Re un array D.

Output: la probabilità con almeno 5 cifre dopo il segno decimale; gli zeri finali possono essere saltati; la notazione scientifica è ok.

Scappatoie vietate. Vittorie più brevi.

test:

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

Vedi anche i modelli di mani Bridge in Wikipedia .

EDIT: abbandonato restrizione inutile H≤R

EDIT: vincolo aggiunto H≥1

— NGN
fonte

Possiamo supporre che D sia ordinato?

— orlp

1

@orip yes, ecco cosa intendevo con D [i] ≥D [i + 1]

— ngn

Le carte che conosco iniziano da 1 non da 0 ...

— RosLuP

@RosLuP cosa intendi?

— ngn

Sono sicuro di non aver capito qualcosa ... Se le carte sono rappresentate dal numero 1,2, ..., 13 tutte * 4; quindi cosa significa "13 0 0 0" nell'esempio? 0 significa carta 0?

— RosLuP,

9

APL (Dyalog Unicode) , 30 caratteri

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

Provalo online!

Usando la formula di @ orlp .

— FrownyFrog
fonte

Eccellente, ben fatto! Il pulsante "+100" dice che devo aspettare altre 10 ore prima di poter assegnare la taglia. Dopodiché ne creerò un altro per +200.

— ngn,

Yay ho vinto! grazie @jayprich

— FrownyFrog il

@FrownyFrog Ti piace Dyalog APL rispetto a J?

— Giona,

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)

La formula è il prodotto di binom(R, d)per ogni elemento din D, tempi factorial(len(D)), diviso per il prodotto di factorial(len(S))per ciascuno Snei raggruppamenti di D(ad esempio [4, 4, 3, 2]ha raggruppamenti [[4, 4], [3], [2]]), infine diviso per binom(len(D) * R, sum(D)).

O nella notazione matematica, supponendo che m contenga le molteplicità degli n elementi univoci in D :

\frac{| D |!}{m_{1}! \cdot m_{2}! \dots m_{n}!} {(\binom{| D | \cdot R}{Σ D})}^{- 1} \underset{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
fonte

2

per un breve momento mi hai fatto credere che PPCG ora supporti LaTeX :)

— ngn

All'interno delle due funzioni ho ottenuto 136, ma forse questo può essere giocato di più (usa i=0per dire b()e usa R,Dper 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))

Provalo online!

Ho osservato la stessa cosa di orlp , ma ho scelto un linguaggio piacevole che ha incorporato la combinatoria.

Spiegazione:

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
fonte

Puoi salvarne un altro con questo: "<"=choose(al di fuori della funzione) e potenzialmente usare seq a seconda della risposta di ngn al commento che ho pubblicato stamattina.

— JayCe

6

Gelatina , 22 20 byte

-2 byte usando un nuovo ʋatomo rapido e un nuovo monadicoẈ

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

Un collegamento diadico, prendendo la distribuzione distribuita, D, a sinistra e il numero di ranghi, R, a destra, che restituisce la probabilità di occorrenza.

Provalo online! o vedi la suite di test

Come?

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

5

05AB1E , 21 byte

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

Provalo online!

Spiegazione

 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
fonte

3

Pyth , 32 byte

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

Provalo qui! oppure Verifica tutti i casi di test!

Come funziona?

cc *.! lQ * F.cLvzQ * F.! hMr8Q.c * vzlQs ~ Programma completo. D = elenco, R = numero.

   .! ~ Il fattoriale di ...
     lQ ~ La lunghezza di D.
  * ~ Moltiplicato per ...
       * F ~ Il prodotto degli elementi di ...
         .c ~ Il nCr tra ...
           LQ ~ Ogni elemento di D e ...
            vz ~ R.
 c ~ Diviso per ...
               * F ~ Il prodotto degli elementi di ...
                 .! ~ Il fattoriale di ogni ...
                   hM ~ Heads. Conteggio degli elementi adiacenti in ...
                     r8Q ~ La codifica della lunghezza della corsa di D.
c ~ Diviso per ...
                        .c ~ Il nCr tra ...
                          * ~ Il prodotto di ...
                           vz ~ R, e ...
                             lQ ~ La lunghezza di D.
                               s ~ E la somma di D.
                                 ~ Uscita implicita.

— Mr. Xcoder
fonte

3

APL (Dyalog) , 42 byte

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

Provalo online!

Ancora golf.

— Uriel
fonte

sfida: 30 byte

— ngn

Sfida @ngn accettata

— Uriel

Siamo spiacenti, in realtà sono 30 caratteri . Con il rischio di fornire informazioni: uno dei miei caratteri non è nel set di caratteri Classic, all'inizio non me ne sono reso conto.

— ngn,

@ngn Non puoi semplicemente usare il set di caratteri di Adám per renderlo di 30 byte?

— Probie,

@Probie sì, questo è ciò che intendevo per "SBCS" nella descrizione della taglia

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

Solo una simulazione della forza bruta, per ottenere una maggiore precisione, aumentare il conteggio delle iterazioni e il valore "1 / N" alla fine di conseguenza. Il primo argomento è il conteggio e il secondo argomento è il numero di carte nel mazzo per suite.

— NikoNyrh
fonte

2

J, 57 byte

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

Provalo online!

Questo funziona a O (golf) e soffocerà molti dei casi di test (anche se funziona teoricamente), il che andrebbe bene se fosse più golfista. Ma sono bloccato a ridurlo, soprattutto evitando quelle ripetute "1. Se qualcuno vuole aiutare, ecco la versione analizzata ...

Il lato destro della forcella principale è tutto il possibile affare del mazzo , e il lato sinistro della forcella principale è solo l'arg originale destro, cioè la maschera del seme con cui ci stiamo confrontando.

All'interno, da ogni mazzo "mischiato", prendiamo gli elementi della prima mano , quindi li raggruppiamo usando la chiave /.e ordiniamo il risultato, e controlliamo che corrisponda alla maschera del seme in questione. Aggiungiamo sommiamo il numero totale corrispondente e lo dividiamo per la lunghezza di tutti i mazzi possibili.

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

— Giona
fonte

1

La formula di Orlp ha segnato 42 punti per APL, forse segnerebbe meno di 58 su J?

— Uriel,

1

Ne ho 45 finora in quel modo f=:(([:!#)%[:*/[:!#/.~)@]**/@(]![)%+/@]![*#@] TIO

— jayprich

Disegni a mano in un gioco di carte

APL (Dyalog Unicode) , 30 caratteri

Python 3, 134 byte

R , 90 85 83 byte

Gelatina , 22 20 byte

Come?

05AB1E , 21 byte

Pyth , 32 byte

Come funziona?

APL (Dyalog) , 42 byte

Clojure, 153 byte

J, 57 byte