resume algo 2023.pdf

1 Pensée computationnelle et programmation (résumé) Prof : FENNI-S
1. La forme générale d’un algorithme
ALGORITHME Nom
DEBUT
Instruction 1
Instruction 2
Instruction N
FIN
N.B.
L’écriture de l’algorithme doit obligatoirement respecter l’indentation.
2. Les types de données simples
En Algorithmique En Python
Entier int()
Réel float ()
Booléen bool ()
Caractère str ()
Chaîne de caractères str ()
3. Déclaration des objets de type simple, en algorithmique
Tableau de déclaration des objets (T.D.O.)
Objets Type/Nature
Nom_Constante Constante = Valeur de la constante
Nom_Variable Type_Variable
Exemples :
T.D.O.
Objets Type/Nature
Pi
e
Heure
Moy
Phrase
Test
C
Constante = 3.14
Constante = 2.718
Entier
Réel
Chaîne de caractères
Booléen
Caractère
N.B.
En python, une variable n’a pas besoin d’être déclarée avec un type particulier : c’est au moment où on lui
attribue une valeur qu’elle sera créée. Ainsi, son type sera défini en fonction du type de la valeur qui lui a été
attribuée. L’identificateur d’une variable est sensible à la casse.
Pensée computationnelle &
Programmation
Définition :
Un algorithme est une suite ordonnée et
finie d’instructions permettant de résoudre
un problème donné.

4. Déclaration d’un tableau à une dimension
Déclaration en Algorithmique :
 1ère
méthode :
 2ème
méthode :
Tableau de déclaration des nouveaux types (T.D.N.T)
Nom_Type_Tableau = Tableau de taille et de type_éléments
Exemple : Tab = Tableau de 50 chaînes de caractères
Déclaration en Python en utilisant la bibliothèque Numpy :
Déclaration dans le cas général
from numpy import array
Nom_Tableau = array ([Type_élément( )] * N )
Ou bien
Nom_Tableau = array ([Valeur_initiale] * N )
Exemples de déclarations en python
Déclaration Explication
T = array ([int( )] * 8)
Déclarer un tableau T de 8 entiers
Pour une telle déclaration, on peut prévoir le tableau suivant :
T 45 13 -7 0 84 -3 34 2
0 1 2 3 4 5 6 7
T = array ([float( )] * 100)
Déclarer un tableau T de 100 réels
T = array ([str] * 50)
Déclarer un tableau T de 50 chaînes de caractères
T = array ([str()] * 10)
Déclarer un tableau T de 10 caractères et initialiser ses éléments
par le caractère vide.
T = array ([""] * 10 , dtype = "U20")
Déclarer un tableau T de 10 éléments initialisés par une chaîne
vide. Chaque élément peut contenir 20 caractères au maximum.
N.B. :
• L’indice de la 1ère case d’un tableau est, par défaut, égal à Zéro ;
• Pour accéder à un élément d’indice « i » d’un tableau : Nom_Tableau [ i ] ;
• Tous les éléments dans un numpy.array sont de même type (entier, réel, caractère,...) ;
• La taille du tableau est constante (il n’est pas possible d’insérer ou de supprimer un élément).
Tableau de déclaration des objets (T.D.O)
Objet Type/Nature
Nom_Tableau Tableau de taille et de type_éléments
Exemple : T Tableau de 100 réels
Tableau de déclaration des objets (T.D.O)
Objet Type/Nature
Nom_Tableau Nom_Type_Tableau
Exemple : T Tab

5. Les opérateurs arithmétiques
Opération
Opérateur en
algorithmique
Opérateur en
python
Exemples Type du résultat
Addition + +
6 + 4.5 = 10.5
"BA" + "C" = "BAC"
Réel
Soustraction - - 6 - 4 = 2 Entier
Multiplication * *
6 * 4 = 24
1.2 * 3 = 3.6
3 * "AB" = "ABABAB"
Entier
Réel
Division / / 6 / 4 = 1.5 Réel
Division entière DIV // 6 // 4 = 1 Entier
Reste de la
division entière
MOD % 6 % 4 = 2 Entier
6. Les opérateurs logiques
Opération
Opérateur en
algorithmique
Opérateur en
python
Exemples en Python
Négation non not
not True = False
not False = True
Conjonction et and
True and False = False
True and True = True
False and False = False
Disjonction ou or
True or False = True
False or False = False
True or True = True
7. Les opérateurs de comparaisons
Tout comme les opérateurs logiques, les opérateurs de comparaison renvoient une valeur booléenne
"Vrai" ou "Faux". Les opérateurs de comparaisons s'appliquent sur tous les types de base.
Opération
Opérateur en
algorithmique
Opérateur en
python
Exemples
en Python
Résultats
Egal = = = 6 = = 6.0 True
Différent ≠ != "a" != "A" True
Strictement supérieur > > "FAMILLE"> "FAMILY" False
Strictement inférieur < < 5 < 5 False
Inférieur ou égal ≤ <= 4 <= 6 True
Supérieur ou égal ≥ >= 3 >= 4 False
Appartient
(entier, caractère)
in
20 in range(0,10)
"b" in {"a","b","e","k"}
False
True
Remarques :
• Lors de l’évaluation d’une expression, il faut tenir compte des règles de priorité entre les opérateurs
utilisés :
En algorithmique En Python
1) les parenthèses (…) (…)
2) les opérateurs unaires - (l'opposé) ; NON - ; not
3) les opérateurs multiplicatifs * ; / ; DIV ; MOD ; ET * ; / ; // ; % ; and
4) les opérateurs additifs + ; - ; OU + ; - ; or
5) les opérateurs relationnels = ; < ; <= ; > ; >= ; ≠ ; = ; < ; <= ; > ; >= ; != ; in
• Deux opérateurs ayant la même priorité, doivent être évalués de gauche à droite.

8. Les fonctions prédéfinies sur les types arithmétiques
Algorithmique Python Rôles Exemples en Python
NArrondi (x) N = round (x)
Retourne l’entier le plus proche
de x
N = round (3.5)  N=4
N = round (2.5)  N=2
N = round (2.8)  N=3
N = round (2.2)  N=2
NRacineCarré (x)
from math import*
N = sqrt (x)
Retourne la racine carrée de x
N = sqrt (25)  N=5
N = sqrt(-4)  Erreur
NAléa (vi, vf)
from random import*
N = randint (vi, vf)
Retourne un entier aléatoire de
l’intervalle [vi, vf]
N = randint (2,5)
N pourra avoir 2 ou 3 ou 4 ou 5
NEnt (x) N = int (x) Retourne la partie entière de x N = int (4.25)  N=4
NAbs (x) N = abs (x) Retourne la valeur absolue de x N = abs (-5)  N=5
9. Les fonctions prédéfinies sur les chaînes de caractères
Algorithmique Python Rôles Exemples en python
L  Long (ch) L=len (ch)
Retourne le nombre de
caractères de la chaîne ch
L = len("L'informatique")
 L = 14
P  Pos (ch1, ch2) P=ch2.find (ch1)
Retourne la première
position de la chaîne ch1
dans la chaîne ch2
ch = 'Bonjour'
x = ch.find ('o')  x = 1
y = ch.find ('no')  y = -1
ch  Convch (x) ch=str (x)
Retourne la conversion d’un
nombre x en une chaîne
ch = str (17.2)  ch = '17.2'
test  Estnum (ch)
test=ch.isdecimal ()
Ou bien
test=ch.isnumeric ()
Retourne Vrai si la chaîne ch
est convertible en une
valeur numérique, elle
retourne Faux sinon
ch = "154"
test = ch.isdecimal ()
 test = True
ch = "9ab3"
test = ch.isdecimal()
 test = False
N  Valeur (ch)
N=int(ch)
Ou bien
N=float(ch)
Retourne la conversion
d’une chaîne ch en une
valeur numérique, si c’est
possible
x = int ("12")  x = 12
y = float ("13.25")  y = 13.25
ch1  Sous_chaîne (ch, d, f) ch1=ch [d : f]
Retourne une partie de la
chaîne ch à partir de la
position d jusqu’à la position
f (f exclue)
ch = "Bonjour"
• ch1 = ch [0:3]
 ch1 = 'Bon'
• ch2 = ch [3:len(ch)]
 ch2 = 'jour'
ch  Effacer (ch, d, f) ch=ch [ : d] + ch [f : ]
Efface des caractères de la
chaîne ch à partir de la
position d jusqu’à la position
f (f exclue)
ch = "Bonjour"
• ch = ch [:1] + ch[4:]
 ch = 'Bour'
• ch = ch [:0] + ch[3:]
⇔ ch = ch [3:]  ch = 'jour'
• ch = ch [:3] + ch[len(ch):]
⇔ ch = ch [:3]  ch = 'Bon'
ch  Majus (ch) ch=ch.upper( )
Convertit la chaîne ch en
majuscule
ch = "jour"
ch = ch.upper()  ch = 'JOUR'
c = "a".upper()  c = 'A'

10. Les fonctions prédéfinies sur les caractères
Algorithmique Python Rôles Exemples en python
Cod  Ord (c) Cod = ord (c) Retourne le code ASCII du caractère c Cod = ord("A") Cod= 65
Car  Chr (d) Car = chr (d) Retourne le caractère dont le code ASCII est d Car = chr(98) Car= 'b'
11. Les actions élémentaires simples
Actions En algorithmique En Python
L’action
d’affectation
Objet  Expression Objet = Expression
Exemples :
• a  2
• b  5 + a * a
• ville  "La chebba"
Exemples :
• a = 2
• b = 5 + a * a
• ville = "La chebba"
L’action
d’entrée
Lire (Objet) Objet = input()
N.B. : Par défaut, la valeur saisie est de type
chaîne de caractères.
Exemples :
• Ecrire ("saisir une chaîne"), Lire (ch)
• Ecrire ("saisir un entier"), Lire (n)
• Ecrire ("saisir un réel"), Lire (x)
Exemples :
• ch = input ("saisir une chaîne n")
• n = int (input ("saisir un entier"))
• x = float (input ("saisir un réel"))
L’action
de sortie
• Ecrire ("message", objet, expression) • print ("message", objet, expression)
Exemples :
• Ecrire ("Saisir un entier : ")
• Ecrire ("Les notes : ", n1, n2, n3)
• Ecrire ( 5 + 4 * 2 )
• Ecrire_nl()
Exemples :
• print ("Saisir un entier : ", end="")
• print (" Les notes :", n1, n2, n3, sep="n")
• print ( 5 + 4 * 2 )
• print() # ligne vide avec retour à la ligne
Remarques :
- Objet est une variable de type simple (entier, réel, booléen, caractère et chaîne de caractères).
- « print » fait un retour à la ligne automatique.
- "n" permet d’ajouter un retour à la ligne.
- Le paramètre « end="" » évite le retour à la ligne.
- Le paramètre « sep="n" » permet d'afficher les valeurs de manière séparée par une nouvelle ligne.
12. Les structures de contrôle conditionnelles
12.1La structure conditionnelle simple
Notation Algorithmique Notation en Python
Si Condition
Alors Traitement
FinSi
if Condition :
Traitement

12.2La structure conditionnelle complète
Si Condition
Alors Traitement1
Sinon Traitement2
FinSi
if Condition :
Traitement1
else :
Traitement2
12.3La structure conditionnelle généralisée (Si imbriquée)
Si Condition1
Alors Traitement1
Sinon Si Condition2
Alors Traitement2
Sinon Si Condition3
Alors Traitement3
Sinon TraitementN
FinSi
if Condition1 :
Traitement1
elif Condition2 :
Traitement2
elif Condition3 :
Traitemnt3
else :
TraitementN
12.4La structure conditionnelle à choix multiples
Notation Algorithmique Notation en Python (Version ≥ 3.10)
Selon Sélecteur
Val1 : Traitement1
Val2, Val3, Val4 : Traitement2
Val5 .. Val9 : Traitement3
…
Sinon TraitementN
FinSelon
match Sélecteur :
case Val1 : Traitement1
case Val2|Val3|Val4 : Traitement2
case Sélecteur if Val5 <= Sélecteur <= Val9 : Traitemnt3
case_ : TraitementN

13. Les structures de contrôle itératives
13.1 La structure de contrôle itérative complète (La boucle POUR … FAIRE …)
Syntaxe en algorithmique Syntaxe en Python
Pour Compteur de Début à Fin [Pas = valeur_pas] Faire
Traitement
Fin Pour
for Compteur in range (Début, Fin+1 [, pas]) :
Traitement
Remarques :
• Le nombre de répétitions est connu avant le
traitement et il est égal à |Fin – Début |+ 1.
• Le Pas peut être Positif ou Négatif.
• Par défaut, le Pas est égal à 1.
• Il faut éviter de modifier la valeur du compteur de la
boucle Pour au niveau du traitement.
• range (5) le compteur prendra les valeurs
suivantes : 0, 1, 2, 3, 4
• range (3, 8) le compteur prendra les
valeurs suivantes : 3, 4, 5, 6, 7
• range (8, 3, -1) le compteur prendra les
valeurs suivantes : 8, 7, 6, 5, 4
• range (0, 10, 3) le compteur prendra les
valeurs suivantes : 0, 3, 6, 9
13.2 La structure de contrôle itérative à condition d’arrêt (La boucle TANT QUE … FAIRE …)
Initialisation
Tant que Condition Faire
Traitement
Fin tant que
Initialisation
while Condition :
Traitement
Exemple
som  0
Tant que som < 100 Faire
Ecrire ("Donner un entier"), Lire (x)
Som  som + x
Fin tant que
Exemple
som = 0
while som < 100 :
x = int (input ('Donner un entier'))
som = som + x
Remarque : Le nombre de répétitions n’est pas connu à l’avance et le traitement peut ne pas se faire.
13.3 La structure de contrôle itérative à condition d’arrêt (REPETER … JUSQU’A …)
Répéter
Traitement
Jusqu’à Condition d’arrêt
Pas de correspondance. Toutefois, on peut utiliser :
valide= False
while not valide : # while valide==False :
Traitement
valide = Condition d’arrêt
Exemple
Répéter
Ecrire ("Donner un entier positif ")
Lire(x)
Jusqu’à x>0
Exemple
valide=False
while not valide :
x = int (input ('Donner un entier positif'))
valide= x>0
Remarque : Le nombre de répétitions n’est pas connu à l’avance et le traitement se fait au moins une fois.

14.Les modules
14.1. Les fonctions
14.1.1. La définition d’une fonction
Une fonction est un sous-programme qui permet la résolution d’un sous-problème précis et retourne (renvoie)
un seul résultat de type simple (entier, caractère, réel, booléen, chaîne) au programme appelant.
FONCTION Nom_fonction (pf1:type1, …, pfn:typen) : Type_Résultat
DEBUT
Instruction 1
Instruction 2
Instruction N
Retourner Résultat
FIN
def Nom_fonction ( pf1 , … , pfn ) :
Instruction 1
Instruction 2
Instruction N
return Résultat
14.1.2. L’appel d’une fonction
Objet  Nom_fonction (pe1, …, pen) Objet = Nom_fonction (pe1, …, pen)
Exemples, pour de fonctions prédéfinies
• Ch2  Majus(ch)
• Si Pos (ch1, ch2) ≠ 0 Alors ............
• y  5 * RacineCarré(x+3)
• Ecrire (Long(ch))
• Ch2 = ch.upper()
• if ch2.find(ch1) !=0 : …………………
• y = 5 * sqrt (x+3)
• print ( len(ch))
N.B.
Les paramètres effectifs (pe1,…, pen) et les paramètres formels (pf1, …, pfn) doivent s’accorder de point
de vue ordre, nombre et type.
14.2. Les procédures
14.2.1. La définition d’une procédure
Une procédure est un sous-programme qui permet la résolution d’un sous-problème précis et qui peut
transmettre de zéro à plusieurs résultats au programme appelant.
14.2.2. L’appel d’une procédure
Nom_procédure (pe1, …, pen) Nom_procédure (pe1, …, pen)
Exemples, pour de procédures prédéfinies
Lire (x)
Ecrire (a, b)
x = input()
print(a, b)
PROCEDURE Nom_procédure (pf1 : type1, …, pf2 : typen)
Début
Instruction 1
Instruction 2
Instruction N
Fin
def Nom_procédure (pf1, …, pfn) :
Instruction 1
Instruction 2
Instruction N

N.B. :
 Le passage de paramètres par adresse (par référence) permet au programme appelant (PP) de
transmettre une valeur à la procédure appelée (SP) et vice versa. Dans ce cas, le paramètre formel est
précédé par le symbole « @ ». Par exemple : PROCEDURE TRAITEMENT( c : Réel ; @ a, b :Entier).
 Toute modification d'un paramètre formel dans le sous-programme appelé entraîne
(automatiquement) au moment du retour à l'appelant une modification de la valeur du paramètre
effectif correspondant.
 En python, le paramètre de type tableau est par défaut passé par référence.
 La portée des variables en python :
• Toute variable déclarée au sein d’un module a une portée locale.
• Toute variable déclarée au sein d’un module précédée par le mot clé global a une portée globale.
Par conséquent, elle ne devra pas figurer parmi les paramètres de ce module.
L’exemple ci-dessous illustre le passage par adresse en algorithmique et en Python.
En algorithmique
Déclaration de la procédure "Saisir" L’appel de la procédure "Saisir"
Procédure Saisir (@ m : Entier)
Début
Répéter
Ecrire ("Saisir un entier entre 5 et 20")
Lire (m)
Jusqu’à (5 ≤ m ≤ 20)
Fin
Saisir (n)
En Python (1ère
démarche)
def Saisir () :
global m
valide = False
while not valide :
m = int (input ("Saisir un entier entre 5 et 20"))
valide = (5 <= m <= 20)
Saisir ()
n = m
En Python (2ème
démarche)
def Saisir () :
valide = False
while not valide :
m = int (input ("Saisir un entier entre 5 et 20"))
valide = (5 <= m <= 20)
return m
n = Saisir ()
Paramètre formel
Paramètre effectif

Problème : Remplir puis afficher un tableau T par N entiers (avec 5 ≤ n ≤ 10)
Exemple d’une solution modulaire
# Algorithme du programme principal
ALGORITHME Exemple
DEBUT
Saisie (N)
Remplir (N, T)
Affichage (N, T)
FIN
T.D.N.T.
Type
TAB = Tableau de 10 entiers
Tableau de déclaration des objets globaux
Objet Type/nature
N Entier
T TAB
Saisie Procédure
Remplir Procédure
Affichage Procédure
# Algorithme de la procédure Saisie
PROCEDURE Saisie ( @ m : Entier )
Début
Répéter
Ecrire ("Donner un entier entre 5 et 10")
Lire (m)
Jusqu’à (5 ≤ m ≤ 10)
Fin
# Algorithme de la procédure Remplir
PROCEDURE Remplir ( m : Entier ; @ V : TAB )
Début
Pour i de 0 à m-1 Faire
Ecrire ("T[",i,"]=")
Lire (V[i])
Finpour
Fin
T.D.O. locaux
Objet Type/Nature
i Entier
# Algorithme de la procédure Affichage
PROCEDURE Remplir ( m : Entier ; V : TAB )
Début
Pour i de 0 à m-1 Faire
Ecrire (V[i])
Finpour
Fin
T.D.O. locaux
Objet Type/Nature
i Entier
T = array ([int()]*10)
def Saisie () :
valide = False
while not valide :
m = int(input("Donner un entier entre 5 et 10"))
valide = (5<=m<=10)
return m
def Remplir (m, V) :
for i in range(m) :
V[i]= int(input("T["+str(i)+"]="))
def Affichage (m, V) :
for i in range(m) :
print(V[i], end=" ")
#Programme principal
N = Saisie ()
Remplir (N, T)
Affichage (N, T)

Les modules usuels
Les procédures
Algorithme Python Appel
# Saisir un entier positif
Procédure Saisir (@ x : entier)
Début
Répéter
Ecrire ("Donner un entier positif ")
Lire(x)
Jusqu’à x ≥ 0
Fin
def Saisir () :
global x
valide = False
while not valide :
x = int(input ("Donner un entier positif "))
valide = (x >= 0)
algorithme
Saisir(n)
python
Saisir()
n = x
def Saisir () :
valide = False
while not valide :
x = int(input ("Donner un entier positif "))
valide = (x >= 0)
return x
algorithme
Saisir(n)
python
n = Saisir()
# Saisir une chaîne de caractères formée uniquement de lettres majuscules
Procédure Saisie (@ ch : Chaîne)
Début
Répéter
Ecrire ("Saisir une chaîne "), Lire(ch)
i← 0
verif←Vrai
Tant que (verif=Vrai) ET (i ≠long(ch)) Faire
Si non (ch[i]∈["A".."Z"])
Alors verif ← Faux
Finsi
i ← i+1
Fin Tant que
Jusqu’à verif = Vrai
Fin
TDOL
objet type/nature
i Entier
def Saisir() :
verif = False
while verif ==False :
ch=input("Saisir une chaîne")
i=0
verif=True
while (verif==True) and (i != len(ch)) :
if not ("A" <= ch[i] <= "Z") :
verif=False
i=i+1
return ch
algorithme
Saisir(ch)
python
ch=Saisir()
# Remplir un tableau T par N entiers en ordre croissant (avec 10 ≤ N ≤ 100)
Procédure remplir (@ T : tab ; n : entier)
Début
Ecrire ("T[0] : "), Lire(T[0])
Pour i de 1 à (n-1) Faire
Répéter
Ecrire ("T[", i, "] : "), Lire(T[i])
Jusqu’à T[i] > T[i-1]
Fin Pour
Fin
TDOL
objet type/nature
i Entier
V = array( [int()]*100)
def remplir (T, n) :
T[0] = int(input("T[0] :"))
for i in range (1, n) :
while T[i] <= T[i-1] :
T[i] = int(input("T["+ str(i) + "] :"))
algorithme
remplir (V, n)
python
remplir(V, n)

# Remplir un tableau T par N entiers de deux chiffres
Procédure remplir (@ T : tab ; n : entier)
Début
Pour i de 0 à n-1 Faire
Répéter
Ecrire ("T[ ", i, "] =" )
Lire(T[i])
Jusqu’à (10 ≤ T[i] ≤ 99)
FinPour
Fin
TDOL
objet type/nature
i Entier
V = array( [int()]*100)
def remplir (T, n) :
for i in range(n) :
valide = False
while not valide :
T[i] = int (input ("T["+ str(i) + "]="))
valide = (10<=T[i] <=99)
algorithme
remplir (V, n)
python
remplir(V, n)
# Remplir un tableau T par N entiers distincts
Procédure Saisie (n : Entier ; @ T : Tab)
Début
Répéter
Ecrire (''Saisir la case '', i), Lire (T[i])
j ← 0
Tant que T[i] ≠ T[j] Faire
j← j+1
Fin Tant que
Jusqu’à (j = i)
Fin Pour
Fin
V = array( [int()]*100)
def Saisie (n, T) :
for i in range(n) :
verif = False
while not verif :
T[i] = int(input("Saisir la case"+ str(i)))
j=0
while T[i] != T[j] :
j=j+1
verif = (i==j)
algorithme
Saisie (n, V)
python
Saisie (n, V)
# Remplir un tableau T par N entiers au hasard entre [a, b]
Procédure Remplir (@ t : Tab ; n, a, b : Entier)
Début
t[i] ← Aléa (a, b)
Fin Pour
Fin
Une lettre majuscule au hazard
t[i] ← chr (65+ Aléa(0, 25))
v = array( [int()]*100)
def Remplir (t, n, a, b) :
from random import randint
for i in range(n) :
t[i] = randint (a, b)
Une lettre majuscule au hazard
t[i] = chr (65+ randint(0, 25))
algorithme
Remplir (v, n,
a, b)
python
Remplir (v, n,
a, b)
# Affichage d’un tableau T de N éléments
Procédure afficher (T: tab ; n : entier)
Début
Ecrire (T[i])
FinPour
Fin
…………………………
v = array( [int()]*100)
def afficher (T, n) : …
for i in range(n) : …
print (T[i], end=" ")
……
algorithme
afficher (v, n)
python
afficher (v, n)

# Ranger les valeurs négatifs d’un tableau T à gauche et les valeurs positifs à droite
Procédure Ranger (@ t : tab ; n : entier)
Début
k ← 0
Si t[i] < 0
Alors aux ← t[i]
t[i] ← t[k]
t[k] ← aux
k ← k +1
Fin Si
Fin Pour
Fin
TDOL
objet type/nature
i, k Entier
v = array( [int()]*100)
def Ranger (t, n) :
k=0
for i in range(n) :
if t[i] < 0 :
aux = t[i]
t[i] = t[k]
t[k] = aux
k = k +1
algorithme
Ranger (v, n)
python
Ranger (v, n)
# Transférer les éléments pairs d’un tableau T, dans T1 et les impairs dans T2
Procédure Transfert (t : tab ; n : entier ; @ t1, t2 : tab ;
@ c1, c2 : entier)
Début
c1 ← 0 ; c2 ← 0
Si t[i] mod 2 = 0
Alors c1← c1 +1
t1[c1] ←t[i]
Sinon c2← c2 +1
t2[c2] ← t[i]
Fin Si
Fin Pour
Fin TDOL
objet type/nature
i Entier
v = array( [int()]*100)
v1 = array( [int()]*100)
v2 = array( [int()]*100)
def Transfert (t, n, t1, t2) :
c1=0 ; c2=0
for i in range (n) :
if t[i] % 2 == 0 :
t1[c1] = t[i]
c1 = c1 +1
else :
t2[c2] = t[i]
c2 = c2 +1
return c1, c2
algorithme
Transfert (v,
m, v1, v2, k1,
k2)
python
k1, k2 =
Transfert (v,
m, v1, v2)
# Permutation de deux variables
Procédure Permut (@ a, b : Réel)
Début
aux ← a
a ← b
b ← aux
Fin
TDOL
objet type/nature
aux Réel
def Permut(a,b) :
aux = a
a = b
b = aux
return a, b
algorithme
Permut (x, y)
python
x,y =
Permut(x,y)
# Insertion d’un élément X dans un tableau T à une position p
Procédure Insertion (@ t : tab ; n, x, p : entier)
Début
Pour i de n à (p-1) [pas=-1] Faire
t[i] ← t[i-1]
Fin Pour
t[p] ← x
Fin
v = array( [int()]*100)
def Insertion (t, n, x, p) :
for i in range (n, p-1, -1) :
t[i] = t[i-1]
t[p]=x
algorithme
Insertion (v, n,
x, p)
python
Insertion (v, n,
x, p)

Les fonctions
Algorithme Python Appel
# PGCD de 2 entiers (méthode de la différence)
Fonction PGCD (a, b : entier) : entier
Début
Tant que (a ≠ b) Faire
Si a > b
Alors a ← a-b
Sinon b ← b-a
FinSi
Fin Tant que
Retourner a
Fin
def PGCD (a, b ) :
while (a != b) :
if a > b :
a = a-b
else :
b = b-a
return a
algorithme
pg ← PGCD (x, y)
python
pg = PGCD (x, y)
# PGCD de 2 entiers (méthode d’Euclide)
Fonction PGCD (a, b : entier) : entier
Début
Tant que (b ≠ 0) Faire
r ← a mod b
a ← b
b ← r
Fin Tant que
Retourner a
Fin
def PGCD (a, b ) :
while (b != 0) :
r = a % b
a = b
b = r
return a
# PPCM de 2 entiers
Fonction PPCM ( a, b : entier) : entier
Début
i ← 1
Tant que ((a*i) mod b) ≠ 0 Faire
i ← i + 1
Fin Tant que
Retourner (a*i)
Fin
def PPCM (a, b ) :
i = 1
while ((a*i) % b) != 0 :
i = i + 1
return (a*i)
algorithme
pp ← PPCM (x, y)
python
pp = PPCM (x, y)
# Calcul de Xn
Fonction puissance(x, n : entier) : réel
Début
p←1
Pour i de 1 à abs(n) Faire
p←p*x
FinPour
Si n<0
Alors p ←1/ p
FinSi
Retourner p
Fin
def puissance (x, n ) :
p=1
for i in range(abs(n)) :
p = p * x
if n<0 :
p = 1/p
return p
algorithme
ps ← puissance(x, n)
python
ps = puissance(x, n)
# Factoriel d’un entier N (N! = 1*2*3*…*n)
Fonction fact (n : entier) : entier ……
Début
f ← 1
Pour i de 2 à n Faire
f ← f*i
FinPour
Retourner f
Fin
def fact (n ) :
f=1
for i in range (2, n+1) :
f = f * i
return f
algorithme
x ← fact(n)
python
x = fact(n)

# Vérifier si un nombre est premier (le nombre de ses diviseurs =2)
Fonction premier (n : entier) : booléen
Début
nb ← 1
Pour i de 1 à (n div 2) Faire
Si (n mod i) = 0
Alors nb ← nb + 1
FinSi
FinPour
Retourner nb = 2
Fin
def premier (n) :
nb=1
for i in range(1, (n//2)+1) :
if n % i == 0 :
nb = nb + 1
return nb == 2
algorithme
ok ← premier(n)
python
ok = premier(n)
# Méthode2 : vérifier s’il y a un diviseur de n dans l’intervalle [2, (n div 2)]
Fonction premier (n : entier) : booléen
Début
i ← 2
verif ← Vrai
Tant que verif ET (i <= n div 2) Faire
Si (n mod i) = 0
Alors verif ← Faux
Sinon i ← i + 1
FinSi
Fin Tant que
Retourner verif
Fin
def premier(n):
i=2
verif=True
while verif and (i <= n // 2):
if (n % i == 0):
verif=False
else:
i=i+1
return verif
algorithme
ok ← premier(n)
python
ok = premier(n)
# Vérifier si un nombre est parfait ( n = somme de ses deviseurs sauf lui-même. exp : 6=1+2+3)
Fonction parfait (n : entier) : booléen
Début
s ← 0
Pour i de 1 à (n div 2) Faire
Si (n mod i) = 0
Alors s ← s + i
FinSi
FinPour
Retourner s = n
Fin
def parfait (n) :
s=0
for i in range(1, n//2+1) :
if (n%i) == 0 :
s = s + i
return s == n
algorithme
ok ← parfait(n)
python
ok = parfait(n)
# Calcul de la somme S = 1+2+3+4+…+N
Fonction Somme (n : entier) : entier
Début
S ← 0
S ← S + i
Fin Pour
Retourner S
Fin
def Somme(n) :
S= 0
for i in range(1, n+1) :
S = S + i
return S
algorithme
som ← Somme(n)
python
som = Somme(n)
# Calcul de la somme S = 1-2+3-4+…+(-1)n+1
N
Fonction Somme (n : entier) : entier
Début
S ← 0 ; signe←1
S ← S + signe*i
signe ← -1
Fin Pour
Retourner S
Fin
def Somme(n) :
S= 0 ; signe=1
for i in range(1, n+1) :
S = S + signe * i
signe= -1
return S
algorithme
som ← Somme(n)
python
som = Somme(n)

# La somme de chiffres d’un entier
Fonction Som_chiff (n : entier) : entier
Début
S ← 0
Répéter
R ← n mod 10
S ← S + R
n ← n div 10
Jusqu’à (n = 0)
Retourner S
Fin
Solution 2 :
Fonction Som_chiff (n : entier) : entier
Début
C ← Convch(n)
S ← 0
Pour k de 0 à long(C)-1 Faire
S ← S + Valeur(C[k])
Finpour
Retourner S
Fin
def Som_chiff (n) :
S= 0
Valide = False
while not Valide :
R = n % 10
S = S + R
n = n // 10
Valide = (n==0)
return S
Solution 2 :
def Som_chiff (n) :
C=str(n)
S=0
for k in range (0, len(C)) :
S = S + int(C[k])
return S
algorithme
som ← Som_chiff(n)
python
som = Som_chiff(n)
# Décomposition d’un nombre en un produit de facteurs premiers ( exp : 36=2*2*3*3)
Fonction fact_premier (n : entier) : chaine
Début
ch←""
i←2
Tant que (n ≠ 1) Faire
Si n mod i = 0
Alors ch ← ch + convch(i) + "*"
n ← n div i
Sinon i ← i+1
FinSi
FinPour
Retourner Sous_chaine (ch, 0, long(ch)-1)
Fin
def fact_premier (n) :
ch = ""
i = 2
while (n != 1) :
if (n % i) == 0 :
ch = ch + str(i) + "*"
n = n // i
else :
i = i + 1
return ch[0 : len(ch)-1]
# La moyenne de n entiers dans un tableau T
Fonction Moyenne (T : tab ; n : entier) : réel
Début
Som← 0
Som ← Som + T[i]
Fin Pour
Retourner Som/n
Fin
v = array( [int()]*100)
def Moyenne(T, n) :
Som= 0
for i in range(n) :
Som = Som + T[i]
return Som/n
solution 2
def Moyenne(T) :
Som= 0
for i in T :
Som = Som + i
return Som/len(T)
algorithme
moy ←Moyenne(v, n)
python
moy = Moyenne(v, n)
solution 2
moy = Moyenne(v)

# Miroir (symétrique) d’un entier
Fonction Miroir (x : entier) : entier
Début
sym ← 0
Répéter
u ← x mod 10
sym ← sym * 10 + u
x ← x div 10
Jusqu’à x=0
Retourner sym
Fin
def Miroir (x) :
sym = 0
while (x != 0) :
u = x % 10
sym = sym * 10 + u
x = x // 10
return sym
# Vérifier si une chaîne est palindrome (exp : "AZIZA")
Fonction Palindrome (ch : chaîne) : Booléen
Début
i ← 0
Répéter
verif ← ch[i] = ch[long(ch) - i -1 ]
i ← i+1
Jusqu’à (verif=faux) ou (i = long(ch) div 2)
Retourner verif
Fin
def Palindrome (ch) :
i = 0
verif = True
while verif and (i != len(ch) // 2):
verif = (ch[i] == ch[len(ch) - i -1])
i=i+1
return verif
# Vérifier si une chaîne de caractères contient uniquement des lettres
Fonction verif (ch : chaine) : booléen
Début
i ← 0
valide←Vrai
Répéter
Si non("A" ≤ Majus(ch[i]) ≤ "Z")
Alors valide←Faux
Finsi
i ← i+1
Jusqu’à (valide=Faux) ou (i = long(ch))
Retourner valide
Fin
def verif (ch ) :
valide = True
i = 0
while (valide==True) and (i!=len(ch)) :
if not ("A" <= ch[i].upper() <= "Z"):
valide=False
i = i + 1
return valide
# Recherche de la première valeur minimum dans un tableau de n réels
Fonction minimum (t : tab ; n : entier) : réel
Début
min ← t[0]
Si t[i] < min
Alors min ← t[i]
FinSi
FinPour
Retourner min
Fin
v = array( [float()]*100)
def minimum (t, n) :
min = t[0]
for i in range (1, n) :
if t[i] < min :
min = t[i]
return min
algorithme
mini ←
minimum(v,n)
python
mini = minimum(v,n)

# Recherche de la dernière position d’un élément X dans un tableau de n réels
Fonction Recherche (x : réel ; n : entier ; t : tab) : entier
Début
p ← -1 ; i ← n
Répéter
i ← i - 1
Si t[i] = x
Alors p ← i
FinSi
Jusqu’à (p ≠ -1) OU (i = 0)
Retourner p
Fin
v = array( [float()]*100)
def Recherche (x, n, t) :
p = -1
i = n
valide=False
while not valide :
i = i - 1
if t[i] == x :
p = i
valide = (p != -1) or (i==0)
return p
algorithme
pos ←
Recherche(x, n, v)
python
pos =
Recherche(x, n, v)
# Fréquence d’un élément X dans un tableau de N entiers
Fonction frequence (x:entier ; t:tab ; n:entier) : entier
Début
nb ← 0
Si t[i] = x
Alors nb ←nb + 1
FinSi
FinPour
Retourner nb
Fin
v = array( [int()]*100)
def frequence (x, t, n) :
nb = 0
for i in range(n) :
if t[i] == x :
nb = nb + 1
return nb

resume algo 2023.pdf

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à resume algo 2023.pdf

Similaire à resume algo 2023.pdf (20)

resume algo 2023.pdf