Tempo per un'altra sfida semplice a cui tutti possono partecipare!

Il teorema multinomiale afferma:

L'espressione tra parentesi è il coefficiente multinomiale, definito come:

Consentire ai termini k _i di spaziare su tutte le partizioni intere di n fornisce l' n -esimo livello del m -simplex di Pascal . Il tuo compito è calcolare questo coefficiente.

Compito

Scrivi un programma o una funzione che accetta numeri m , n , k ₁ , k ₂ , ..., k _m-1 e genera o restituisce il coefficiente multinomiale corrispondente. Il tuo programma può facoltativamente prendere m come argomento aggiuntivo, se necessario. Si noti che k _m non è presente nell'input.

• Questi numeri possono essere inseriti in qualsiasi formato uno preferisca, ad esempio raggruppati in elenchi o codificati in unario, o qualsiasi altra cosa, purché il calcolo effettivo del coefficiente multinomiale venga eseguito dal codice e non dal processo di codifica.

• Il formato di output è altrettanto flessibile.

• Tutto il codice dovrebbe essere eseguito in meno di un minuto per n e m fino a 1000.

• Non preoccuparti dell'overflow di numeri interi.

• Non sono ammessi incorporati progettati per calcolare il coefficiente multinomiale.

• Si applicano scappatoie standard.

punteggio

Questo è il codice golf: vince la soluzione più breve in byte.

Casi test

Input: 3, [2, 0]
Output: 3

Input: 3, [1, 1]
Output: 6

Input: 11, [1, 4, 4]
Output: 34650

Input: 4, [1,2]
Output: 12

Input: 15, [5,4,3,2]
Output: 37837800

Input: 95, [65,4,4]
Output: 1934550571913396675776550070308250

Input: 32, [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
Output: 4015057936610313875842560000000

Input: 15, [3,3,3,3]
Output: 168168000

Input: 1000, [10,10,10,10,10,10,10,10,10,10,100,100,100,100,100,100,100,100]
Output: 1892260836114766064839886173072628322819837473493540916521650371620708316292211493005889278395285403318471457333959691477413845818795311980925098433545057962732816261282589926581281484274178579110373517415585990780259179555579119249444675675971136703240347768185200859583936041679096016595989605569764359198616300820217344233610087468418992008471158382363562679752612394898708988062100932765563185864346460326847538659268068471585720069159997090290904151003744735224635733011050421493330583941651019570222984959183118891461330718594645532241449810403071583062752945668937388999711726969103987467123014208575736645381474142475995771446030088717454857668814925642941036383273459178373839445456712918381796599882439216894107889251444932486362309407245949950539480089149687317762667940531452670088934094510294534762190299611806466111882595667632800995865129329156425174586491525505695534290243513946995156554997365435062121633281021210807821617604582625046557789259061566742237246102255343862644466345335421894369143319723958653232683916869615649006682399919540931573841920000000000000

Input: 33, [17]
Output: 1166803110

Input: 55, [28]
Output: 3824345300380220

Gelatina , 7 6 byte

;_/!:/

Guarda, no Unicode! Questo programma accetta un unico elenco come input, con n al suo primo indice.

Provalo online! oppure verifica tutti i casi di test contemporaneamente .

Come funziona

;_/!:/ Input: A (list)

 _/    Reduce A by subtraction. This subtracts all other elements from the first.
;      Concatenate A with the result to the right.
   !   Apply factorial to all numbers in the resulting list.
    :/ Reduce the result by division. This divides the first element by the others.

CJam, 11 byte

l~_:-+:m!:/

Inserisci come un unico elenco con il nprimo:

[95 65 4 4]

Questo gestisce gli input fino a ne m1000 praticamente all'istante.

Provalo qui.

Spiegazione

l~  e# Read a line of input and evaluate it.
_   e# Duplicate.
:-  e# Fold subtraction over the list. A fold is essentially a foreach loop that starts
    e# from the second element. Hence, this subtracts all the k_i from n, giving k_m.
+   e# Append k_m to the list.
:m! e# Compute the factorial of each element in the list.
:/  e# Fold division over the list. Again, this divides n! by each of the k_i!.

MATL , 21 15 byte

Mettiamo a frutto la funzione log-gamma . Questo evita lo straripamento interno lavorando con logaritmi di fattoriali, non con fattoriali stessi.

1+ZgiO$Gs-h1+Zgs-ZeYo

Funziona con la versione corrente (9.2.2) del linguaggio / compilatore, che è precedente a questa sfida.

Gli input sono: prima un numero, quindi un vettore numerico. Il risultato è prodotto come a double, che limita il massimo output da qualche parte intorno 2^52.

Esempio

>> matl 1+ZgiO$Gs-h1+Zgs-ZeYo
> 15
> [5 4 3 2]
37837800

Spiegazione

1+       % implicit input (number). Add 1
Zg       % log-gamma function
i        % input (numeric vector).
0$G      % push both inputs
s-       % sum the second input (vector) and subtract from first
h1+      % append to vector. Add 1
Zg       % log-gamma function, element-wise on extended vector
s        % sum of results
-        % subtract from previous result of log-gamma
Ze       % exponential
Yo       % round. Implicit display

PowerShell, 91 74 byte

_{Corteggiare! La mia centesima risposta su PPCG!}

param($n,$k)(1..$n-join'*'|iex)/(($k|%{$n-=$_;1..$_})+(1..$n)-join'*'|iex)

Accidenti. Non vinceremo il codice più corto, questo è certo. Usa un paio di trucchi accurati con intervalli, però. _{E questo è probabilmente completo senza senso per chiunque non abbia familiarità con PowerShell.}

Spiegazione

Per prima cosa prendiamo input param($n,$k)e ci aspettiamo $kdi essere un array, ad es .\compute-the-multinomial-coefficient.ps1 11 @(1,4,4).

Inizieremo con il numeratore (tutto a sinistra di /). Questo è semplicemente un intervallo 1..$nche è stato -joineditato insieme *e quindi valutato iexper calcolare il fattoriale (ad es.1*2*3*...*$n ).

Successivamente, abbiamo un ciclo su $k|%{...}e ogni iterazione si sottrae il valore di corrente $_da $n(che non ci preoccupiamo più) di formulare $k_min seguito. Inoltre, generiamo l'intervallo di 1..$k_iogni iterazione, che viene lasciato sulla pipeline. Questi oggetti della pipeline vengono concatenati con la matrice con la seconda espressione, intervallo 1..$n(che è $k_ma questo punto). Tutto ciò viene infine -joinredatto insieme *e valutato iex, in modo simile al numeratore (funziona perché x! * y! = 1*2*3*...*x * 1*2*3*...*y, quindi non ci interessa l'ordine individuale).

Alla fine, /succede, il numeratore è diviso per il denominatore e l'output.

Gestisce correttamente l'output per numeri più grandi, poiché non stiamo esplicitamente lanciando alcuna variabile come particolari tipi di dati, quindi PowerShell eseguirà il cast silenzioso come diversi tipi di dati al volo, se necessario. Per i numeri più grandi, output tramite notazione scientifica per preservare al meglio cifre significative man mano che i tipi di dati vengono rilanciati. Ad esempio, .\compute-the-multinomial-coefficient.ps1 55 @(28)verrà emesso 3.82434530038022E+15. Presumo che questo sia OK dato che "il formato di output è altrettanto flessibile" è specificato nei commenti della sfida e della quintopia "Se il risultato finale può rientrare nei tipi interi supportati nativamente, allora il risultato deve essere accurato. non ci sono restrizioni su ciò che può essere prodotto. "

In alternativa

A seconda delle decisioni di formattazione dell'output, quanto segue a 92 byte

param($n,$k)((1..$n-join'*'|iex)/(($k|%{$n-=$_;1..$_})+(1..$n)-join'*'|iex)).ToString('G17')

Che è lo stesso del precedente, utilizza solo l'uscita esplicita la formattazione con .ToString('G17')per ottenere il numero desiderato di cifre. Per 55 @(28)questo uscirà3824345300380220.5

Modifica1: salvati 17 byte eliminandoli $de semplicemente calcolandoli direttamente, eliminando il calcolo eseguendo $k_mla $k
stringa lungo mentre eseguiamo il ciclo Modifica2: aggiunta versione alternativa con formattazione esplicita

APL (Dyalog Extended) , 9 byte

×/2!/+\⍛,

Provalo online!

Utilizzando l'idea della mia risposta APL su un'altra sfida che coinvolge i multinomi .

Una funzione tacita il cui argomento di sinistra è l'elenco di k, e l'argomento di destra è n. I casi di test controllano se è d'accordo con la soluzione di Adam con argomenti a sinistra ea destra capovolti.

Come funziona

×/2!/+\⍛,
     +\    ⍝ Cumulative sum of k's (up to m-1'th element)
       ⍛,  ⍝ Append n (sum of k_1 to k_m)
  2!/      ⍝ Binomial of consecutive pairs
×/         ⍝ Product

Mathematica, 26 byte

#!/Times@@({#-+##2,##2}!)&

Esempio:

In[1]:= #!/Times@@({#-+##2,##2}!)&[95,65,4,4]

Out[1]= 1934550571913396675776550070308250

Python 3, 93 91

Grazie a Dennis e FryAmTheEggman .

f=lambda x:0**x or x*f(x-1)
def g(n,k):
    r=f(n)
    for i in k:r//=f(i)
    return r//f(n-sum(k))

ncome intero, kcome ripetibile.

Ungolfed:

import functools #cache

@functools.lru_cache(maxsize=None) #cache results to speed up calculations
def factorial(x):
    if x <= 1: return 1
    else: return x * factorial(x-1)

def multinomial(n, k):
    ret = factorial(n)
    for i in k: ret //= factorial(i)
    km = n - sum(k)
    return ret//factorial(km)

APL (Dyalog Unicode) , 16 byte ^SBCS

Interamente basato sull'abilità matematica del mio collega Marshall .

Funzione infix anonima. Prende k come argomento destro e n come argomento sinistro.

{×/⍵!⍺-+\¯1↓0,⍵}

Provalo online!

{... } lambda anonimo; ⍺è argomento di sinistra ( n ) ed ⍵è argomento di destra ( k )

 0,⍵ anteporre uno zero a k

 ¯1↓ elimina l'ultimo elemento da quello

 +\ somma cumulativa di quello

 ⍺- sottrarre quello da n

 ⍵! ( ^k ) quello

 ×/ prodotto di quello

PARI / GP, 43 byte

Abbastanza diretto; a parte la formattazione, la versione non modificata potrebbe essere identica.

m(n,v)=n!/prod(i=1,#v,v[i]!)/(n-vecsum(v))!

Matlab 48 byte

È necessario impostare formata longin anticipo per ottenere la maggiore precisione. Quindi, è abbastanza semplice:

@(n,k)factorial(n)/prod(factorial([k,n-sum(k)]))

ans(95, [65,4,4])
ans =

 1.934550571913395e+33

Pyth, 10 byte

/F.!MaQ-FQ

Provalo online: dimostrazione

Spiegazione:

/F.!MaQ-FQ   implicit: Q = input list
       -FQ   reduce Q by subtraction
     aQ      append the result to Q
  .!M        compute the factorial for each number
/F           reduce by division

J, 16 byte

[(%*/)&:!],(-+/)

uso

Per valori più grandi, un suffisso di xviene utilizzato per indicare numeri interi di precisione estesi.

   f =: [(%*/)&:!],(-+/)
   11 f 1 4 4
34650
   15x f 5 4 3 2
37837800

Spiegazione

[(%*/)&:!],(-+/)  Input: n on LHS, A on RHS
             +/   Reduce A using addition
            -     Subtract that sum from n, this is the missing term
         ]        Get A
          ,       Append the missing term to A to make A'
[                 Get n
      &:!         Take the factorial of n and each value in A'
   */             Reduce using multiplication the factorials of A'
  %               Divide n! by that product and return

05AB1E , 8 byte

Ƹ«!R.«÷

Provalo online! Spiegazione:

Æ           Subtract all the elements from the first
 ¸«         Append to the original list
   !        Take the factorial of all the elements
    R.«÷    Reduce by integer division

Non riesco a trovare modi migliori per eseguire il passaggio 2 o il passaggio 4.

APL (Dyalog Unicode) , 17 byte

⊢∘!÷(×/∘!⊣,⊢-1⊥⊣)

Provalo online!

Aggiunta della funzione tacit (Grazie a @ Adám per i 2 byte che salva.)

APL (Dyalog Unicode) , 19 byte

{(!⍺)÷×/!(⍺-+/⍵),⍵}

Provalo online!

Infix Dfn.

Entrambe le funzioni sopra calcolano la formula data.

Haskell , 59 58 byte

f n=product[1..n]
n#k=foldl((.f).div)(f n)k`div`f(n-sum k)

Provalo online!

Grazie a BMO per aver salvato 1 byte!

Clojure, 70 byte

#(let[a apply](a /(map(fn[x](a *(map inc(range x))))(conj %(a - %)))))

Crea una funzione anonima prendendo tutti gli argomenti come un unico elenco, con n prima.

30 caratteri vengono "sprecati" solo per definire la dannata funzione fattoriale. Oh bene.

Perl 6 ,  52  50 byte

->\n,\k{[*](1..n)div[*] ([*] 1..$_ for |k,[-] n,|k)}

Provalo

->\n,\k{[*](1..n)/[*] ([*] 1..$_ for |k,[-] n,|k)}

Provalo (il risultato è una Razionale con denominatore di 1)

Allargato:

->     # pointy block lambda
  \n,
  \k
{
    [*]( 1 .. n )   # factorial of ｢n｣

  /                 # divide (produces Rational)

    [*]             # reduce the following using &infix:«*»

      (
          [*] 1..$_ # the factorial of

        for         # each of the following

          |k,       # the values of ｢k｣ (slipped into list)
          [-] n,|k  # ｢n｣ minus the values in ｢k｣
      )
}