COURS COMPLET – ALGORITHMIQUE ET PYTHON
Ce document est un cours complet et détaillé pour réviser l’examen d’algorithmique et
Python.
Le but est de comprendre la logique des exercices et apprendre à résoudre les problèmes
étape par étape.
Chapitre 1 : Introduction à l’algorithmique
Définition :
Un algorithme est une suite d’instructions ordonnées permettant de résoudre un problème.
Exemple :
Problème : calculer la somme de deux nombres.
Algorithme :
Début
Lire A
Lire B
S←A+B
Ecrire S
Fin
Caractéristiques d’un bon algorithme :
- clair
- précis
- sans ambiguïté
- finit toujours
Chapitre 2 : Variables et types de données
Une variable est un espace mémoire qui stocke une valeur.
Types :
- entier : int
- réel : float
- caractère : char
- chaîne : string
- booléen : True/False
Exemple :
age ← 20
nom ← "Adnan"
Règles :
- pas d’espace
- ne commence pas par un chiffre
Exemple faux :
2age
Exemple correct :
age2
Chapitre 3 : Les opérateurs
Opérateurs arithmétiques :
+ addition
- soustraction
* multiplication
/ division
% modulo
Exemple :
17 % 5 = 2
Le modulo donne le reste.
Comparaison :
== égal
!= différent
> supérieur
< inférieur
Logiques :
and
or
not
Chapitre 4 : Les conditions
Une condition permet de prendre une décision.
Syntaxe :
Si condition alors
instructions
Sinon
instructions
FinSi
Exemple :
Si note >=10 alors
afficher("Admis")
Sinon
afficher("Ajourné")
Python :
if note >= 10:
print("Admis")
else:
print("Ajourné")
Exemple détaillé :
Si note = 14
→ condition vraie
→ affiche Admis
Chapitre 5 : Les boucles
Les boucles permettent de répéter des instructions.
1) TantQue
TantQue(condition)
instructions
FinTantQue
Exemple :
i←1
TantQue(i<=5)
afficher(i)
i←i+1
FinTantQue
Affichage :
12345
------------------------------------------------
2) Pour
Pour i allant de 1 à 5
afficher(i)
FinPour
------------------------------------------------
3) Répéter Jusqu’à
Répéter
instructions
Jusqu’à(condition)
Différence :
la boucle s’exécute au moins une fois.
Chapitre 6 : Exercices classiques sur les boucles
Exercice 1 : somme de 1 à N
Exemple :
N=5
1+2+3+4+5 = 15
Algorithme :
som ← 0
Pour i allant de 1 à N
som ← som + i
FinPour
------------------------------------------------
Exercice 2 : somme des nombres impairs
N = 10
1+3+5+7+9 = 25
Méthode :
tester si le nombre est impair.
Si i % 2 != 0
------------------------------------------------
Exercice 3 : afficher les diviseurs
Pour i allant de 1 à N
Si N % i ==0
afficher(i)
------------------------------------------------
Exercice 4 : nombre de chiffres
84397
84397/10 = 8439
8439/10 = 843
843/10 = 84
84/10 = 8
Donc 5 chiffres.
------------------------------------------------
Exercice 5 : inverser un nombre
1234 → 4321
Principe :
%10 pour récupérer dernier chiffre.
Chapitre 7 : PGCD
PGCD = Plus Grand Diviseur Commun
Exemple :
15 et 10
Diviseurs de 15 :
1 3 5 15
Diviseurs de 10 :
1 2 5 10
Plus grand commun = 5
Algorithme :
i ←1
TantQue(i<=N et i<=M)
si N%i==0 et M%i==0
pgcd ← i
finsi
i ← i+1
FinTantQue
Chapitre 8 : Nombre parfait
Définition :
Un nombre parfait est égal à la somme de ses diviseurs propres.
Exemple :
6
Diviseurs :
123
1+2+3 = 6
Donc 6 est parfait.
Chapitre 9 : Fonctions et procédures
Fonction :
retourne une valeur.
Syntaxe :
Fonction Nom()
retourner valeur
FinFonction
Exemple :
Fonction carre(x)
retourner x*x
Procédure :
ne retourne rien.
Différence importante :
fonction → return
procédure → pas de return
Chapitre 10 : Variables locales et globales
Variable locale :
visible seulement dans la fonction.
Variable globale :
visible partout.
Attention :
les variables globales peuvent provoquer des erreurs.
Chapitre 11 : Python – bases
input()
input retourne une chaîne.
Donc :
age = int(input())
------------------------------------------------
print()
print("Bonjour")
------------------------------------------------
type()
type(age)
------------------------------------------------
range()
range(5)
→01234
Chapitre 12 : Boucles en Python
While :
i=0
while i<5:
print(i)
i+=1
------------------------------------------------
For :
for i in range(5):
print(i)
Chapitre 13 : Fonctions Python
def somme(a,b):
return a+b
Appel :
x = somme(3,5)
Résultat :
8
------------------------------------------------
Fonction puissance :
def puissance(x,n):
r=1
for i in range(n):
r *= x
return r
Chapitre 14 : Récursivité
Définition :
fonction qui s’appelle elle-même.
Exemple factoriel :
def fact(n):
if n==0:
return 1
return n * fact(n-1)
Exemple :
fact(4)
= 4 * fact(3)
= 4 * 3 * fact(2)
= 24
Chapitre 15 : Listes
Définition :
structure qui stocke plusieurs valeurs.
Exemple :
L = [1,2,3,4]
Accès :
L[0] = 1
Fonctions importantes :
append()
remove()
len()
Exemple :
[Link](5)
Résultat :
[1,2,3,4,5]
Chapitre 16 : Tuples
Tuple = structure non modifiable.
Exemple :
T = (1,2,3)
Différence avec liste :
tuple → impossible modifier
Chapitre 17 : Dictionnaires
Définition :
structure clé/valeur.
Exemple :
etudiant = {
"nom":"Adnan",
"age":22
}
Accès :
etudiant["nom"]
Résultat :
Adnan
Ajouter :
etudiant["ville"] = "Temara"
Chapitre 18 : Fichiers
Ouvrir fichier :
f = open("[Link]","r")
Lire :
[Link]()
Fermer :
[Link]()
Modes :
r lecture
w écriture
a ajout
Chapitre 19 : Modules
Un module contient des fonctions prêtes.
Exemple :
from math import *
sqrt(16)
Résultat :
4
Chapitre 20 : Conseils examen
1. Lire l’énoncé plusieurs fois
2. Déterminer les variables
3. Chercher :
- boucle ?
- condition ?
- fonction ?
4. Faire un exemple manuel
5. Tester le programme
Pièges :
- oublier incrémentation
- boucle infinie
- confusion = et ==