1|Page PYTHON
SERIED’EXERCICESENPYTHON
Exercice1
Ecrire un programme en langage Python qui demande à l’utilisateur de saisir son nom et de lui afficher son nom
avec un message de bienvenue !
Corrigé :
nom=input(‘’Entrez votre nom : ‘’)
print(f’’Bienvenue, {nom} ! ‘’)
Exercice2
Ecrire un programme en Python qui demande à l’utilisateur de saisir deux nombres a et b et de lui afficher leur
somme : a + b
Corrigé :
a=float(input(‘’veuillez entrer la valeur de a : ‘’))
b=float(input(‘’veuillez entrer la valeur de a : ‘’))
print(f‘’la somme de {a} et {b} est {a+b}.’’)
Exercice3
Ecrire un programme en Python qui demande à l’utilisateur de saisir deux nombres a et b et de lui afficher leur
maximum.
Corrigé :
a=float(input(‘’veuillez entrer la valeur de a : ‘’))
b=float(input(‘’veuillez entrer la valeur de a : ‘’))
print(f‘’le maximum est max(a,b) .’’)
Exercice4
Ecrire un programme en langage Python qui affiche les 100 premiers nombres entiers
Corrigé : For i in range(1,101) : print(i)
Exercice5
Ecrire un programme en langage Python qui demande à l’utilisateur de saisir son nombre entier et de lui afficher
si ce nombre est pair ou impair.
Nombre=int(input(‘’Entrez un nombre entier :’’))
If nombre%2==0 :
Print(‘’Ce nombre est pair’’)
Else :Print(‘’Ce nombre est impair’’)
AMINEHASSEN
2|Page PYTHON
Exercice6
Ecrire un programme en langage Python qui demande à l’utilisateur de saisir son âge et de lui afficher le
message « vous êtes Majeur ! » si l’âge tapé est supérieur ou égale à 18 et le message « vous êtes mineur ! » si
l’âge tapé est inférieur à 18
Corrigé :
Age=int(input(‘’Entrer votre age :’’))
If age>=18 :
Print(‘’Vous etes majeur !’’ )
Else :
Print(‘’Vous etes mineur !’’)
Exercice7
Ecrire un programme en Python qui demande à l’utilisateur de saisir 3 nombre x, y et z et de lui afficher leur
maximum.
x=float(input(‘’veuillez entrer la valeur de y : ‘’))
y=float(input(‘’veuillez entrer la valeur de y : ‘’))
z=float(input(‘’veuillez entrer la valeur de z : ‘’))
print(f‘’le maximum est max(x,y,z) .’’)
Exercice8
Ecrire un programme en Python qui demande à l’utilisateur de saisir un nombre entier n et de lui afficher la valeur
de la somme 1 + 2 + … + n = ?
Corrigé :
N=int(input(‘’Entrer un nombre entier :’’))
Somme=sum(range(1,N+1))
Print(‘’La somme des nombres de 1 a N est somme’’)
Exercice9.
Ecrire un programme en Python qui demande à l’utilisateur de saisir un nombre entier n et de lui afficher n !
Corrigé :
Import math
n=int(input(‘’Entrer un nombre entier positif :’’))
if n==0 :
print(‘’La factorielle de n est : 1)
else :
Exercice10
Ecrire un programme en Python qui demande à l’utilisateur de saisir le rayon d’un cercle et de lui renvoyer la
surface et le périmètre.
Corrigé :
import math
rayon=float(input(‘’Entrer le rayon du cercle : ‘’))
surface=math.pi * rayon ** 2
perimetre=2 * math.pi * rayon
print(‘’La surface du cercle est Surface .’’)
print(‘’Le perimetre du cercle est Perimetre.’’)
AMINEHASSEN
3|Page PYTHON
Exercice11
Ecrire un programme en Python qui demande à l’utilisateur de saisir un nombre entier n et de lui afficher tous les
diviseurs de ce nombre.
N=int(input(‘’Entrer un nombre entier : ‘’))
diviseurs=[i for i in range(1,n+1) if n%i==0]
print(‘’les diviseurs de n sont {diviseurs} ‘’)
Exercice12.
– Ecrire un programme en Python qui demande à l’utilisateur de saisir un nombre entier n et de lui afficher la
table de multiplication de ce nombre.
– Améliorez le programme afin qu’il affiche les tables de multiplications de tous les nombres compris entre 1 et 9
corrigé :
Lisp:
(defun table-de-multiplication ()
(format t "Entrez un nombre: ")
(let ((n (read)))
(loop for i from 1 to 10
do (format t "a x ~a = ~a%" n i (* n i)))))
Prolog:
table_de_multiplication(N) :-
between(1, 10, I),
Result is N * I,
format('~w x ~w = ~w~n', [N, I, Result]),
fail.
table_de_multiplication(_). % pour arrêter la recherche après avoir imprimé la table
% Pour exécuter, vous pouvez utiliser
% ?- read(N), table_de_multiplication(N).
AMINEHASSEN
4|Page PYTHON
Python
def table_de_multiplication():
n = int(input("Entrez un nombre: "))
for i in range(1, 11):
print(f"{n} x {i} = {n * i}")
# Exécution de la fonction
table_de_multiplication()
Langage C :
int main()
{
int n ;
printf(‘’Entrer un nombre entier naturel :’’) ;
scanf(‘’%d’’,&n) ;
for(i=1 ;i<=10 ;i++) { print(‘’%d*%d = %d\n’’,n,i,n*i) ;} return 0}
Prolog :
table_de_multiplication(N) :- between(1,10,I), Result is N*I,format (‘’-w * -w =-w-n’’,[N,I,Result]),fail.
Table_de_multiplication(_).
%Excecution : % ?-table_de_multiplication(5).
Exercice13
Ecrire un programme en langage Python qui demande à l’utilisateur de saisir deux nombres entiers a et b et de
lui afficher le quotient et le reste de la division euclidienne de a par b.
Lisp:
(defun quotient-et-reste ()
(format t "Entrez la valeur de a: ")
(let ((a (read))
(b (progn
(format t "Entrez la valeur de b: ")
(read))))
(if (> a b)
(let* ((resultat (floor a b)) ; (quotient, reste)
AMINEHASSEN
5|Page PYTHON
(quotient (car resultat))
(reste (cdr resultat)))
(format t "Quotient: a%" quotient)
(format t "Reste: a%" reste))
(format t "Erreur: a doit être plus grand que b~%"))))
Prolog:
En Prolog, vous pouvez utiliser read pour saisir les valeurs de
a et
b, puis calculer le quotient et le reste avec les opérateurs // et mod.
quotient_et_reste :-
write('Entrez la valeur de a: '),
read(A),
write('Entrez la valeur de b: '),
read(B),
( A>B
-> Quotient is A // B,
Reste is A mod B,
format('Quotient: ~w~n', [Quotient]),
format('Reste: ~w~n', [Reste])
; write('Erreur: a doit être plus grand que b'), nl
).
AMINEHASSEN
6|Page PYTHON
Python:
En Python, vous pouvez utiliser la fonction input() pour saisir les valeurs et les convertir en entiers. Ensuite, vous
pouvez calculer le quotient et le reste avec les opérateurs // et %.
def quotient_et_reste():
a = int(input("Entrez la valeur de a: "))
b = int(input("Entrez la valeur de b: "))
if a > b:
quotient = a // b
reste = a % b
print(f"Quotient: {quotient}")
print(f"Reste: {reste}")
else:
print("Erreur: a doit être plus grand que b")
# Exécution de la fonction
quotient_et_reste()
Langage C
#include <stdio.h>
int main() {
int a, b, quotient, reste;
// Demander à l'utilisateur de saisir les valeurs
printf("Entrez le dividende (a) : ");
scanf("%d", &a);
printf("Entrez le diviseur (b) : ");
scanf("%d", &b);
AMINEHASSEN
7|Page PYTHON
// Vérifier que le diviseur n'est pas zéro
if (b == 0) {
printf("Erreur : Division par zéro n'est pas permise.\n");
return 1; // Retourne 1 pour indiquer une erreur
// Calculer le quotient et le reste
quotient = a / b;
reste = a % b;
// Afficher les résultats
printf("Le quotient de %d divisé par %d est : %d\n", a, b, quotient);
printf("Le reste de %d divisé par %d est : %d\n", a, b, reste);
return 0; // Retourne 0 pour indiquer que le programme s'est terminé correctement
Exercice14
Ecrire un programme en langage Python qui demande à l’utilisateur de saisir un nombre entier n et de lui afficher
si ce nombre est carré parfait ou non.
Exercice15
Ecrire un programme en langage Python qui demande à l’utilisateur de saisir un nombre entier n et de lui afficher
si ce nombre est premier ou non.
### En Python
def est_premier(n):
# Vérifie si un nombre n est premier
if n <= 1:
return False # Les nombres <= 1 ne sont pas premiers
if n <= 3:
return True # 2 et 3 sont des nombres premiers
if n % 2 == 0 or n % 3 == 0:
AMINEHASSEN
8|Page PYTHON
return False # Les multiples de 2 et 3 ne sont pas premiers
i=5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False # Divisible par un nombre autre que 1 et lui-même
i += 6
return True
def main():
try:
# Demande à l'utilisateur d'entrer un nombre entier
n = int(input("Entrez un nombre entier: "))
if est_premier(n):
print(f"{n} est un nombre premier.")
else:
print(f"{n} n'est pas un nombre premier.")
except ValueError:
print("Veuillez entrer un nombre entier valide.")
if _name_ == "_main_":
main()
En Lisp (Common Lisp)
lisp
(defun est-premier (n)
(cond
AMINEHASSEN
9|Page PYTHON
((< n 2) nil) ; Les nombres < 2 ne sont pas premiers
((= n 2) t) ; 2 est un nombre premier
((= (mod n 2) 0) nil) ; Les nombres pairs autres que 2 ne sont pas premiers
(t (loop for i from 3 to (sqrt n) by 2
unless (zerop (mod n i)) ; Si n est divisible par i, ce n'est pas premier
return nil
finally (return t))))) ; Si aucun diviseur n'est trouvé, c'est premier
(defun main ()
(format t "Entrez un nombre entier: ")
(let ((n (read)))
(if (est-premier n)
(format t "A est un nombre premier.%" n)
(format t "A n'est pas un nombre premier.%" n))))
(main)
Langage C
#include <stdio.h>
#include <stdbool.h>
#include <math.h>
// Fonction pour vérifier si un nombre est premier
bool est_premier(int n) {
AMINEHASSEN
10 | P a g e PYTHON
if (n <= 1) return false; // Les nombres <= 1 ne sont pas premiers
if (n <= 3) return true; // 2 et 3 sont des nombres premiers
if (n % 2 == 0 || n % 3 == 0) return false; // Divisible par 2 ou 3, donc pas premier
for (int i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return false; // Divisible par un autre nombre
return true;
int main() {
int n;
printf("Entrez un nombre entier: ");
if (scanf("%d", &n) != 1) {
printf("Veuillez entrer un nombre entier valide.\n");
return 1;
if (est_premier(n)) {
printf("%d est un nombre premier.\n", n);
} else {
printf("%d n'est pas un nombre premier.\n", n);
return 0;
### En Prolog
prolog
% Détermine si un nombre N est premier
AMINEHASSEN
11 | P a g e PYTHON
est_premier(2).
est_premier(N) :-
N > 2,
N mod 2 =\= 0, % N doit être impair
\+ (between(3, sqrt(N), I), N mod I =:= 0). % Vérifie si N est divisible par un nombre entre 3 et sqrt(N)
% Fonction principale qui demande un nombre et affiche si il est premier ou non
main :-
write('Entrez un nombre entier: '),
read(N),
( est_premier(N) ->
format('~d est un nombre premier.~n', [N])
; format('~d n\'est pas un nombre premier.~n', [N])
).
% Exécute la fonction principale à l'initialisation
:- initialization(main). Chaque commentaire explique le rôle des différentes parties du code, ce qui facilite la
compréhension de ce que fait chaque programme.
AMINEHASSEN
12 | P a g e PYTHON
EXERCICE EXAMS :
Programme de calcule du nombre de feuilles, de la hauteur et des branches d’un arbre
Réponse aux questions :
a.
Lisp
(defun nombre-feuilles (arbre)
(if (null arbre)
0
(if (and (consp (car arbre)) (not (cdr arbre)))
(apply #'+ (mapcar #'nombre-feuilles (cdr arbre)))
(if (consp (car arbre))
(nombre-feuilles (cdr arbre))
1))))
b.
(defun nombre-branches (arbre)
(if (null arbre)
0
(if (consp arbre)
(+ (length (cdr arbre))
(apply #'+ (mapcar #'nombre-branches (cdr arbre))))
0)))
c.
(defun profondeur (arbre)
(if (null arbre)
0
(if (not (consp arbre))
1
(1+ (apply #'max (mapcar #'profondeur (cdr arbre)))))))
Prolog
a.
nombre_feuilles(node(_, [], []), 1).
nombre_feuilles(node(_, L, R), Nombre) :-
nombre_feuilles_liste(L, NombreL),
nombre_feuilles_liste(R, NombreR),
Nombre is NombreL + NombreR.
nombre_feuilles_liste([], 0).
nombre_feuilles_liste([H|T], Nombre) :-
nombre_feuilles(H, NombreH),
nombre_feuilles_liste(T, NombreT),
Nombre is NombreH + NombreT.
b.
nombre_branches(node(_, L, R), Nombre) :-
length(L, NbBranchesG),
length(R, NbBranchesD),
Nombre is NbBranchesG + NbBranchesD + NbBranchesG + NbBranchesD. % inclut les branches dans les
sous-arbres
c.
profondeur(node(_, L, R), Profondeur) :-
profondeur_liste(L, ProfondeurG),
profondeur_liste(R, ProfondeurD),
Profondeur is max(ProfondeurG, ProfondeurD) + 1.
AMINEHASSEN
13 | P a g e PYTHON
profondeur_liste([], 0).
profondeur_liste([H|T], Profondeur) :-
profondeur(H, ProfondeurH),
profondeur_liste(T, ProfondeurT),
Profondeur is max(ProfondeurH, ProfondeurT).
Python
a.
def nombre_feuilles(arbre):
if isinstance(arbre, str): # noeud feuille
return 1
elif isinstance(arbre, list):
return sum(nombre_feuilles(sous_arbre) for sous_arbre in arbre)
return 0
b.
def nombre_branches(arbre):
if isinstance(arbre, str): # noeud feuille
return 0
elif isinstance(arbre, list):
nb_branches = len(arbre) - 1 # la racine a (len(arbre) - 1) branches
return nb_branches + sum(nombre_branches(sous_arbre) for sous_arbre in arbre)
return 0
c.
def profondeur(arbre):
if isinstance(arbre, str): # noeud feuille
return 1
elif isinstance(arbre, list):
return 1 + max(profondeur(sous_arbre) for sous_arbre in arbre)
return 0
AMINEHASSEN
