Dans cette tâche, vous obtenez un nombre impair de boules blanches et le même nombre de boules noires. La tâche consiste à compter toutes les façons de mettre les balles dans des bacs de sorte que dans chaque bac, il y ait un nombre impair de chaque couleur.

Par exemple, disons que nous avons 3 boules blanches. Les différentes manières sont:

(wwwbbb)
(wb)(wb)(wb)

pour les deux possibilités différentes.

Si nous avons 5 boules blanches, les différentes manières sont:

(wwwwwbbbbb)
(wwwbbb)(wb)(wb)
(wwwb)(wbbb)(wb)
(wb)(wb)(wb)(wb)(wb)

Vous pouvez prendre l'entrée, qui est un entier unique, comme vous le souhaitez. La sortie n'est qu'un seul entier.

Votre code doit être assez rapide pour que vous l'ayez vu complet pour 11 boules blanches.

Vous pouvez utiliser n'importe quelle langue ou bibliothèque que vous aimez.

Pari / GP, 81 octets

p=polcoeff;f(n)=p(p(prod(i=1,n,prod(j=1,n,1+(valuation(i/j,2)==0)*x^i*y^j)),n),n)

Pour plus d'efficacité, remplacez 1+par 1+O(x^(n+1))+O(y^(n+1))+(le premier Oterme seul aide déjà beaucoup).

Essayez-le en ligne! (version antérieure de 86 octets avec une paire de parens inutiles et sans l' p=abréviation)

Ancienne version, 90 octets

f(n)=polcoeff(polcoeff(taylor(1/prod(i=0,n,prod(j=0,n,1-x^(2*i+1)*y^(2*j+1))),x,n+1),n),n)

L'informatique a f(11)besoin d'une plus grande taille de pile, le message d'erreur vous indiquera comment l'augmenter. Il est plus efficace (mais moins golfique) de remplacer les deux nqui apparaissent comme deuxièmes arguments prodavec (n-1)/2.

Python 3, 108 octets

C=lambda l,r,o=():((l,r)>=o)*l*r%2+sum(C(l-x,r-y,(x,y))for x in range(1,l,2)for y in range(1,r,2)if(x,y)>=o)

Énumère récursivement tous les ensembles, en veillant à ne pas obtenir de doublons en générant toujours les ensembles dans l'ordre. Raisonnablement rapide lorsqu'il est mémorisé en utilisant C = functoools.lru_cache(None)(C), mais ce n'est pas nécessaire pour n = 11.

Appelez C(num_white, num_black)pour obtenir votre résultat. Premier couple de n:

1: 1
3: 2
5: 4
7: 12
9: 32
11: 85
13: 217
15: 539
17: 1316
19: 3146
21: 7374

Pour générer les résultats:

def odd_parts(l, r, o=()):
    if l % 2 == r % 2 == 1 and (l, r) >= o:
        yield [(l, r)]

    for nl in range(1, l, 2):
        for nr in range(1, r, 2):
            if (nl, nr) < o: continue
            for t in odd_parts(l - nl, r - nr, (nl, nr)):
                yield [(nl, nr)] + t

Par exemple pour (7, 7):

[(7, 7)]
[(1, 1), (1, 1), (5, 5)]
[(1, 1), (1, 1), (1, 1), (1, 1), (3, 3)]
[(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1)]
[(1, 1), (1, 1), (1, 1), (1, 3), (3, 1)]
[(1, 1), (1, 3), (5, 3)]
[(1, 1), (1, 5), (5, 1)]
[(1, 1), (3, 1), (3, 5)]
[(1, 1), (3, 3), (3, 3)]
[(1, 3), (1, 3), (5, 1)]
[(1, 3), (3, 1), (3, 3)]
[(1, 5), (3, 1), (3, 1)]

Python 3 , 180 172 octets

def f(n):
 r=range;N=n+1;a=[N*[0]for _ in r(N)];R=r(1,N,2);a[0][0]=1
 for i in R:
  for j in R:
   for k in r(N-i):
    for l in r(N-j):a[k+i][l+j]+=a[k][l]
 return a[n][n]

Essayez-le en ligne!

Implémentation simple de la fonction de génération. Long mais (un peu) efficace. O (n ⁴ ) temps, O (n ² ) mémoire.

Le tableau résultant acontient tous les résultats de toutes les tailles jusqu'à n, bien que seul a[n][n]soit renvoyé.

Python 2 ,168 181 octets

from itertools import*
r,p=range,product
def f(n):
 a,R=eval(`[[0]*n]*n`),r(1,n,2);a[0][0]=1
 for i,j in p(R,R):
  for k,l in p(r(n-i),r(n-j)):a[k+i][l+j]+=a[k][l]
 return a[-1][-1]

Essayez-le en ligne!

• Basé sur la réponse de user202729 .
• Edit: en a fait une fonction indépendante.
• Enregistré 2 octets grâce à user202729 .