Exercices 3SC 2022 2023

Année 2022-2023-3ème Maths, Sciences et Techniques version 26 avril 2023 Matière : Informatique
Projet 1:
Un jeu de devinette consiste à générer un nombre
x(Aléatoire entre 1 et 100) puis essayer de le deviner .
(Ajouter perdu, si le nombre n’est pas trouvé dans 10
essais)
Objectif 1 : Générer un entier x au hasard entre 1 et 100.
Poi Aléa Permet de générer un entier au hasard. Poi Pour affecter une valeur à une variable, on utilise le
nt Algorithme Python symbole d’affectation.
nt
d'inxAléa(0,10) from random import * Algorithme Python
d'in
for x=randint(0,10) x=10
for x10
ma ma Attention : ne pas confondre avec le test d’égalité
tio tio Algorithme Python
n n Si x=10 alors if x==10 :
On va avoir la solution suivante :

Algorithme
Algorithme devinette from random import * #ou from random import randint
Début x=randint(1,100)
xAléa(1,100)
Objectif 2 : Afficher un message contenant la question « Donner un entier entre 1 et 100

= ? » et demander de l’utilisateur une réponse.
Poi Pour afficher une variable ou un message : Poi Pour saisir une variable :
nt Algorithme Python nt Algorithme Python
d'in Ecrire("Message",x) print('Message',x) d'in lire(n) n=input()
for  En Python on peut délimiter un texte avec ' ' ou " " for  En Python : saisir une chaîne (str) : n=input()
ma Exemple : print("C'est un texte") ma saisir un entier (int): n=int(input())
tio  Pour rester sur la même ligne et empêcher un tio saisir un réel (float) : n=float(input())
n retour à la ligne suivante avec print, on pourra utiliser n Pour lire une variable en affichant un message:
l’instruction suivante : print('___',end=' ') n=input('Message=')
Prof:N.DHIFALLAH Page 1 / 33 Année scolaire 2022-2023


Algorithme
Algorithme devinette from random import randint
xAléa(1,100) n=int(input('Donner un entier (entre 1-100) = '))
Ecrire("Donner un entier entre 1 et 100:"),Lire(n)
Objectif 3 : On veut afficher un message suivant la valeur entrée : « Bravo » si la réponse est
juste et « plus grand » ou « plus petit » sinon .
Algorithme
Poi Structure conditionnelle si
Algorithme multiplication from random import *
nt Algorithme Python
xAléa(1,100) y=int(input('Donner un entier d'in Si condition alors if condition :
Ecrire("Donner un entier (entre 1-100) = ')) for Traitement1  traitement1
entre 1 et 100:") if y==x : ma Sinon Traitement 2 else :
Lire(y) print('Bravo') tion FinSi  traitement2
Si x=y alors elif y>x:  En Python on doit utiliser la tabulation  pour
Ecrire("Bravo") print('plus petit !') exprimer un bloc d’instructions
Sinon si y>x alors else:  Pour rester sur la même ligne et empêcher un
Ecrire("Plus petit") print('Plus grand :') retour à la ligne suivante avec print, on pourra
Sinon utiliser l’instruction suivante : print('___',end=' ')
Ecrire("Plus grand")
Fin
Objectif 4 : On veut répéter la saisie d’un nombre et l’affichage du message correspondant

jusqu’à ce que l’utilisateur trouve la solution (x=n) .
Il y a un traitement qui se répète, quelle est la boucle à choisir ?
La boucle Répéter jusqu’à
Poi Algorithme Python
La boucle Pour Poi
Répéter init
nt Algorithme Python nt while not(condition):
Traitement
d'in Pour i de 0 à n-1 faire for i in range(n) : d'i Traitement
Jusqu'à
for Traitement  Traitement nfo
condition(s)
ma FinPour rm
La boucle Tant que faire
tio ati
 En Python on doit utiliser la tabulation  pour Algorithme Python
n
Prof:N.DHIFALLAH Page 2 / 33 on Année scolaire 2022-2023
exprimer un bloc d’instructions Tant que Cond(s) while condition :
 range(4) donne 0 1 2 3 range(1,4) donne 1 2 3 Faire Traitement
Traitement

Algorithme
Algorithme nombre from random import *
XAléa(1,100) y=-1
Répéter while x !=y:
y=int(input('Donner un entier (entre 1-100) = '))
Ecrire("Donner un entire entre 1 et 100:"),Lire(y)
if y==x :
Si x=y alors Ecrire("Bravo") print('Bravo')
Sinon si y>x alors Ecrire("Plus petit") elif y>x:
Sinon Ecrire("Plus grand") print('plus petit !')
Finsi else:
Jusqu’à (x=y) print('Plus grand :')
Fin
Début
Projet 1 : (bis)
On va réaliser un jeu pour apprendre la table
de multiplication. Générer 2 entiers x et y
Référez-vous à l’algorigramme ci-contre pour, au hasard entre 0 et 10
Ecrire un algorithme puis une implémentation
Python permettant de réaliser ce jeu.
Affichage de la question x * y = ?
Saisir une réponse n
Oui Si Non
n=x*y
Prof:N.DHIFALLAH Page 3 / 33
Afficher Bravo Afficher Erreur
Année scolaire 2022-2023
On commence par générer 2 entiers (x et y) au hasard entre 0 et 10.
Poi Aléa Permet de générer un entier au hasard. Poi Pour affecter une valeur à une variable, on utilise le
nt Algorithme Python symbole d’affectation.
nt
d'inxAléa(0,10) from random import * Algorithme Python
d'in
for x=randint(0,10) x=10
for x10
ma ma Attention : ne pas confondre avec le test d’égalité
tio tio Algorithme Python
n n Si x=10 alors if x==10 :
par importer la bibliothèque random

Algorithme
xAléa(0,10) y=randint(0,10)
yAléa(0,10)
On veut maintenant afficher un message contenant la question x * y = ? et demander de l’utilisateur une réponse.
Poi Pour afficher une variable ou un message : Poi Pour saisir une variable :
nt Algorithme Python nt Algorithme Python
d'in Ecrire("Message",x) print('Message',x) d'in lire(n) n=input()
for  En Python on peut délimiter un texte avec ' ' ou " " for  En Python : saisir une chaîne (str) : n=input()
ma Exemple : print("C'est un texte") ma saisir un entier (int): n=int(input())
tio  Pour rester sur la même ligne et empêcher un tio saisir un réel (float) : n=float(input())
n retour à la ligne suivante avec print, on pourra utiliser n Pour lire une variable en affichant un message:
l’instruction suivante : print('___',end=' ') n=input('Message=')

Algorithme
yAléa(0,10) print(x, ' * ' , y , ' = ', end=' ')
Ecrire(x, " * " , y , " = ") n=int(input())
Lire(n)
On veut afficher un message suivant la valeur entrée : « Bravo » si la réponse est juste et « erreur » sinon :

Algorithme
Lire(n) if n==x*y :
Si n=x*y alors print('Bravo')
Ecrire("Bravo") else :
Sinon Ecrire("Erreur") print('Erreur')
FinSi
Fin
Structure conditionnelle si
Poi
Algorithme Python
nt
d'in Si condition alors if condition :
for Traitement1  traitement1
ma Sinon Traitement 2 else :
tio FinSi  traitement2
n  En Python on doit utiliser la tabulation 
pour exprimer un bloc d’instructions
 Pour rester sur la même ligne et empêcher
un retour à la ligne suivante avec print, on
pourra utiliser l’instruction suivante :
print('___',end=' ')
Pour bien s’entrainer sur la table de multiplication, on va répéter le jeu 5 fois.
Poi La boucle Pour

nt Algorithme Python
d'in for i in range(n) :
Pour i de 0 à n-1 faire
for
Traitement  Traitement
ma
FinPour
tio
 En Python on doit utiliser la tabulation  pour
n
exprimer un bloc d’instructions
 range(4) donne 0 1 2 3 range(1,4) donne 1 2 3
Algorithme
Début for i in range(5) :
Pour i de 0 à 4 faire x=randint(0,10)
Lire(n) if n==x*y :
FinSi
FinPour
Fin

Algorithme
Début for i in range(1,6) :
Pour i de 1 à 5 faire print('Essai : ',i)
Ecrire("Essai",i) x=randint(0,10)
Lire(n) if n==x*y :
FinSi
FinPour
Fin
On veut afficher le n° d’essai :
Algorithme
Début score=0
Score=0 for i in range(1,6) :
Pour i de 1 à 5 faire print('Essai : ',i)
Ecrire("Essai",i) x=randint(0,10)
Lire(n) if n==x*y :
Ecrire("Bravo") score=score+1
Scorescore+1 else :
Scorescore-1 score=score-1
FinSi print('score= ',score)
Ecrire("Score=",score) print('score final= ',score)
FinPour
Ecrire("Score final=",score)
Fin
Pour noter l’utilisateur on va

ajouter un score (initialisé par 0 , si
bonne réponse le score
s’incrémente par 1 sinon se
décrémente par 1) , afficher le
score de chaque essai et enfin le
score final :
L’utilisateur doit s’identifier au début du

jeu à travers la saisie de son nom et prénom Poi Pour une chaîne de caractère ch="Bonjour" ch[0]="B"
séparés par espace. nt Algorithme Python
Affichons par la suite un message de d'in Long(ch)=7 len(ch)
for Pos("j",ch)=3
bienvenu à l’utilisateur (en affichant Pos("x",ch)=-1 ch.find('j')
ma Ch[3:len(ch)]
uniquement son prénom). tion Sous_chaîne(ch,3,long(ch)) ="jour" ch[3:]
Algorithme
Algorithme multiplication from random import randint
Début print('Table de multiplication')
Ecrire("nom et prénom=") print('-----------------------')
lire(ch) #***************** Identification ***************
ppos(" ",ch) ch=input('nom et prénom(séparés par un espace)=')
prenom=sous_chaine(ch,p+1,long(ch)) p=ch.find(' ') #position de l'espace
Ecrire("Bonjour", prenom) prenom=ch[p+1:len(ch)]# ou prenom=ch[p+1:]
Score=0 print('Bonjour:',prenom)
Pour i de 1 à 5 faire #**************** commencer le jeu **************
Ecrire("Essai",i) score=0
for i in range(1,6) :
xAléa(0,10)
print('Essai : ',i)
yAléa(0,10)
x=randint(0,10)
Ecrire(x, " * " , y , " = "), Lire(n)
y=randint(0,10)
Si n=x*y alors print(x, ' * ' , y , ' = ', end=' ')
Ecrire("Bravo", prenom) n=int(input())
Scorescore+1 if n==x*y :
Sinon Ecrire("Erreur") print('Bravo',prenom)
Scorescore-1 score=score+1
FinSi else :
Ecrire("Score=",score) print('Erreur')
FinPour score=score-1
Ecrire("Score final=",score) print('score= ',score)
Fin print('************************')
Tableau de déclaration des objets print('score final= ',score)
Objets Types/Nature
Ch,prenom chaîne
Score,p,i, x,y,n Entier
Nom&prénom du joueur :fouleni Foulen
Bonjour Foulen

Jeu Chilaformi
"Pair-Impair" est une version plus simple de jeu « mourre » appelé en Tunisie Chilaformi
1- L'ordinateur saisit aléatoirement un nombre x compris entre 0 et 5.
2- L'utilisateur saisit un nombre y compris entre 0 et 5.
3- Calculer la somme de x et y.
4- Si la somme est paire, alors afficher « Ordinateur gagnant ». Si la somme est impaire, alors afficher « Utilisateur gagnant
».
Attribuer un score à l'ordinateur (score1) et un score à l'utilisateur (score2) initialisés par 0, incrémentés à chaque partie gagnée.
Répéter les étapes 1-4 , 5 fois et afficher à la fin le score final : score utilisateur = .. score ordinateur =...
Exemple d'exécution:
Ordinateur: j'ai choisi un nombre entre 0 et 5= *
Utilisateur :Saisir un nombre entre 0 et 5=2
Chilaformi
La somme de ordinateur( 3) et utilisateur (2)=5 est impaire
Utilisateur gagnant
Algorithme Chilaformi
Début
Score10
Score20
Pour i de 0 à 4 faire
XAléa(0,5)
Ecrire("Ordinateur: J’ai choisi un nombre entre 0 et 5=*")
Poi
Ecrire("Utilisateur: J’ai choisi un nombre entre 0 et 5=")
nt
Lire(y) Division entière
d'in
Sx + y Algorithme Python
for
Ecrire("Chilaformi") a // b
ma a div b
Si S mod 2=0 alors A mod b a % b
tio
Ecrire("La somme de ordinateur(",x,”) et l’utilisateur(",y,”)=”,s,” est paire”)
n
Ecrire("Ordinateur gagnant") 7 2
Score1Score1+1
3 Quotient
Sinon
7 mod 2=1 Reste 1 7 div 2=3
Ecrire("Utilisateur gagnant")
Ecrire("La somme de ordinateur(",x,”) et l’utilisateur(",y,”)=”,s,” est impaire”)
Score2 score2+1
FinSi
Finpour

Ecrire("score ordinateur =”,score1, “Score utilisateur=”,score2)
Fin
Objets Types/Nature
x,y,s,score1,score2, i entier
https://archeostudia.com/2020/04/14/idees-archeo-jeu-antique-pair-impair/
Implémenter l’algorithme en Python et l’envoyer sur Google Classroom
Projet 3: On veut faire la moyenne des notes d’une classe.
Exemple d’exécution : Nbre d’élèves=3

Note 1=10.5
Note 2=13.2
Note 3=18
Moyenne de la classe=13.91
Objectif 1 : Saisir le nombre d’élèves, puis la note de chaque élève, enfin afficher la moyenne de la classe.
Algorithme
Algorithme Moyenne
Début
Ecrire("Nbre d’élèves="),Lire(n) Déclaration des objets
S0 Objets Types/Nature
Pour i de 0 à n-1 faire i,n Entier
Ecrire("Note ",i+1,"="), Lire(x) x,S, moy réel
SS+x
Finpour
MoyS/n
Ecrire("moy classe=",Moy)
Fin
Solution :

Algorithme
si moy >=12 alors if moy>=12 :
Ecrire("Bien") print('Bien')
Sinon si moy>=10 : elif moy>=10 :
Ecrire("Passable") print('passable')
Sinon else :
Ecrire("Faible") print('Faible')
FinSi
Objectif 2 : Ajouter une appréciation :

« Bien »si la moyenne >=12 ,
« Passable » si 10<=moyenne<12
« faible » si moyenne <10.
Implémenter l’algorithme en Python et l’envoyer sur Google Classroom
Ajouter un contrôle de saisie sur les notes pour être entre 0 et 20 et sur le nombre des élèves
pour être entre 2 et 25.

Algorithme
Prof:N.DHIFALLAH Page 10 / 33 Année scolaire 2022-

2023
Algorithme classe
Début n=0
Répéter while n not in range(2,26):
Ecrire("Nbre d’élèves=") n=int(input('Nombres élèves='))
Lire(n)
Jusqu’à 2<=n<=25 s=0
S0 for i in range(n):
Pour i de 0 à n-1 faire x=-1
Répéter while not(0<=x<=20) :
Ecrire("Note ",i+1,"=") x=float(input('Note'+str( i+1)+ '='))
Lire(x) s=s+x
Jusqu’à 0<=x<=20 moy=s/n
SS+x print('moyenne de la classe=',moy)
Finpour if moy>=12 :
MoyS/n print('Bien')
elif moy>=10 :
Ecrire("moy classe=",Moy ) print('passable')
si Moy >=12 alors else :
Ecrire("Bien") print('Faible')
Sinon si Moy>=10 alors
Ecrire("Passable")
Sinon
Ecrire("Faible")
FinSi
Fin Déclaration des objets
Objets Types/Nature
Point
i,n d'information
Entier
S, moy, x réel
La boucle Répéter jusqu’à

2023
Projet 3: Rappel : On veut faire la moyenne des notes d’une classe.

Exemple d’exécution :
Nbre d’élèves=3
Note 1=10.5
Note 2=13.2
Note 3=18
La moyenne de la classe=13.91
Objectif 1 : Saisir le nombre d’élèves, puis la note de chaque élève, enfin afficher la moyenne de la classe.
1ère solution :
Algorithme
Algorithme Moyenne
Début
Ecrire("Nbre d’élèves="),Lire(n) Déclaration des objets
S0 Objets Types/Nature
Pour i de 0 à n-1 faire i,n Entier
Ecrire("Note ",i+1,"="), Lire(x) x,S, moy réel
Point d'information
SS+x On utilisera la bibliothèque
Finpour numpy pour implémenter les
MoyS/n tableaux
Ecrire("moy classe=",Moy) Un tableau numpy est :
Fin Homogène : constitué
d’éléments de même type,
Statique : sa taille est fixée
lors de la création
Exemples :
from numpy import array
T=array([float()]*10)
Remarques : Déclarations
Tableau de chaines :
T=array([str]*25)
Tableau de caractères :
T=array([str()]*25)
Reprendre l’exercice de la moyenne des notes d’une classe,
en utilisant la structure tableau.
2ère solution : (en utilisant les tableaux)
Algorithme
Algorithme classe from numpy import *
Début T=array([float()]*25)
Répéter n=0
Ecrire("Nbre d’élèves=") while n not in range(2,26):
Lire(n) n=int(input('N='))
Jusqu’à 2<=n<=25 for i in range(n):
Pour i de 0 à n-1 faire T[i]=-1
Répéter while not(0<=T[i]<=20):
Ecrire("Note ",i+1,"=") T[i]=float(input('Note'+ str(i+1)+'='))
Lire(T[i]) s=0
Jusqu’à 0<=T[i]<=20 for i in range(n):
2023
Finpour s=s+T[i]
S0 moy=s/n
Pour i de 0 à n-1 faire print('moy classe=',moy) )
SS+T[i]
Finpour
MoyS/n
Ecrire("moy classe=",Moy )
Fin Déclaration des objets
Objets Types/Nature
i,n Entier
T Tableau de 25 réels
S, moy réel
Objectif 2 : Ajouter le calcul puis l’affichage de la meilleure note.

Algorithme

2023
Algorithme classe from numpy import *
Début T=array([float()]*25)
Répéter n=0
Ecrire("Nbre d’élèves="),Lire(n) while n not in range(2,26):
Jusqu’à 2<=n<=25 n=int(input('N='))
Pour i de 0 à n-1 faire for i in range(n):
Répéter T[i]=-1
Ecrire("Note ",i+1,"=") while not(0<=T[i]<=20):
Lire(T[i]) T[i]=float(input('Note'+ str(i+1)+'='))
Jusqu’à 0<=T[i]<=20 s=0
Finpour for i in range(n):
S0 s=s+T[i]
Pour i de 0 à n-1 faire moy=s/n
SS+T[i] M=T[0]
Finpour for i in range(1,n) :
MoyS/n if T[i]>M :
M=T[i]
MT[0] print(' moy de la classe=',moy,'\nMeilleure note=',M)
Si T[i]>M alors MT[i] Finsi
FinPour
Point d'information
Ecrire("moy classe=",Moy , "Meilleure note=",M) Dans un print "\n" permet d’ajouter
Fin Déclaration des objets un retour à la ligne.
Objets Types/Nature
i,n Entier
T Tableau de 25 réels
S, moy, M réel

2023
Ecrire un algorithme puis un script python permettant de saisir un entier n entre 1 et 15 puis remplir un tableau T par
n entiers au hasard (entre 10 et 50), enfin afficher T .
Objectif 2 : Ajouter le calcul puis l’affichage de nombre des entiers pairs dans le tableau T
Algorithme
Algorithme pairs from numpy import *
Début from random import *
Répéter T=array([int()]*15)
Ecrire("n="),Lire(n) n=0
Jusqu’à 1<=n<=15 while n not in range(1,16):
Pour i de 0 à n-1 faire n=int(input('N='))
T[i]=Aléa(10,50)
Pour i de 0 à n-1 faire T[i]=randint(10,50)
Ecrire('T[',i,']=',T[i])
nb0 print('T[',i,']=',T[i])
Pour i de 0 à n-1 faire nb=0
Si T[i] mod 2=0 alors nbnb+1 for i in range(n):
Finsi if T[i] % 2==0:
Finpour nb=nb+1
print('Nbre des pairs=',nb)
Ecrire("Nbre des pairs=",nb)
Fin
Déclaration des objets

Objets Types/Nature
i, n, nb Entier
T Tableau de 15 entiers

2023

2023
Jeu: Deviner l’ordre des chiffres

Soit le jeu suivant :
Donner le nombre des entiers=5
10, 56, 5, 82,12
Deviner l’ordre de ces chiffres:
Essai 1 : Essai 2 : Essai 3 :
Entier n°1=5 Entier n°1=10 Entier n°1=10
X , 12, X, 82, X 10,12, X, 82, X 10,12, 56, 82, 5
1- On demande le nombre des entiers : n (entre 2 et 10)
2- Afficher n entiers générés aléatoirement (entre 1 et 100)
3-Mélanger les éléments du tableau (changer leurs positions) en utilisant shuffle(T)
4- Deviner l’ordre de ces chiffres.
5- Après chaque essai, afficher l’entier s’il est dans la position exacte et X dans le cas contraire.
6-Répéter les étapes 4 et 5 jusqu’à trouver le Bon ordre ou faire nb=n-1 essais
7-Enfin afficher le message “Bravo” si le bon ordre est trouvé et “Perdu” dans le cas contraire.
ok=False
from numpy import * nb=0
from random import * while (ok==False) and (nb<n-1):
ok=True
n=0 nb=nb+1
while n not in range(2,11): print('\nEssai ',nb,' :')
n=int(input("Donner le nbre des entiers=")) for i in range(n):
T1[i]=int(input('Entier '+str(i+1)+'='))
T=array([int()]*n)
T1=array([int()]*n) for i in range(n):
if T[i]==T1[i] :
for i in range(n): print(T[i],end=',')
T[i]=randint(1,100) else :
print('X',end=',')
for i in range(n): ok=False
if i!=n-1: if ok:
print(T[i],end=' , ') print('Bravo !')
else: else:
print(T[i]) print('Perdu!, le bon ordre est:')
for i in range(n):
shuffle(T) if i!=n-1:
print(T[i],end=' , ')
print('Deviner l’ordre de ces chiffres:') else:
print(T[i])

2023
Point
d'information
Intérêts de la décomposition modulaire :
Objectif 1 : Reprendre l’exercice de la moyenne et • Plus d’organisation en séparant les
décomposer le problème en modules. difficultés et les taches.
Point • S’occuper d’un seul problème à la fois.
Lad'information
décomposition modulaire consiste à diviser un problème • En cas d’erreur la division en module
en sous problème de difficultés moindres. Ces derniers sont permet de savoir quel module à corriger
aussi soumis à cette division jusqu'à ce qu’on arrive à un • Plus facile à faire évoluer.
niveau abordable de difficulté. • Permet d’éviter la répétition d’un même
On peut utiliser les modules suivants : n traitement dans un programme.
PP M Point
saisir d'information
T T,n La décomposition modulaire
T,n T,n moy permet de diviser un programme
maximum
remplir en plusieurs sous-programmes.
moyenne
(procédures ou une fonctions).
Algorithmes
Algorithme du programme principal : Algorithme de la fonction moyenne :
Algorithme Classe: fonction moyenne(T:tab,n :entier) :réel
DEBUT Début
Appel d’une
Saisir(n) S0
procédure
Appel Remplir(T1, n) Pour i de 0 à n-1 faire
d’une SS+T[i] Type de retour
Moymoyenne(T1,n)
fonction Paramètres effectifs FinPour de la fonction
Mmaximum(T1,n)
MoyS/n
Ecrire("moy classe=",Moy, "Meilleure note=",M)
Retourner Moy
FIN Fin
Nouveaux Types T.D.O.Locaux
TAB= tableau de 25 réels Objets Types/Nature
T.D.O.globaux
i Entier
Objet Type/Nature s,moy réel
n Entier Algorithme de la fonction maximum :
moy, M réel fonction maximum(T:tab,n :entier) :réel
T1 TAB Début
Saisir, remplir Procédures XT[0] Paramètres formels
Moyenne,maximu fonctions Pour i de 1 à n-1 faire
m Si T[i]>M alors XT[i] Finsi
FinPour
Algorithme de la procédure saisir : Retourner X
Procédure saisir(@n :entier) Fin T.D.O.Locaux
DEBUT Objets Types/Nature
Répéter
i Entier
Ecrire("Nbre d’élèves="), lire(n)
X réel
Jusqu’à 2<=n<=25
Point d'information
FIN
On distingue deux types de paramètres :
Algorithme de la procédure remplir : 1-Les paramètres formels : qui figurent dans la
Procédure Remplir(@T:tab,n :entier) définition de la procédure ou la fonction.
Début 2-Les paramètres effectifs : qui figures dans l'appel de
Pour i de 0 à n-1 faire la procédure ou la fonction et qui sont manipulés par
Répéter celle-ci.
Ecrire("Note ",i+1,"="), Lire(T[i])
Jusqu’à 0<=T[i]<=20 Point d'information
Finpour
Fin Il y a deux modes de passage par (valeur/adresse).
T.D.O.Locaux Si le mode de passage est par référence (par adresse),
on ajoutera le symbole @ avant le nom du paramètre.
Objets Types/Nature

2023
i Entier
Point
d'information
Remarque : Les paramètres formels et les paramètres effectifs doivent s'accorder de point de vue nombre et ordre
et leurs types doivent être identiques ou compatibles.
Point
d'information
En Algorithmique :
Les procédures sont des sous-programmes qui peuvent avoir plusieurs résultats.
Une fonction est un sous-programme qui renvoie une valeur de type simple, ce type sera le type de la fonction..
Implémentations en python
Méthode 1 Méthode 2
from numpy import * from numpy import *
T1=array([float()]*25) T1=array([float()]*25)
def saisir(): def saisir():

n=0 global n
while n not in range(2,26): n=0
n=int(input('Nombres élèves=')) while n not in range(2,26):
return n n=int(input('Nombres élèves='))
def remplir(T,n): def remplir(T,n):

for i in range(n): for i in range(n):
T[i]=-1 T[i]=-1
while not(0<=T[i]<=20): while not(0<=T[i]<=20):
T[i]=float(input('Note'+ T[i]=float(input('Note'+
str(i+1)+'=')) str(i+1)+'='))
def moyenne(T,n): def moyenne(T,n):

s=0 s=0
for i in range(n): for i in range(n):
s=s+T[i] s=s+T[i]
moy=s/n moy=s/n
return moy return moy
def maximum(T,n): def maximum(T,n):

X=T[0] X=T[0]
for i in range(1,n) : for i in range(1,n) :
if T[i]>X : if T[i]>X :
X=T[i] X=T[i]
return X return X
#programme principal #programme principal

n=saisir() saisir()
remplir(T1,n) remplir(T1,n)
moy=moyenne(T1,n) moy=moyenne(T1,n)
M=maximum(T1,n) M=maximum(T1,n)
print('moy de la classe=',moy,'\nMeilleure print('moy de la classe=',moy,'\nMeilleure
note=',M) note=',M)

2023
Objectif 2 : Modifier le programme principal et le module Remplir

pour saisir le nom et chaque élève et sa note.
Déclarer un tableau de caractère : Exemple d’exécution :

Poi Déclaration
nt T1 = array ([str( )] * N)
d'i Déclarer un tableau de chaînes de caractère :
nf Déclaration
or
m T2 = array ([str] * N)
ati
on
Algorithme
Algorithme du programme principal : from numpy import *
Algorithme Classe: T1=array([float()]*25)
DEBUT T2=array([str]*25)
Saisir(n) def saisir():
Remplir(T1,T2 n) n=0
Moymoyenne(T1,n) while n not in range(2,26):
n=int(input('Nombres élèves='))
Mmaximum(T1,n) return n
FIN
Nouveaux Types def remplir(T,T2,n):
TAB= tableau de 25 réels for i in range(n):
TAB2=Tableau de 25 chaînes T2[i]=input('Nom '+str(i+1)+'=')
T.D.O.globaux T[i]=-1
Objet Type/Nature while not(0<=T[i]<=20):
T[i]=float(input('Note'+
n Entier
str(i+1)+'='))
moy, M réel
T1 TAB
def moyenne(T,n):
T2 TAB2
s=0
Saisir, remplir Procédures for i in range(n):
Moyenne,maximu fonctions s=s+T[i]
m moy=s/n
return moy
Algorithme de la procédure remplir : def maximum(T,n):

Procédure Remplir(@T:tab,@T2:tab2,n :entier) X=T[0]
Début for i in range(1,n) :
Pour i de 0 à n-1 faire if T[i]>X :
Ecrire("Nom ",i+1,"="), Lire(T2[i]) X=T[i]
Répéter return X
Ecrire("Note ",i+1,"="), Lire(T[i])
Jusqu’à 0<=T[i]<=20 #programme principal
Finpour n=saisir()
Fin remplir(T1,T2,n)
T.D.O.Locaux moy=moyenne(T1,n)
Objets Types/Nature M=maximum(T1,n)
print('moy de la classe=',moy,'\nMeilleure
i Entier note=',M)

2023
Objectif 3 : Modifier le programme principal et ajouter un

module Afficher pour afficher les élèves et leurs notes
Déclarer un tableau de caractère :

Poi Déclaration
nt
d'i T1 = array ([str( )] * N)
nf Déclarer un tableau de chaînes de caractère :
or Déclaration
m T2 = array ([str] * N)
ati
on
Algorithme
Remplir(T1,T2, n) n=0
Moymoyenne(T1,n) while n not in range(2,26):
Afficher(T1,T2,n)
FIN def remplir(T,T2,n):
Nouveaux Types for i in range(n):
TAB= tableau de 25 réels T2[i]=input('Nom '+str(i+1)+'=')
TAB2=Tableau de 25 chaînes T[i]=-1
while not(0<=T[i]<=20):
T.D.O.globaux
T[i]=float(input('Note'+
Objet Type/Nature
str(i+1)+'='))
n Entier
moy, M réel def moyenne(T,n):
T1 TAB s=0
T2 TAB2 for i in range(n):
Saisir, remplir, afficher Procédures s=s+T[i]
Moyenne,maximum fonctions moy=s/n
return moy
Algorithme de la procédure Afficher : def maximum(T,n):

Procédure Afficher(T1:tab,T2:tab2,n :entier) X=T[0]
Début for i in range(1,n) :
Pour i de 0 à n-1 faire if T[i]>X :
Ecrire(T2[i] , " : ", T1[i] ) X=T[i]
Finpour return X
Fin
T.D.O.Locaux def afficher(T1,T2,n):
Objets Types/Nature for i in range(n):
print(T2[i], ' : ', T1[i])
i Entier
#programme principal
n=saisir()
remplir(T1,T2,n)
moy=moyenne(T1,n)
M=maximum(T1,n)
afficher(T1,T2,n)
2023
print('moy de la classe=',moy,'\nMeilleure
note=',M)
Exercice 1 : PGCD(Plus grand commun diviseur)

Calcul de PGCD de 2 entiers a et b par la
méthode de différence :
Exp : a=15 b =27
pgcd(15,27) =pgcd(15 , 27-15 )
=pgcd(15 , 12) =pgcd(15-12 ,12)
=pgcd(3 , 12)=pgcd(3 , 12-3)
On veut poser un barreaudage pour une fenêtre de longueur L =pgcd(3 , 9 )=pgcd(3 , 9-3)=pgcd(3,6)
et de hauteur H, de manière que la distance D maximale entre =pgcd(3 , 6-3)=pgcd(3 , 3) → a=b
les barreaux soit identique sur toute la longueur et la donc pgcd(a,b)=a=b=3
hauteur.
Solution : Calculer le PGCD(Plus grand commun diviseur) de L et H.
Travail à faire: Ecrire un algorithme puis un script Python permettant de saisir 2 entiers (la longueur L(en cm), puis la
hauteur H (en cm), ensuite calculer le PGCD de L et H (définir un module pour réaliser le calcul) enfin afficher la distance
maximale D entre les barreaux équidistants.
Algorithme barreaudage: Fonction pgcd(a, b : entier) : Une implémentation en python:
DEBUT entier def pgcd(a,b):
Ecrire("L=") , Lire(L) DEBUT while a!=b:
Ecrire("H=") , Lire(H) Tant que a≠b faire if a>b:
Ecrire("Distance D=”,pgcd(L,H)) Si a>b alors a←a-b Finsi a=a-b
FIN Si b>a alors b←b-a Finsi if b>a:
T.D.O FinTantQue b=b-a
Objet Type/Nature return a
L,H Entier Retourner a L=int(input('L='))
pgcd fonction FIN. H=int(input('H='))
print('Disatance maximale D=',pgcd(L,H))
Exercice 2: Nombres premiers
1-Ecrire un module en python permettant de vérifier si un nombre n est premier. premier(n) (retourne True ou False)
2-Afficher à la suite tous les entiers premiers entre 1 et 99 :
Rq :Un nombre premier est un entier naturel qui admet exactement deux diviseurs distincts entiers et positifs ( 1 et lui-même).
Algorithme nbrpremiers: Fonction premier(n : entier) : booléen Une implémentation en python:
DEBUT DEBUT def premier(n):
Pour i de 1 à 99 faire nb0 nb=0
si premier(i)=vrai alors Pour i de 1 à n faire for i in range(1,n+1): if nb==2:
Ecrire(i) Si n mod i =0 Alors nbnb+1 Finsi if n % i==0: return True
Finsi FinPour nb=nb+1 else:
FinPour Retourner nb=2 return nb==2 return False
FIN T.D.O FIN. T.D.O.Locaux for i in range(1,100):
Objet Type/Nature Objet Type/Nature if premier(i): # if premier(i)==True:
i Entier i,nb Entier print(i)
premier fonction
Exercice 3: (Décomposition en produit de facteurs premiers)

Ecrire l’algorithme d’un programme qui permet de chercher puis d’afficher la décomposition en produit de facteurs
premiers d’un entier n donné. La décomposition d’un entier en produit de facteurs premiers consiste à écrire cet entier
sous la forme d’un produit de ces diviseurs premiers.

2023
Algorithme facteurs: Procédure afficher_fact(n : entier) Une implémentation en
DEBUT DEBUT python:
Ecrire("n à décomp=") i=2 def afficher_fact(x):
Lire(n) Répéter i=2
afficher_fact(n) Tant que n mod i =0 faire while x!=1:
FIN T.D.O Ecrire ( i ) while x % i==0:
Objet T/N nn div i print(i, end=" ")
n entier FinTantque x=x//i
afficher_fact Procédure ii+1 i=i+1
Jusqu’a n=1 n=int(input('n='))
FIN. T.D.O.Locaux afficher_fact(n)
Objet Type/Nature
i Entier
Exercice 4 :
On se propose d’écrire un algorithme en utilisant la décomposition modulaire permettant de saisir le nombre de ville n
(entre 3 et 9), puis le nom de chaque ville (chaîne de longueur <20) suivi par La quantité de pluies enregistrée en
millimètres (entre 0 et 150.5), ensuite d’afficher chaque ville et sa pluviométrie, enfin le nom de la ville ayant un maximum
pluviométrique.
Exemple : Donner le nombre des villes=3
Ville 1=Sousse
Qté pluies 1=24.8
Ville 2=Monastir
Qté pluies 2=59.8
Ville 3=Gabes
Qté pluies 3=19.6
Pluviométrie :
Sousse : 24.8
Monastir :59.8
Gabes :19.6
Pluviométrie max dans la ville = Monastir
Exercice 5: Ecrire un algorithme puis un script python permettant de saisir un entier n entre (5 et 15) puis remplir un
tableau T par des entiers aléatoires (entre 10 et 50), ensuite afficher le tableau T, enfin calculer et afficher nb ( le nombre
des entiers pairs).
Algorithme pairs: Paramètre effectif T.D.O.Globaux from numpy import *
DEBUT Objet Type/nature from random import *
Saisir(n) n, nb Entier T=array([int()]*15)
Appel d’une
Remplir(T, n) T Tab
procédure def saisir():
Afficher(T, n) Saisir procédure
nb calculer(T,n) remplir procédure n=-1
Ecrire("nbre des pairs=",nb) Afficher procédure while not(5<=n<=15):
FIN calculer fonction n=int(input('nbre de personnes='))
return n
Nouveaux Types
TAB= tableau de 15 entiers
def remplir (T,n):
Algorithme de la procédure saisir : for i in range(n):
Procédure saisir(@ n :entier) Passage
T[i]=randint(10,50)
Début par variable
Répéter
Ecrire("Donner le nombre de personnes"), Lire(n) def afficher(T,n):
Jusqu’a n ∈[5..15] for i in range(n):
Fin print(T[i], end=" ")
Algorithme de la procédure remplir : print()
Procédure remplir(@T :TAB, n :entier)
Début T.D.O.Locaux def calculer(T,n):
Pour i de 0 à n-1 faire Objet T/N nb=0
T[i]Aléa(10,50) for i in range(n) :
i Entier
Finpour if T[i] % 2==0 :
Paramètre formel nb=nb+1
Fin
2023
Algorithme de la procédure Afficher: return nb
Procédure Afficher(T :TAB, n :entier) #programme principal
Début T.D.O.Locaux n=saisir()
Pour i de 0 à n-1 faire Passage Objet T/N remplir(T,n)
Ecrire(T[i]) par valeur i Entier afficher(T,n)
Finpour print('le nombre des pairs=',calculer(T,n))
Fin n
Algorithme de la fonction calculer: PP
fonction calculer(T :TAB, n :entier):entier nb
Début T.D.O.Locaux saisir T
nb0 Objet T/N n T,n
Pour i de 0 à n-1 faire i,nb Entier T,n
si T[i] mod 2=0 alors nbnb+1 FinSi calculer
Finpour remplir
retourner nb Afficher
Fin
La recherche séquentielle : Pour un tableau T de taille n. par exemple n=5 x=10
La méthode de recherche séquentielle d'un élément x dans un tableau T consiste à parcourir le tableau élément par
élément progressivement de début vers la fin en les comparants avec l'élément à chercher jusqu'à trouver ce dernier ou
achever le tableau.
Algorithme de la fonction Chercher : def chercher(x,T,n):
Fonction chercher(x : entier , T :Tab, n :entier) :booléen trouve=False
Début i=-1
TrouveFaux while (trouve==False) and (i!=n-1):
i-1 i=i+1
Répéter if T[i]==x:
ii+1 trouve=True
Si T[i]=x alors trouvevrai FinSi
return trouve
Jusqu’à (trouve=vrai) ou (i=n-1)
Retourner trouve
Fin T.D.O.Locaux
Objet Type/Nature
i Entier
trouve booléen
Le tri d’un tableau: Le tri d’un tableau consiste à le mettre en ordre (croissant ou décroissant). Tri à bulles
Principe : pour un tableau d’entiers de taille n:
Faire remonter le plus grand élément du tableau en Procédure tri_bulle(@T:TAB,n:Entier)
comparant les éléments successifs. Début
Déroulement de l’algorithme : Répéter
-On commence par i=0, on compare le 1er(T[0]) et le 2éme Echange faux
élément(T[1]) du tableau, s'il ne sont pas dans le bon Pour i de 0 à n-2 faire
ordre, on les permute, on passe ensuite au 2ème (T[1])et Si ( T[i] > T[i+1])Alors auxT[i]
3ème (T[2]), puis 3ème et 4ème et ainsi de suite jusqu'au T[i]T[i+1]
(T[n-2])et (T[n-1]). T[i+1]aux
→À la fin du premier parcours, on aura poussé le plus Echange vrai
grand élément du tableau vers sa place finale qui est le FinSi
nième élément du tableau. FinPour
-On recommence cette opération en parcourant de 0 à n-2 n n-1
puis de 0 à n-3 et ainsi de suite. Jusqu'à (Echange = Faux) ou (n=1)
→On arrête quand la partie à trier est réduite à un seul Fin T.D.O.Locaux
élément ou que le tableau est devenu trié (c.à.d aucune Objet Type/Nature
permutation n'a été faite lors du dernier parcours à vérifier i Entier
par un indicateur) echange Booléen
aux Même type que les éléments du tableau
Exercice 7: Ecrire un script python permettant de saisir un entier n entre 1 et 15 puis remplir un tableau T par des entiers
au hasard (entre 10 et 50), ensuite afficher T, puis trier T en ordre croissant enfin afficher le résultat (le contenu de T).
(reprendre l’exercice 4 et ajouter le tri et l’affichage)
from numpy import * def tri_bulles(T,n):
2023
from random import * echange=True
T=array([int()]*15) while (echange) and (n!=1):
def saisir(): echange=False
n=0 for i in range(n-1):
while not(1<=n<=15): if (T[i]>T[i+1]):
n=int(input("n=")) echange=True
return n aux=T[i]
def remplir (T,n): T[i]=T[i+1]
for i in range(n): T[i+1]=aux
T[i]=randint(10,50) n=n-1
#programme principal
def afficher(T,n): n=saisir()
for i in range(n): remplir(T,n)
print(T[i], end=" ") afficher(T,n)
print() tri_bulles(T,n)
afficher(T,n)
Remarque: En Python return T :est facultatif puisque le module tri_bulles modifie directement le tableau T(T par défaut passé
par référence).
Reprendre l’exercice de la moyenne : Algorithme classe.
Objectif 4 : Ajouter un module Résultat pour afficher le rang , le nom et la

moyenne de chaque élève en ordre décroissant suivant la moyenne.
Exemple d’affichage :
Algorithme
while n not in range(2,26):
Moymoyenne(T1,n)
Tri_bulles(T1,T2,n) def remplir(T1,T2,n):
Afficher(T1,T2,n) T2[i]=input('Nom '+str(i+1)+'=')
T1[i]=-1
FIN
while not((0<=T1[i]<=20)) :
Nouveaux Types
T1[i]=float(input("Note"+str(i+1)+'='))
TAB= tableau de 25 réels
TAB2=Tableau de 25 chaînes def moyenne(T,n): def maximum(T,n): def afficher (T1,T2,n):
T.D.O.globaux s=0 X=T[0] for i in range(n):
Objet Type/Nature for i in range(n): for i in range(1,n) : print(i+1,'-',T2[i],':',T1[i])
n Entier s=s+T[i] if T[i]>X :
moy=s/n X=T[i]
moy, M réel
return moy return X
T1 TAB def tri_bulles(T1,T2,n):
T2 TAB2 echange=True
Saisir, remplir, Tri_bulles Procédures while (echange) and (n!=1):
Moyenne,maximum fonctions echang=False
Algorithme de la procédure tri_bulles : for i in range(n-1):
Procédure tri_bulles(@T1:TAB, @T2:TAB2,n:Entier) if (T1[i]<T1[i+1]):
Début echange=True
Répéter aux1=T1[i]
Echange faux T1[i]=T1[i+1]
Pour i de 0 à n-2 faire T1[i+1]=aux1
Si ( T1[i] <T1[i+1])Alors Echange vrai
Aux1T1[i] aux2=T2[i]
T1[i]T1[i+1] T2[i]=T2[i+1]
T1[i+1]aux1 T2[i+1]= aux2
Aux2T2[i] n=n-1
T2[i]T2[i+1] #programme principal
2023
T2[i+1]aux2 n=saisir()
FinSi remplir(T1,T2,n)
FinPour moy=moyenne(T1,n)
n n-1 M=maximum(T1,n)
Jusqu'à (Echange = Faux) ou (n=1) tri_bulles(T1,T2,n)
Fin T.D.O.Locaux print('Liste triée:')
Objet Type/Nature afficher(T1,T2,n)
print('moy de la classe=',moy,'\nMeilleure note=',M)
i Entier
aux1 Réel
aux2 Chaîne de caractère
Echange Booléen
Algorithme de la procédure Afficher :
Procédure Afficher(T1:tab,T2:tab2,n :entier)
Début
Ecrire(i+1,"-", T2[i] , " : ", T1[i] )
Finpour Objets Types/Nature
Fin T.D.O.Locaux i Entier

2023
3èmes Maths, Sciences et Techniques Exercices sur les chaînes de caractères Matière : Informatique
Ch[i] Long(ch) Sous_chaîne Ch1+ch2 Ecrire un programme qui permet de saisir une chaine ch
Ecrire un algorithme puis un programme en langage Python, qui : ch=input('Donner une chaine=')  de longueur < =10 caractères puis l’inverse, enfin indique
 Demande à l’utilisateur de saisir une chaîne de caractère ch L=len(ch) si c'est un palindrome. (S’écrivant de la même façon de
 Permet d’afficher le nombre de caractère de cette chaîne print('Le nbre de caractère de ', ch, '=',L) gauche à droite et de droite à gauche . Exemples : radar,
 Échange le premier et le dernier caractère de cette chaîne ch=ch[L-1]+ch[1:L-1]+ch[0]
Algorithme ex1 print('Chaine résultat=',ch)  elle,...) .
Objet Type/Nature
Début  Algorithme palindrome  Ch, ch2 Chaîne
Ecrire("Donner une chaine="), lire(ch) Début i Entier
Llong(ch) Répéter
Ecrire("le nbre de caractère de ", ch, "=",L) c=input('Donner un caractère =')
Ecrire("ch="), lire(ch)
Chch[L-1]+sous_chaine(ch,1,L-1)+ch[0] if 'A'<=c.upper()<='Z':
Jusqu’à 2<=long(ch)<=10
Ecrire("Chaine résultat=",ch) Objet print('Lettre')
Type/Nature Ch2""
Fin if c.upper() in {'A','E','I', 'O', 'U','Y'}: Pour i de long(ch)-1 à 0 (pas=-1) faire
ch Chaîne
print('Voyelle') Ch2ch2+ch[i]
L entier
else: FinPour
Majus Caractère print('Consonne') Ch"" Ch[i]
Si ch2=ch alors Ecrire("Palindrome")
elif '0'<= c <='9':
c["A".."Z"] c["0".."9"]
Ecrire c{"Y","O","U"}
un algorithme puis un programme
en langage Python, qui permet de, saisir print('Chiffre')  Sinon Ecrire("Non palindrome")
FinSi
Long(ch) Ch1+ch2
un caractère puis déterminer sa nature else: Fin Parcours inverse chaîne

lettre, chiffre ou symbole. Rq :Ajouter le print('Symbole') ch=''
cas de voyelles et des consonnes. while len(ch) not in range(2,11):
Algorithme nature ch=input('Ch=')
Début  Algorithme lettres  ch2=''
Ecrire("Donner un caractère ="), lire(c) for i in range(len(ch)-1,-1,-1):
Si majus(c)["A".."Z"]alors Début ch2=ch2+ch[i]
Ecrire("Lettre") Ecrire("Donner une chaine if ch2==ch:
si Majus(c) {"A","E","I", composée par des chiffres et des print('Palindrome')
"O", "U","Y"} lettres="), lire(ch) else:
alors Ecrire("Voyelle") Ch1"" print('Non palindrome')
Sinon Ch2""
Ecrire("Consonne") Objet Type/Nature Pour i de 0 à long(ch)-1 faire
c Caractère Si majus(ch[i])["A".."Z"] alors ch=input('Donner une chaine composée par des chiffres et des
Finsi
Ch1ch1+ch[i] lettres=')
Sinon si c ["0".."9"] alors
FinSi ch1=''
Ecrire("chiffre")
Sinon Ecrire("Symbole") Si ch[i]["0".."9"] alors ch2='' 
FinSi
Ch[i] Ch1+ch2 c["A".."Z"] Ch2ch2+ch[i] for i in range(len(ch)): Caractère chr ord
Fin Ch"" Parcours chaîne Majus c["0".."9"] FinSi if 'A'<=ch[i].upper()<='Z':
FinPourqui permet de saisir une chaîne ch1=ch1+ch[i]
Écrire un programme 'A'<'B'
Ecrire("Lettres=",ch1,
Ch composée uniquement de chiffres et de lettres if '0'<=ch[i]<='9': ord('A')<ord('B')
puis extraire les lettres"Chiffres=",ch2)
dans une chaîne CH1 et les ch2=ch2+ch[i] 65 < 66
Fin print('Lettres=',ch1,' Chiffres=',ch2) chr(65)='A'
 chiffres dans une chaîne CH2, Enfin les afficher.
2023
3èmes Maths, Sciences et Techniques Exercices sur les chaînes de caractères Matière : Informatique
Ecrire un programme qui permet de saisir une ch=input('Donner une chaine=') Exercice 9 : Ecrire un script python permettant de saisir n entre2 et 10
chaine Ch puis une lettre L ensuite calcul et L=input('Donner une lettre=') puis remplir un tableau T par des entiers entre 5 et 20 puis saisir un
affiche le nombre d’occurrence de L dans ch dans if ch.find(L)==-1: autre entier x enfin afficher si x existe dans T ou non. Pour N=5 et
le cas où L existe dans ch et affiche n’existe pas print(L,"n'existe pas dans ", ch) X=11 => N’existe pas
dans le cas contraire. else: 0 1 2 3 4
Parcours chaîne Ch[i]
Algorithme occurrence nb=0 T 15 20 10 1 7
Début Long(ch) Caractère Pos(c,ch) for i in range(len(ch)):  from numpy import *
Ecrire("Donner une chaine="), lire(ch) if ch[i]==L: T=array([int()]*15)
Ecrire("Donner une lettre="), lire(L) nb=nb+1 def saisir():
Si pos(L,ch)=-1 alors Ecrire (L,"n’existe pas dans ",ch) print(L,' existe ', nb ,' fois dans ',ch) n=0
Sinon while not(2<=n<=10):
Nb0 n=int(input('n='))
Objet Type/Nature
Pour i de 0 à long(ch)-1 faire  Convch Valeur
n,S Entier
return n
def remplir (T,n):
Si ch[i]=L alors nbnb+1 FinSi Parcours chaîne ch Chaîne
Ecrire (L,"existe ", nb ,"fois dans ",ch) for i in range(n):
Ch[i]Algorithme
Long(ch) chiffres2
FinSi Objet Type/Nature T[i]=0
Début
Fin ch chaîne while not(5<=T[i]<=20):
Ecrire("Donner un entier=")
L Caractère T[i]=int(input('T['+ str(i+1)+']='))
lire(n)
def chercher(x,T,n):
I,nb entier chconvch(n)  trouve=False
s0
i=-1
Pour i de 0 à long(ch)-1
Ecrire un algorithme puis un script Python while (trouve==False) and (i!=n-1):
faire
permettant de saisir un entier n (composé i=i+1
ss+valeur(ch[i])
de 3 chiffres) puis afficher la somme de ces if T[i]==x:
Ecrire("La somme des
chiffres. trouve=True Selon code
chiffres=",s)
Exemple : Donner un entier de 3 chiffres =123 return trouve 619 : Message "Tunisie"
Fin
La somme des chiffres=6 #programme principal 600,601: Message "Afrique de sud"
Rq :Modifier le programme pour afficher la somme n=saisir()
n=int(input('Donner un entier =')) 450..459,490:Message "Japon"
des chiffres d’un entier composé d’un nombre remplir(T,n)
ch=str(n)
x=int(input('x='))
sinon Message "Autres"
quelconque de chiffres.
s=0
Algorithme chiffres
 for i in range(len(ch)):
 if chercher(x,T,n): FinSelon
Début print('existe') match code:
s=s+int(ch[i])
Ecrire("Donner un entier de 3 chiffres ="), else: case 619:
print('La somme des chiffres=',s)
lire(n) print("n'existe pas") message='Tunisie'
cn div 100 case 600 | 601:
d(n mod 100 ) div 10 n=int(input('Donner un entier de 3 chiffres=')) message='Afrique de sud'
un mod 10 c=n//100 case code if 450<=code<=459 |490:
sc+d+u d=n % 100 //10  message='japon'
Ecrire("La somme des chiffres=",s) u=n%10
Fin case _ :
Objet Type/Nature s=c+d+u
print('La somme des
message=’autre’
Prof:N.DHIFALLAH n,c,d,u,s Entier Pagechiffres=',s)
28 / 33 Année scolaire 2022-
2023
Exercice 8: def verif(ch):

Écrire un programme qui permet de saisir une chaîne Ch if ch=='' :
composée uniquement de chiffres et de lettres puis extraire les ok=False
lettres dans une chaîne CH1 et les chiffres dans une chaîne else:
CH2. i=-1
Algorithme du programme principal : ok=True
Algorithme extraction while (ok==True) and (i!=len(ch)-1):
Début i=i+1
saisir(ch) if not(('0'<=ch[i]<='9') or ('A'<=ch[i].upper()<='Z')):
extraire(ch,ch1,ch2) ok=False
Ecrire ("Lettres=",ch1,"Chiffres =",ch2) return ok
Fin def saisir():
T.D.O.Globaux ch=''
Objet Type/nature while verif(ch)==False:
Ch,ch1,ch2 chaîne ch=input('ch=')
Saisir , extraire procédure return ch
Algorithme de la procedure saisir: def extraire(ch):
Procédure saisir( @ ch:chaine) global ch1,ch2
ch1=''
Début
ch2=''
Répéter
for i in range(len(ch)):
Ecrire("ch="),lire(ch)
if '0'<=ch[i]<='9': # if ch[i].isdecimal() :
Jusqu’a verif(ch)=vrai
ch2=ch2+ch[i]
Fin T.D.O.Locaux
else:
Objet T/N ch1=ch1+ch[i]
verif fonction #programme principal
ch=saisir()
Algorithme de la fonction verif: extraire(ch)
Fonction verif(ch:chaine):booléen print('Lettres=',ch1,'\nChiffres =',ch2)
Début
Si ch=""alors ok Faux
Sinon
i← -1, ok←vrai
Répéter
i←i+1
si NON(ch[i] dans ["0.."9", "a".."z","A".."Z"])
alors ok ←Faux
Finsi
Jusqu'a (i=long(ch)-1) ou (ok=faux)
FinSi
Retourner ok
Fin T.D.O.Locaux
Objet T/N
I Entier
ok booléen
Algorithme de la procédure extraire :
procédure extraire(ch :chaine ,@ ch1 : chaine ,@ ch2 :chaine)
Début
CH1←"", CH2← ""
Pour i de 0 à long(ch)-1 faire Estnum(ch[i])
Si ch[i] dans ["0".."9"] alors CH2 ←CH2+ch[i]
Sinon CH1←CH1+ch[i] FinSi
FinPour
Fin T.D.O.Locaux
Objet T/N

i Entier
Objectif 7 : Ajouter un contrôle de saisie sur les noms des élèves pour être composés par des lettres et des
espaces seulement.
Algorithme
while n not in range(2,26):
Moymoyenne(T1,n)
Tri_bulles(T1,T2,n) def remplir(T1,T2,n):
Afficher(T1,T2,n) for i in range(n):
Ecrire("moy classe=",Moy, "Meilleure note=",M) T2[i]='-'
while verif(T2[i])==False:
FIN
T2[i]=input('Nom '+str(i+1)+'=')
Nouveaux Types
TAB= tableau de 25 réels T1[i]=-1
TAB2=Tableau de 25 chaînes while not((0<=T1[i]<=20)) :
T.D.O.globaux T1[i]=float(input("Note"+str(i+1)+'='))
Objet Type/Nature
n Entier def moyenne(T,n): def maximum(T,n): def afficher (T1,T2,n):
moy, M réel s=0 X=T[0] for i in range(n):
T1 TAB for i in range(n): for i in range(1,n) : print(i+1,'-',T2[i],':',T1[i])
s=s+T[i] if T[i]>X :
T2 TAB2
moy=s/n X=T[i]
Saisir, remplir, Tri_bulles Procédures return moy return X
Moyenne,maximum fonctions def verif(ch):
Algorithme de la fonction verif: ok=True
Fonction verif(ch:chaine):booléen i=-1
Début while (ok==True) and (i<len(ch)-1):
i← -1, ok←vrai i=i+1
Répéter if not(('A'<=ch[i].upper()<='Z')or (ch[i]==' ')):
i←i+1 ok=False
si NON(Majus(ch[i])  ["A".."Z"] ou ch[i]=" ") return ok
alors ok ←Faux def tri_bulles(T1,T2,n):
Finsi echange=True
Jusqu'a (i=long(ch)-1) ou (ok=faux) while (echange) and (n!=1):
Retourner ok echang=False
Fin Objet T/N for i in range(n-1):
T.D.O.Locaux i Entier if (T1[i]<T1[i+1]):
ok booléen echange=True
aux1=T1[i]
T1[i]=T1[i+1]
Algorithme de la procédure remplir :
T1[i+1]=aux1
Procédure Remplir(@T:tab,@T2:tab2,n :entier)
aux2=T2[i]
Début
T2[i]=T2[i+1]
T2[i+1]= aux2
Répéter n=n-1
Ecrire("Nom ",i+1,"="), Lire(T2[i]) #programme principal
Jusqu’à vérif(T2[i])=vrai n=saisir()
Répéter remplir(T1,T2,n)
Ecrire("Note ",i+1,"="), Lire(T[i]) moy=moyenne(T1,n)
Jusqu’à 0<=T[i]<=20 M=maximum(T1,n)
Finpour tri_bulles(T1,T2,n)
Fin T.D.O.Locaux print('Liste triée:')
Objets Types/Nature afficher(T1,T2,n)
i Entier print('moy de la classe=',moy,'\nMeilleure note=',M)

verif fonction
Exercice 6: Les codes EAN 13 sont composés de 13 chiffres. Les deux ou trois premiers
chiffres de l'EAN indiquent dans quel pays l'entreprise est membre du système EAN.
Donner une implémentation en Python de l'algorithme suivant en utilisant la structure
conditionnelle à choix « Selon » :
Algorithme code une implémentation en Python:
Début code=int(input('code='))
Écrire ("code="), Lire (code) if code==619:
Si code=619 alors Message "Tunisie" message='Tunisie'
Sinon Si (code=600) OU (code=601) elif code==600 or code==601:
alors Message "Afrique de sud" message='Afrique de sud'
Sinon elif 450<=code<=459 or code==490:
si (code dans [450..459]) OU (code=490) message='Japon'
alors else:
Message "Japon" message='Autres'
Sinon Message "Autres" print('Le pays est: ',message)
FinSI
Écrire (''Le pays est : '', Message)
Fin T.D.O
Objet Type/Nature
code Entier
Message chaîne
Algorithme code une implémentation en python:
Début (pour python version >=3.10 sur Windows 10)
Écrire ("code="), Lire (code) code=int(input('code='))
Selon code
619 : Message "Tunisie" match code:
600,601: Message "Afrique de sud" case 619:
450..459,490:Message "Japon" message='Tunisie'
sinon Message "Autres" case 600 | 601:
FinSelon message='Afrique de sud'
Écrire (''Le pays est : '', Message) case code if 450<=code<=459 |490:
Fin T.D.O message='japon'
Objet Type/Nature case _ :
code Entier message=’autre’
Message chaîne print('Le pays est ',message)
Remarque: pour «selon» le sélecteur doit être de type scalaire
Exemples de déclarations de tableaux en Python:

Déclaration Explication
T = array ([5] * 10) Déclarer un tableau T de 10 entiers et initialiser ses éléments par « 5 ».
T = array ([float ()] * 10) Déclarer un tableau T de 10 réels et initialiser ses éléments par «0.0 ».
T = array ([str] * 10) Déclarer un tableau T de 10 chaînes de caractères.
T = array ([str()] * 10) Déclarer un tableau T de 10 caractères et initialisé par le caractère vide.
T = array ([‘’] * 10 , dtype = Déclarer un tableau T de 10 éléments initialisés par une chaîne vide. Chaque élément
’U20’) peut contenir 20 caractères au maximum
Les fonctions prédéfinies:
a. le type numérique b. le type caractère c. le type chaîne de caractères
En algorithmique En Python algorithmique Python algorithmique Python
Arrondi (x) round (x) ord (c) Ord (c) Long(ch) len(ch)
RacineCarré(x) sqrt (x) chr (d) Chr (d) Pos(ch1, ch2) ch2.find (ch1)
Aléa (vi, vf) randint(vi, vf) Convch(x) str (x)
Ent(x) int (x) Estnum(ch) ch.isdecimal()
Abs (x) abs (x) Valeur (ch) int (ch)|float(ch)
Remarques: Sous_chaine(ch, d, f) ch[d:f]
sqrt: nécessite import math Effacer (ch, d, f) ch=ch[:d ]+ch[f:]
randint: nécessite import random Majus(ch) ch.upper()
Pour concaténer deux chaînes de caractères, on utilise l’opérateur « + »
Exercice 4:
Modifier le programme de l’exercice 3, pour saisir un entier n entre (10 n PP
et 1000), remplir un tableau T par la décomposition en facteurs premiers
saisir T ,j T,n
de n enfin afficher la décomposition à partir de T. Pour résoudre ce n
problème, on va le décomposer en modules : Afficher_fact
Remplir_fact
Algorithme
Algorithme Décomposition: Paramètre effectif T=array([int()]*10)
DEBUT def afficher_fact(T,j):
for i in range(j):
Saisir(n) print(T[i],'x',end=' ')
Remplir_fact(T, i , n) Appel d’une
procédure print(T[j])
Afficher_fact(T,i) def remplir_fact(T,x):
FIN global j
Nouveaux Types i=2
TAB= tableau de 10 entiers j=-1
while x!=1:
T.D.O.globaux
if x % i==0:
Objet Type/Nature j=j+1
i,n Entier T[j]=i
T TAB x=x//i
Saisir, remplir_fact,afficher_fact Procédures else:
Algorithme de la procédure saisir : i=i+1
Procédure saisir(@n :entier) def saisir():
n=0
DEBUT
while not(10<=n<=1000) :
Répéter n=int(input('n à décomposer ?='))
Ecrire("Donner un entier (entre 10 et 1000)=") return n
lire(n) #programme principal
Jusqu’à n>=10 et n<=1000 n=saisir()
FIN remplir_fact(T,n)
Algorithme de la procédure rempli_fact : afficher_fact(T,j)
Procédure Remplir_fact(@T:tab, @ j:entier , x:entier)
DEBUT Passage Autre méthode :
from numpy import *
i2 j-1 par variable T=array([int()]*10)
Tantque x≠1 faire
Paramètre def afficher_fact(T,j):
si x mod i = 0 alors for i in range(j):
formel
jj+1 print(T[i],'x',end=' ')
T[j]i print(T[j])
def remplir_fact(T,x):
xx div i i=2
sinon i i+1 j=-1
Finsi while x!=1:
FinTantque if x % i==0:
Fin. j=j+1
T.D.O.Locaux T[j]=i
x=x//i
Objets Types/Nature else:
i Entier i=i+1
Algorithme de la procédure Afficher_fact : return j
Procédure afficher_fact(T :tab,j :entier) def saisir():
n=0
DEBUT
while not(10<=n<=1000) :
Pour i de 0 à j-1 faire
n=int(input('n à décomposer ?='))
Ecrire(T[i], "x") Passage return n
Finpour par valeur
Ecrire(T[j]) #programme principal
FIN n=saisir()
T.D.O.Locaux j=remplir_fact(T,n)
Objets Types/Nature afficher_fact(T,j)

i Entier

Exercices 3SC 2022 2023

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Exercices 3SC 2022 2023

Transféré par

Droits d'auteur :

Formats disponibles

Année 2022-2023-3ème Maths, Sciences et Techniques version 26 avril 2023 Matière : Informatique

Objectif 1 : Générer un entier x au hasard entre 1 et 100.

On va avoir la solution suivante :

Objectif 2 : Afficher un message contenant la question « Donner un entier entre 1 et 100

Prof:N.DHIFALLAH Page 1 / 33 Année scolaire 2022-2023

On va avoir la solution suivante :

Objectif 4 : On veut répéter la saisie d’un nombre et l’affichage du message correspondant

On va avoir la solution suivante :

Saisir une réponse n

On commence par générer 2 entiers (x et y) au hasard entre 0 et 10.

par importer la bibliothèque random

On va avoir la solution suivante :

On va avoir la solution suivante :

Prof:N.DHIFALLAH Page 4 / 33 Année scolaire 2022-2023

Pour bien s’entrainer sur la table de multiplication, on va répéter le jeu 5 fois.

Poi La boucle Pour

Prof:N.DHIFALLAH Page 5 / 33 Année scolaire 2022-2023

On veut afficher le n° d’essai :

Pour noter l’utilisateur on va

L’utilisateur doit s’identifier au début du

Prof:N.DHIFALLAH Page 7 / 33 Année scolaire 2022-2023

Prof:N.DHIFALLAH Page 8 / 33 Année scolaire 2022-2023

Implémenter l’algorithme en Python et l’envoyer sur Google Classroom

Projet 3: On veut faire la moyenne des notes d’une classe.

Exemple d’exécution : Nbre d’élèves=3

Prof:N.DHIFALLAH Page 9 / 33 Année scolaire 2022-2023

Objectif 2 : Ajouter une appréciation :

Implémenter l’algorithme en Python et l’envoyer sur Google Classroom

On va avoir la solution suivante :

Prof:N.DHIFALLAH Page 10 / 33 Année scolaire 2022-

La boucle Répéter jusqu’à

Prof:N.DHIFALLAH Page 11 / 33 Année scolaire 2022-

Projet 3: Rappel : On veut faire la moyenne des notes d’une classe.

Objectif 2 : Ajouter le calcul puis l’affichage de la meilleure note.

On va avoir la solution suivante :

Prof:N.DHIFALLAH Page 13 / 33 Année scolaire 2022-

Prof:N.DHIFALLAH Page 14 / 33 Année scolaire 2022-

Déclaration des objets

Prof:N.DHIFALLAH Page 15 / 33 Année scolaire 2022-

Prof:N.DHIFALLAH Page 16 / 33 Année scolaire 2022-

Jeu: Deviner l’ordre des chiffres

Prof:N.DHIFALLAH Page 17 / 33 Année scolaire 2022-

Prof:N.DHIFALLAH Page 18 / 33 Année scolaire 2022-

def saisir(): def saisir():

def remplir(T,n): def remplir(T,n):

def moyenne(T,n): def moyenne(T,n):

def maximum(T,n): def maximum(T,n):

#programme principal #programme principal

Prof:N.DHIFALLAH Page 19 / 33 Année scolaire 2022-

Objectif 2 : Modifier le programme principal et le module Remplir

Déclarer un tableau de caractère : Exemple d’exécution :

Algorithme de la procédure remplir : def maximum(T,n):

Prof:N.DHIFALLAH Page 20 / 33 Année scolaire 2022-

Objectif 3 : Modifier le programme principal et ajouter un

Déclarer un tableau de caractère :

Algorithme de la procédure Afficher : def maximum(T,n):

Exercice 1 : PGCD(Plus grand commun diviseur)

Exercice 3: (Décomposition en produit de facteurs premiers)

Prof:N.DHIFALLAH Page 22 / 33 Année scolaire 2022-

Objectif 4 : Ajouter un module Résultat pour afficher le rang , le nom et la

Prof:N.DHIFALLAH Page 26 / 33 Année scolaire 2022-

un caractère puis déterminer sa nature else: Fin Parcours inverse chaîne

Exercice 8: def verif(ch):