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