Accueil › Cours › Arithmétique

Les leçons de ce chapitre

1. La décomposition en facteurs premiers
2. Factorielle, arrangements et combinaisons
3. Changer de base
4. Nombres parfaits et nombres d'Armstrong

Leçon 16.1 : La décomposition en facteurs premiers

9 min

Tout entier n ≥ 2 s'écrit comme un produit de nombres premiers : 60 = 2 × 2 × 3 × 5. Pour trouver ces facteurs, on essaie de diviser n par d = 2, 3, 4… : quand d divise n, on l'affiche et on remplace n par n div d ; sinon on passe au d suivant. On s'arrête quand n vaut 1.

Astuce : On peut essayer d = 4 sans risque : quand on arrive à 4, tous les 2 sont déjà partis, donc 4 ne divise plus n. Seuls des nombres premiers sont affichés.

Attention : On n'augmente d que si la division échoue : un même facteur peut revenir plusieurs fois (2 × 2 dans 60).

En Python

Chaque facteur premier est affiché sur une ligne.

n = int(input())
d = 2
while n > 1:
    if n % d == 0:
        print(d)
        n = n // d
    else:
        d = d + 1

En algorithme

Une boucle Tant que qui s'arrête quand n vaut 1.

Algorithme Facteurs
Début
  Lire(n)
  d ← 2
  Tant que n > 1 Faire
    Si n mod d = 0 Alors
      Ecrire(d)
      n ← n div d
    Sinon
      d ← d + 1
    FinSi
  FinTantQue
Fin

TDO
Objet | Type/Nature
n, d | Entier

Leçon 16.2 : Factorielle, arrangements et combinaisons

10 min

La factorielle de n, notée n!, est le produit 1 × 2 × … × n (et 0! = 1). Elle compte les façons de ranger n objets. Avec elle on calcule :

• les arrangements A(n, p) = n! / (n − p)! : choisir p objets parmi n dans un ordre (podium) ;
• les combinaisons C(n, p) = n! / (p! × (n − p)!) : choisir p objets parmi n sans ordre (une équipe).

C'est l'occasion d'écrire une fonction fact(n) et de l'appeler plusieurs fois : c'est la décomposition modulaire.

Astuce : Les résultats sont des entiers : on divise avec div (en Python //) pour garder un entier.

En Python

La fonction fact est appelée cinq fois pour calculer A(n, p) et C(n, p).

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

n = int(input())
p = int(input())
print("A =", fact(n) // fact(n - p))
print("C =", fact(n) // (fact(p) * fact(n - p)))

En algorithme

La fonction a son propre TDO pour ses variables locales f et i.

DEF FN fact (n : Entier) : Entier
TDO
Objet | Type/Nature
f, i | Entier
Début
  f ← 1
  Pour i de 2 à n Faire
    f ← f * i
  FinPour
  Retourner f
Fin

Algorithme Denombrement
Début
  Lire(n)
  Lire(p)
  Ecrire("A = ", fact(n) div fact(n - p))
  Ecrire("C = ", fact(n) div (fact(p) * fact(n - p)))
Fin

TDO
Objet | Type/Nature
n, p | Entier

Leçon 16.3 : Changer de base

11 min

Nous écrivons les nombres en base 10 (chiffres 0 à 9). L'ordinateur utilise la base 2 (binaire, chiffres 0 et 1) ; on rencontre aussi la base 16 (hexadécimal, chiffres 0 à 9 puis A à F).

• Base 10 → base b : divisions successives par b. Les restes, lus du dernier au premier, sont les chiffres. Ex. 13 = 1101 en binaire.
• Base b → base 10 : on lit les chiffres de gauche à droite avec n ← n × b + chiffre. Ex. 1101 → 1, 3, 6, 13.

Astuce : Pour ajouter chaque reste devant les précédents, on construit une chaîne : ch ← convch(r) + ch.

Attention : Pour n = 0, la boucle Tant que n > 0 ne tourne pas et la chaîne reste vide : traite ce cas à part si l'énoncé le demande.

En Python

Conversion de la base 10 vers la base 2.

n = int(input())
ch = ""
while n > 0:
    ch = str(n % 2) + ch
    n = n // 2
print(ch)

En algorithme

convch transforme le reste (un entier) en chaîne.

Algorithme Binaire
Début
  Lire(n)
  ch ← ""
  Tant que n > 0 Faire
    ch ← convch(n mod 2) + ch
    n ← n div 2
  FinTantQue
  Ecrire(ch)
Fin

TDO
Objet | Type/Nature
n | Entier
ch | Chaîne

Leçon 16.4 : Nombres parfaits et nombres d'Armstrong

10 min

Les sujets d'examen aiment les nombres remarquables. Chacun se teste avec ce que tu sais déjà : boucles, mod et div.

• Nombre parfait : égal à la somme de ses diviseurs autres que lui-même. 28 = 1 + 2 + 4 + 7 + 14.
• Nombre d'Armstrong : égal à la somme de ses chiffres, chacun élevé à la puissance du nombre de chiffres. 153 = 1³ + 5³ + 3³.

Astuce : Pour Armstrong, on fait deux passages sur les chiffres : un pour les compter, un pour faire la somme. On travaille sur une copie de n pour garder n intact.

En Python

On teste si un nombre est d'Armstrong.

n = int(input())
k = 0
c = n
while c > 0:
    k = k + 1
    c = c // 10
s = 0
c = n
while c > 0:
    s = s + (c % 10) ** k
    c = c // 10
if s == n:
    print(n, "est un nombre d'Armstrong")
else:
    print(n, "n'est pas un nombre d'Armstrong")

En algorithme

La puissance s'écrit ^ en algorithme.

Algorithme Armstrong
Début
  Lire(n)
  k ← 0
  c ← n
  Tant que c > 0 Faire
    k ← k + 1
    c ← c div 10
  FinTantQue
  s ← 0
  c ← n
  Tant que c > 0 Faire
    s ← s + (c mod 10) ^ k
    c ← c div 10
  FinTantQue
  Si s = n Alors
    Ecrire(n, " est un nombre d'Armstrong")
  Sinon
    Ecrire(n, " n'est pas un nombre d'Armstrong")
  FinSi
Fin

TDO
Objet | Type/Nature
n, k, c, s | Entier

S'entraîner gratuitement

Chaque leçon a 3 exercices gratuits avec indices pour appliquer ce chapitre avec Hannibot.

← Chapitre précédent : La recherche dans un tableau · Chapitre suivant : Les matrices →

Tous les chapitres · Voir les devoirs corrigés de 2ème TI

Cours écrit pour Mission Carthage d'après le programme officiel. Ton professeur reste la référence.