SERIE D’EXERCICES (Les boucles)

Exercice 1
Ecrire un programme en Python qui permet de chercher puis d’afficher tous les entiers naturels formés de quatre
chiffres et qui vérifient les propriétés suivantes :
• La somme des chiffres est égale à vingt.
• Le chiffre des unités est le triple du chiffre des milliers.
• Le chiffre des dizaines est égal à celui des centaines.
Exemples : 1883, 2666, 3449

Algorithme exercice1 #Programme exercice1

Début for n in range(1000, 10000) :
Pour N de 1000 à 9999 Faire u=n%10
u  N div 10 d=(n//10)%10
d  N div 10 mod 10 c=(n//100)%10
c  N div 100 mod 10 m= n//1000
m  N div 1000 if (u+d+c+m==20)and(u==3*m)and(d==c):
Si (u+d+c+m=20)et(u=3*m)et(d=c) print(n,end=" ")
Alors Ecrire(N)
Finsi
Fin pour
Fin

Exercice 2
Un entier naturel de trois chiffres est dit cubique s’il est égal à la somme des cubes de ses trois chiffres.
Exemple: 153 est cubique car : 153 = 13 + 53 + 33
Ecrire un programme en python, qui cherche et affiche tous les entiers cubiques de trois chiffres.
#programme exercice2
Algorithme exercice2
print ("Les nombres cubiques :")
Début
for n in range(100,1000) :
Ecrire("Les nombres cubiques :")
u = n%10
Pour n de 100 à 999 Faire
d = n//10%10
u  n mod 10
c = n//100
d  n div 10 mod 10
if n == (c**3 + d**3 + u**3):
c  n div 100
print (n)
Si n = (c*c*c + d*d*d + u*u*u)
Alors Ecrire (n)
Finsi
Fin pour
Fin

Exercice 3
Ecrire un algorithme puis son implémentation en python qui permet de saisir un entier N, de calculer et d’afficher :
• la somme des N premiers entiers (1+2+3+4+…+N)
• Le produit des N premiers entiers (1*2*3*4*…*N)
• La somme des N premiers entiers impairs (1+3+5+7+…+(2N-1) = N2)

Page 1
Algorithme exercice3
Début #programme exercice3
Ecrire ("Saisir un entier :"), Lire (n) N=int(input("Donner un entier : "))
S10 S1=0
P1 P=1
Pour i de 1 à n Faire for i in range(1, N+1):
S1 S1 + i S1=S1+i
PP*i P=P*i
Fin pour S2=0
S20 for i in range(1, 2*N):
Pour i de 1 à (2*n-1) Faire if i % 2 == 1 :
Si i mod 2 = 1 S2=S2+i
Alors S2 S2 + i # Autre méthode : for i in range(1, 2*N, 2):
Fin si S2=S2+i
Fin pour print("la somme des N premiers entiers :", S1)
Ecrire ("la somme des N premiers entiers :", S1) print("le produit des N premiers entiers :", P)
Ecrire ("le produit des N premiers entiers :", P) print("la somme des N premiers entiers impairs :",
Ecrire ("la somme des N premiers entiers impairs :", S2) S2)
Fin

Exercice 4
Ecrire un programme en Python, qui permet de saisir un entier N, de calculer et d’afficher la somme S suivante :
S = 1 - 1/2 + 1/3 - 1/4 + 1/5 - ......... +1/n
Algorithme exercice4
#programme exercice4
Début
n=int(input("Saisir un entier : "))
Ecrire ("Saisir un entier :"), Lire (n)
s=0
s0
signe=1
signe1
for i in range(1,n+1) :
Pour i de 1 à n Faire
s = s + signe * 1/i
s s + signe * 1/i
signe = - signe
signe  - signe
print ("Somme = %.3f" %s)
Fin pour
Ecrire ("Somme =", s)
Fin

Exercice 5
Ecrire un programme en python, qui permet de saisir deux entiers X et N puis afficher XN.

Algorithme exercice5 #programme exercice5

Début x=int(input('Saisir un nombre entier : '))
Ecrire ("Saisir un nombre entier :"), Lire (x) n=int(input('Saisir la puissance n : '))
Ecrire ("Saisir la puissance n :"), Lire (n) p= 1
p1 for k in range(1,abs(n)+1):
Pour k de 1 à abs(n) Faire p=p*x
p p * x if n<0:
Fin pour p= 1/p
Si n<0 Alors p1/p Finsi print(x, ' puissance ' , n , ' = ' , p)
Ecrire (x, "puissance", n, "=" p)
Fin

Page 2
Exercice 6
Un nombre est dit parfait s’il est égal à la somme de ses diviseurs sauf lui-même. Ecrire un programme en python qui
permet de déterminer si un entier N est parfait ou non.

Algorithme exercice6
# programme exercice6
Début
m = int(input("Saisir un nombre entier : "))
Ecrire ("Saisir un nombre entier :"), Lire (m)
s=0
s0
for i in range (1,(m//2)+1) :
Pour i de 1 à (m div 2) Faire
if m%i == 0 :
Si m mod i = 0
s=s+i
Alors s s + i
if m == s :
Finsi
print(m,"est parfait")
Fin pour
else:
Si m=s
print(m,"n'est pas parfait")
Alors Ecrire (m, "est parfait")
Sinon Ecrire (m, "n’est pas parfait")
Finsi
Fin

Exercice 7
Ecrire un programme en python qui détermine et affiche le nombre de lettres NL, le nombre de chiffres NC et le
nombre de symboles NS d’une chaine de caractères CH donnée.
Algorithme exercice7
Début
#programme exercice7
Ecrire ("Saisir une chaîne :"), Lire (CH)
CH=input("Saisir une chaine : ")
NL0
NL=0
NC0
NC=0
NS0
NS=0
Pour i de 0 à long(CH)-1 Faire
for i in range(0,len(CH)):
Si "A"<= Majus(CH[i])<="Z"
if "A"<=CH[i].upper()<="Z":
Alors NL NL + 1
NL= NL + 1
Sinon Si "0"<=CH[i]<="9"
else:
Alors NCNC + 1
if "0"<=CH[i]<="9":
Sinon NSNS+1
NC=NC + 1
Finsi
else:
Finpour
NS=NS+1
Ecrire ("nombre de lettres : ",NL)
print("nombre de lettres : ",NL)
Ecrire ("nombre de chiffres : ",NC)
print("nombre de chiffres : ",NC)
Ecrire ("nombre de symboles : ",NS)
print("nombre de symboles : ",NS)
Fin

Exercice 8
Ecrire un programme Python qui permet de saisir un entier N et de déterminer et d’afficher tous ses chiffres qui le
divisent.
Exemple : Si N = 2376 alors les chiffres 2, 3 et 6 seront affichés.

Page 3
Algorithme exercice8
#programme exercice8
Début
n=int(input("saisir un entier : "))
Ecrire("saisir un entier : "), Lire (n)
ch=str(n)
ch Convch(n)
print ("les diviseurs de ",n,"sont : ")
Ecrire("les diviseurs de ", n ,"sont : ")
for i in range(len(ch)) :
Pour i de 0 à long(ch)-1 Faire
x=int(ch[i])
xValeur(ch[i])
if (n%x) == 0 :
Si (n mod x) = 0
print(x)
Alors Ecrire(x)
Finsi
Finpour
Fin

Exercice 9
Un entier supérieur à 1 est dit premier s'il admet exactement deux diviseurs : 1 et lui-même. Écrire un programme en
Python, permettant de saisir un entier N de vérifier et d’afficher s’il est premier ou non.
#programme exercice9
Algorithme exercice9
n=int(input("donner un entier >1 : "))
Début
d=0
Ecrire ("donner un entier >1 : "), Lire(n)
for i in range(1,n+1) :
d0
if (n%i) == 0 :
Pour i de 1 à n Faire
d=d+1
Si (n mod i) = 0
if d == 2 :
Alors d  d + 1
print("Le nombre",n,"est premier")
Finsi
else:
Finpour
print("Le nombre",n,"n'est pas premier")
Si d = 2
Alors Ecrire("Le nombre",n,"est premier")
Sinon Ecrire("Le nombre",n,"n'est pas premier")
Finsi
Fin

Exercice 10
Écrire un programme en Python, permettant de trouver le nombre de voyelles dans une chaine de caractères CH.
Exemple : Si CH ="LYCEE ibn rochd chebba"
Le programme affichera le nombre des voyelles est : 7

Algorithme exercice10 #programme exercice10

Début ch=input("saisir une chaine : ")
Ecrire("saisir une chaine : "), Lire(ch) nv = 0
nv 0 for i in range(len(ch)) :
Pour i de 0 à long(ch)-1 Faire if ch[i].upper() in ["A","E","I","O","U","Y"] :
Si Majus(ch[i]) ∈ ["A","E","I","O","U","Y"] nv = nv + 1
Alors nv  nv + 1 print("le nombre de voyelles est :", nv)
Finsi
Finpour
Ecrire("le nombre de voyelles est :",nv)
Fin

Page 4
Exercice 11
Un palindrome est un mot, ou une phrase, lisible dans les deux sens, par exemple "kayak" et "radar". Ecrire un
programme en Python qui vérifie si une chaîne de caractères est palindrome ou non.

Algorithme exercice11
#programme exercice11
Début
ch=input("saisir une chaine ")
Ecrire("saisir une chaine "), Lire(ch)
inv=""
inv  ""
for i in range (len(ch)) :
Pour i de 0 à long(ch)-1 Faire
inv = ch[i] + inv
inv  ch[i] + inv
if inv==ch :
Finpour
print(ch,"est palindrome")
Si inv = ch
else :
Alors Ecrire(ch,"est palindrome")
print(ch,"n'est pas palindrome")
Sinon Ecrire(ch,"n'est pas palindrome")
Finsi
Fin

Exercice 12
Ecrire un programme Python, qui permet de saisir une chaîne de caractères CH puis d’en extraire les deux nombres
formés par les chiffres figurant dans la chaîne CH (extraction à partir de la droite puis extraction à partir de la
gauche).
Exemple : Si CH = "A45B3C2"
Le programme affichera 4532 et 2354
Algorithme exercice12
Début #programme exercice12
Ecrire("saisir une chaine "), Lire(ch) ch=input("saisir une chaine ")
s1  "" s1=""
s2  "" s2=""
Pour i de 0 à Long(ch)-1 Faire for i in range (len(ch)) :
Si Estnum(ch[i]) if ch[i].isnumeric() :
Alors s1  s1 + ch[i] s1 = s1 + ch[i]
s2  ch[i] + s2 s2 = ch[i] + s2
Finsi print(s1)
Finpour print(s2)
Ecrire(s1)
Ecrire(s2)
Fin

Exercice 13
Ecrire un programme Python qui réalise le traitement suivant :
- saisir un entier n de l’intervalle [100,500].
- afficher tous les entiers de l’intervalle [10,30] en remplaçant par le caractère '*' tous les diviseurs de n ainsi
que tous les entiers comportant dans leurs écritures le chiffre de centaine de n.
Exemples d'exécution:
Si n=312 alors la liste suivante sera affichée :
10 11 * * 14 15 16 17 18 19 20 21 22 * * 25 * 27 28 29 *

Page 5
Algorithme exercice13
Début
#programme exercice13
Ecrire("Donner un entier entre 100 et 500")
n=int(input("Donner un entier entre 100 et 500"))
Lire (n)
for i in range(10,31):
Pour i de 10 à 30 Faire
if (n%i==0)or(i%10==n//100)or(i//10==n//100):
Si (n mod i = 0) ou (i mod 10 = n div 100) ou (i div 10 =
print('*',end=' ')
n div 100)
else:
Alors Ecrire ("*"," ")
print(i,end=' ')
Sinon Ecrire (i, " ")
Finsi
Finpour
Fin

Exercice 14
Un nombre N est dit ondulant s’il est formé de trois chiffres au minimum et qui est de la forme ababab… avec a ≠ b.
Exemples :
▪ 101, 2525, 56565 et 1717171 sont des nombres ondulants.
▪ 12345 et 808008 ne sont pas des nombres ondulants
Ecrire un programme Python, qui permet de vérifier si un entier naturel N (N>=100) est un nombre ondulant ou non.

Algorithme exercice14 #programme exercice14

Début valide=False
Répéter while not valide:
Ecrire("Saisir un entier >=100") N=int(input("Saisir un entier >=100"))
Lire(N) valide= N>=100
Jusqu'à N>=100 ch=str(N)
chConvCh(N) i=0
i0 verif=True
verifVrai while (i<=len(ch)-3) and verif :
Tant que (i<=long(ch)-3) ET verif Faire if (ch[i]!=ch[i+1]) and (ch[i]==ch[i+2]) :
Si (ch[i] ≠ch[i+1]) ET (ch[i]=ch[i+2]) i=i+1
Alors ii+1 else:
Sinon verifFaux verif=False
Finsi if verif :
Fin Tant que print(N,"est un nombre ondulant")
Si verif else:
Alors Ecrire(N,"est un nombre ondulant") print(N,"n'est pas ondulant")
Sinon Ecrire(N,"n'est pas ondulant")
Finsi
Fin

Page 6
Exercice 15
Soit S la somme des diviseurs propres (sauf lui-même) de N. Ecrire un programme en Python, qui permet de saisir un
entier N (2 ≤ N ≤ 100) et d’afficher sa nature :
• Nombre déficient si S<N
• Nombre presque parfait si S = N-1
• Nombre parfait si S=N
• Nombre quasi-parfait si S = N+1
• Nombre abondant si S>N
Exemple :
Pour N=6, la somme S=1+2+3, donc N=S, alors le programme affichera "Nombre parfait"

Algorithme nombre
Début
Répéter #program nombre
Lire(n) n=0
Jusqu'à (2 ≤ n ≤ 100) while not (2<=n<=200) :
s0
n=int(input())
Pour i de 1 à (n div 2) Faire
Si n mod i = 0 s=0
Alors s s + i for i in range (1,n//2+1):
Finsi if n % i ==0:
Finpour s=s+i
Si s<n Alors Ecrire(n,' Nombre déficient') if s<n:
Sinon Si s=n Alors Ecrire (n,' Nombre parfait') print(n,' Nombre déficient')
Sinon Ecrire (n,' Nombre abondant') elif s==n:
Finsi print(n,' Nombre parfait')
Si s=n-1 else:
Alors Ecrire(n,' Nombre presque parfait') print(n,' Nombre abondant')
Finsi if s==n-1:
Si s=n+1 print(n,' Nombre presque parfait')
Alors Ecrire(n,' Nombre quasi parfait') if s==n+1:
Finsi print(n,' Nombre quasi parfait')
Fin

Exercice 16
Un nombre N est dit hautement abondant si la somme de ses diviseurs (lui-même inclus) est strictement supérieure
à la somme des diviseurs de n’importe quel nombre plus petit que lui (le nombre inclus).
Exemples :
• 8 est hautement abondant car la somme de ses diviseurs, qui est égale à 15 (1+2+4+8=15), est
strictement supérieure à la somme des diviseurs de tout entier plus petit que lui.
• 5 n’est pas hautement abondant car la somme de ses diviseurs, qui est égale à 6 (1+5=6), est inférieure
à 7 qui la somme des diviseurs de 4 (1+2+4=7).

Page 7
 #programme hautement abondant
def SomDiv(N):
s=N
for i in range(1,N//2 +1):
if N%i==0:
s=s+i
return s

def HAbondant(N):
ok=True
i=N-1
S=SomDiv(N)
while i>=1 and ok:
if SomDiv(i) > S:
ok=False
else :
i=i-1
return ok

for i in range(1,100):
if HAbondant(i):
print(i,end=" ")

Page 8
 Répondez à la question suivante en une seule commande. Combien y a-t-il de nombres pairs dans
l’intervalle [2, 10000] inclus ?

Afin d'apprendre aux élèves la table de multiplication, on veut créer un programme en

python qui demande le résultat de la multiplication de 2 nombres choisies aléatoirement par
l'ordinateur entre 0 et 9. On lui interroge 10 fois en affichant le mot 'bravo' pour chaque
bonne réponse et 'faux' pour une réponse fausse.
On affiche à la fin le score obtenu qui est égale au nombre des réponses correctes /10.
Algorithme exercice13 #programme exercice13
Début from random import*
nb0 nb=0
Pour i de 1 à 10 Faire for i in range(1,11) :
a Aléa(0,9) print("Essai n°",i)
b Aléa(0,9) a=randint(0,9)
Ecrire (a,"*", b,"="), Lire(reponse) b=randint(0,9)
Si reponse=a*b reponse=int(input(str(a)+" * "+str(b)+" = "))
Alors Ecrire ("Bravo") if reponse==a*b:
nb  nb +1 print("Bravo")
Sinon Ecrire ("Faux") nb=nb+1
Finsi else:
Finpour print("Faux")
Ecrire ("Le nombre de réponses correctes : ", print("Le nombre de réponses correctes : ", nb,
nb, " /10") "/10")
Fin

Algorithme exercice3 #programme exercice3

Début N=int(input("Donner un entier : "))
Ecrire ("Saisir un entier :"), Lire (n) S=0
s0 P=1
p1 cs=""
cs"" cp=""
cp"" for i in range(1,N+1):
Pour i de 1 à n Faire cs=cs+str(i)+"+"
s s + i cp=cp+str(i)+"*"
cscs+convch(i)+"+" S=S+i
pp*i P=P*i
cpcp+convch(i)+"*" print(cs[0:len(cs)-1],"=",S)
Fin pour print(cp[0:len(cp)-1],"=",P)
Ecrire (sous_chaîne(cs,0,long(cs)-1), "=", s)
Ecrire (sous_chaîne(cp,0,long(cp)-1), "=", p)
Fin

Page 9