Maths-cours

COURS & EXERCICES DE MATHÉMATIQUES

Close

Dénombrement en Python

  1. Compléter le programme Python ci-dessous de telle sorte que la fonction factorielle retourne n! n! nn désigne un entier naturel passé en argument.

    def factorielle(n) :
       f = ...
       for i in range(...) :
          f = ...
       return ...

  2. Sur le modèle de la question précédente, écrire une fonction arrangement qui prend en arguments deux entiers naturels nn et pp et qui retourne le nombre de pp-uplets formés d'éléments distincts d'un ensemble à nn éléments.

  3. Écrire une fonction Python qui prend en arguments deux entiers naturels nn et pp et qui retourne le nombre de combinaisons (np) \begin{pmatrix} n \\ p \end{pmatrix} .
    On pourra faire appel aux fonctions définies dans les questions précédentes.

Corrigé

  1. On utilise la définition de n! n! :

    n!=n×(n1)×...×1 n! = n\times \left(n - 1\right)\times . . .\times 1

    (voir Factorielle et permutations )

    Le programme Python peut être compléter de la façon suivante :

    def factorielle(n) :
       f = 1
       for i in range(1, n+1) :
          f = f * i
       return f

    Remarque : On rappelle que l'instruction for i in range(1, n+1) effectue une boucle pour i variant de 1 à n.

  2. Le nombre de p-uplets formés de p éléments distincts d'un ensemble à nn éléments est :

    Anp=n×(n1)××(np+1) A_n^p = n \times (n - 1) \times \cdots \times (n - p+1) =n!(np)!= \dfrac{ n! }{ (n - p) !}

    (voir p-uplets formés de p éléments distincts - Arrangements)

    La fonction arrangement sera donc assez similaire à la fonction factorielle :

    def arrangement (n, p) :
       a = 1
       for i in range(n-p+1, n+1) :
          a = a * i
       return a

  3. En utilisant les fonctions définies dans les questions précédentes et le fait que :

    (np)=n!p!(np)!=Anpp!\begin{pmatrix} n \\ p \end{pmatrix}=\frac{n!}{p!\left(n - p\right)!} = \dfrac{ A_n^p }{ p! } (voir Combinaisons)

    on obtient la fonction Python :

    def combinaison (n, p) :
        return arrangement(n,p)//factorielle(p)

Remarque : L'opérateur // effectue la division entière alors que l'opérateur / (acceptable ici aussi) effectue la division décimale.