ENCG-KENITRA — Université Ibn Tofail Année Universitaire 2025-2026
SÉRIE N°1
Algorithmique et Programmation en Python (version 3)
Objectifs : Variables, entrées/sorties, affectation, opérateurs/priorité, instructions conditionnelles/répétitives. Tous les exercices sont
traduits en langage Python (version 3).
ALGORITHME CODE PYTHON
Exercice 1 — Déclarations, Affectations et Opérations
Algorithme 1 — DeclarationAffectationOperations
Algorithme DeclarationAffectationOperations
Variable A, B : Entier
x, y : Réel
msg : Texte
T, R : Logique
Début
Ecrire('mon premier algorithme')
A ← 14
B ← 4
x ← A / B % x = 3.5
y ← A + x % y = 17.5
T ← (A > B) % T = Vrai
T ← (x > y) OU (A < B) % T = Faux
R ← (x > y) ET (A < B) % R = Faux
y ← y - x % y = 14.0
msg ← 'Bonjour '
Fin
CODE PYTHON
# Algorithme 1 — traduction Python
A = 14
B = 4
x = A / B # x = 3.5
y = A + x # y = 17.5
T = (A > B) # T = True
T = (x > y) or (A < B) # T = False
R = (x > y) and (A < B) # R = False
y = y - x # y = 14.0
msg = 'Bonjour '
print('A =', A) # 14
print('B =', B) # 4
print('x =', x) # 3.5
print('y =', y) # 14.0
print('T =', T) # False
print('R =', R) # False
print('msg =', msg)
Algorithme 2 — Entrée / Sortie
Algorithme Entrée_Sortie
Variable X, Y : Entier
Début
Ecrire('Bonjour mes amis')
Ecrire('Taper la valeur de X')
Lire(X)
Y ← X ^ 3
Ecrire('X =', X, ' Y =', Y)
Fin
CODE PYTHON
print('Bonjour mes amis')
X = int(input('Taper la valeur de X : '))
Y = X ** 3
print('X =', X, ' Y =', Y)
Code Python du cours (avec résultats)
print('MON PREMIER CODE PYTHON')
A = 22
B = 7
print('A =', A) # A = 22
print('B =', B) # B = 7
print('A/B =', A/B) # 3.142857...
print('A//B =', A//B) # 3 (division entière)
print('A%B =', A%B) # 1 (modulo)
print('B**3 =', B**3) # 343 (puissance)
print('C =', 27/3**3*5)# 5.0 (priorité : ** avant / et *)
prenom = input('Taper votre prénom : ')
nom = input('Taper votre nom : ')
print('Nom complet :', nom + ' ' + prenom)
Exercice 2 — Permutation de deux variables
Algorithme classique (variable temporaire)
Algorithme Permutation
Variable x, y, temp : Réel
Début
Ecrire('Taper x : ') Lire(x)
Ecrire('Taper y : ') Lire(y)
temp ← x
x ← y
y ← temp
Ecrire('x =', x, ' y =', y)
Fin
CODE PYTHON — Méthode 1 : variable temporaire
x = float(input('Taper x : '))
y = float(input('Taper y : '))
print('Avant :', x, y)
temp = x
x = y
y = temp
print('Après :', x, y)
Méthode 2 — Affectation simultanée (spécifique Python)
En Python, le membre droit est entièrement évalué avant l'affectation, ce qui permet d'écrire la permutation en une seule ligne.
Algorithme Permutation_Simultanee
Variable x, y : Réel
Début
Ecrire('Taper x : ') Lire(x)
Ecrire('Taper y : ') Lire(y)
x, y ← y, x % affectation simultanée
Ecrire('x =', x, ' y =', y)
Fin
CODE PYTHON — Méthode 2 : affectation simultanée
x = float(input('Taper x : '))
y = float(input('Taper y : '))
print('Avant :', x, y)
x, y = y, x # Python évalue (y, x) puis affecte simultanément
print('Après :', x, y)
Note : en algorithmique classique, la notation x,y ← y,x n'existe pas. On utilise toujours la variable temporaire. L'affectation simultanée est une
spécificité Python.
Exercice 3 — Calcul du Prix TTC
Formule : Prix_TTC = nombre_articles × Prix_HT × (1 + TVA/100)
Algorithme Prix_Article
Variable prix_HT, TVA, Prix_TTC : Réel
nombre_articles : Entier
Début
Ecrire('Prix HT de l article : ') Lire(prix_HT)
Ecrire('Nombre d articles : ') Lire(nombre_articles)
Ecrire('Taux de TVA (%) : ') Lire(TVA)
Prix_TTC ← nombre_articles * prix_HT * (1 + TVA / 100)
Ecrire('Prix TTC =', Prix_TTC, 'DH')
Fin
CODE PYTHON
prix_HT = float(input('Entrer le prix HT : '))
nombre_articles = int(input( 'Entrer le nombre d articles : '))
TVA = float(input('Entrer le taux de TVA (%) : '))
Prix_TTC = nombre_articles * prix_HT * (1 + TVA / 100)
print('Prix TTC =', Prix_TTC, 'DH')
Exercice 4 — Minimum et Maximum de deux nombres
Algorithme — Minimum
Algorithme Minimum
Variable a, b : Réel
Début
Ecrire('Entrer a : ') Lire(a)
Ecrire('Entrer b : ') Lire(b)
Si a < b Alors
Ecrire('Le minimum est :', a)
Sinon
Ecrire('Le minimum est :', b)
FinSi
Fin
Algorithme — Maximum
Algorithme Maximum
Variable a, b : Réel
Début
Ecrire('Entrer a : ') Lire(a)
Ecrire('Entrer b : ') Lire(b)
Si a > b Alors
Ecrire('Le maximum est :', a)
Sinon
Ecrire('Le maximum est :', b)
FinSi
Fin
CODE PYTHON
a = float(input('Entrer le premier nombre a : '))
b = float(input('Entrer le deuxieme nombre b : '))
# Minimum
if a < b:
print('Le minimum est :', a)
else:
print('Le minimum est :', b)
# Maximum
if a > b:
print('Le maximum est :', a)
else:
print('Le maximum est :', b)
Exercice 6 — Analyse de la marge bénéficiaire
Formule : Marge (%) = 100 × (Bénéfice / Chiffre d'affaires)
Algorithme Marge_Beneficiaire
Variable benefice, CA, marge : Réel
Début
Lire(benefice)
Lire(CA)
marge ← 100 * (benefice / CA)
Si marge >= 50 Alors
Ecrire('Excellente rentabilite')
SinonSi marge >= 30 Alors
Ecrire('Bonne rentabilite')
SinonSi marge >= 10 Alors
Ecrire('Rentabilite moyenne')
Sinon
Ecrire('Rentabilite faible')
FinSi
Fin
CODE PYTHON
benefice = float(input('Entrer le benefice : '))
CA = float(input('Entrer le chiffre d affaires : '))
marge = 100 * (benefice / CA)
print(f'Marge = {marge:.2f} %')
if marge >= 50:
print('Excellente rentabilite')
elif marge >= 30:
print('Bonne rentabilite')
elif marge >= 10:
print('Rentabilite moyenne')
else:
print('Rentabilite faible')
Exercice 7 — Boucle Pour — Tables de multiplication
Table de 7
Algorithme Table_De_7
Variable i : Entier
Début
Pour i allant de 1 à 9 Faire
Ecrire('7 x', i, '=', 7 * i)
FinPour
Fin
CODE PYTHON
for i in range(1, 10): # range(1,10) = 1,2,...,9
print(f'7 x {i} = {7*i:02d}')
Toutes les tables de 1 à 9 (boucles imbriquées)
Algorithme Toutes_Tables
Variable table, i : Entier
Début
Pour table allant de 1 à 9 Faire
Ecrire('=== Table de', table, '===')
Pour i allant de 1 à 9 Faire
Ecrire(table, 'x', i, '=', table * i)
FinPour
FinPour
Fin
CODE PYTHON
for table in range(1, 10):
print(f'=== Table de {table} ===')
for i in range(1, 10): # boucle imbriquee
print(f'{table} x {i} = {table*i:02d}')
Exercice 8 — Factorielle
N! = 1 × 2 × 3 × … × N (avec 0! = 1)
Algorithme Factoriel
Variable N, i, fact : Entier
Début
Ecrire('Entrer N >= 0 : ') Lire(N)
fact ← 1
Pour i allant de 1 à N Faire
fact ← fact * i
FinPour
Ecrire(N, '! =', fact)
Fin
CODE PYTHON
N = int(input('Entrer un entier N >= 0 : '))
fact = 1
for i in range(1, N + 1): # de 1 jusqu a N inclus
fact = fact * i
print(f'{N}! = {fact}')
Exemple : N=5 → 1×2×3×4×5 = 120. Si N=0, la boucle ne s'exécute pas et fact reste 1 (correct car 0!=1).
Exercice 9 — Suite de Fibonacci
X0 = X1 = 1 et Xn+2 = Xn+1 + Xn
Algorithme Fibonacci
Variable X0, X1, Xn, i : Entier
Début
X0 ← 1 X1 ← 1
Ecrire(X0) Ecrire(X1)
Pour i allant de 2 à 29 Faire
Xn ← X0 + X1
Ecrire(Xn)
X0 ← X1
X1 ← Xn
FinPour
Fin
CODE PYTHON
X0 = 1
X1 = 1
print(f'F(1) = {X0}')
print(f'F(2) = {X1}')
for i in range(2, 30): # calcule F(3) jusqu a F(30)
Xn = X0 + X1
print(f'F({i+1:2d}) = {Xn}')
X0 = X1 # glissement : X0 prend la valeur de X1
X1 = Xn # X1 prend le nouveau terme
Exercice 10 — Exponentielle — Série de Taylor
Série : e^x = 1 + x/1! + x2/2! + x3/3! + …
Astuce : chaque terme k se calcule à partir du terme k-1 en multipliant par (x/k), ce qui évite de recalculer la factorielle à chaque
étape.
Algorithme Exponentielle
Variable x, terme, somme : Réel
i, nb_termes : Entier
Début
Ecrire('Entrer x : ') Lire(x)
somme ← 1 % terme k=0
terme ← 1
nb_termes ← 50 % 50 termes => tres bonne precision
Pour i allant de 1 a nb_termes Faire
terme ← terme * (x / i)
somme ← somme + terme
FinPour
Ecrire('exp(x) =', somme)
Fin
CODE PYTHON
import math
x = float(input('Entrer la valeur de x : '))
nb_termes = 50 # 50 termes : precision suffisante
somme = 1.0 # terme k=0 vaut toujours 1
terme = 1.0
for i in range(1, nb_termes + 1):
terme = terme * (x / i) # terme_k = terme_{k-1} * x/k
somme = somme + terme
print(f'exp({x}) par serie de Taylor : {somme}')
print(f'Valeur exacte ([Link]) : {[Link](x)}')
print(f'Erreur absolue : {abs(somme - [Link](x)):.2e}')
Exemple : x=1 → e^1 ≈ 2.718281828... L'erreur est inférieure à 10^-15 avec 50 termes.
ENCG-KENITRA | Module Algorithmes et Python S2 | 2025-2026