2023

Fiche de Révision En Informatique

Muḥammad ibn Mūsā al-Khwārizmī

Sections :
Mathématiques, Sciences Expérimentales, Sciences Techniques.

Anis Ben Nacib

 Fiche de Révision ::: Informatique

Les traitements récurrents et arithmétiques

Fonction qui permet de calculer la somme des chiffres un entier strictement positif x.
fonction somme_chiffres(x : entier) : entier def somme_chiffres(x):
Début ch = str(x)
Ch ← Convch (x) s = 0
S ← 0 for i in range(len(ch)):
Pour i de 0 à Long(Ch)-1 faire s = s + int(ch[i])
S ← S + Valeur (Ch[i]) return s
finPour
Retourner S
Fin
Fonction qui permet de calculer la somme des diviseurs d'un entier strictement positif x (x non inclus).
fonction somme_diviseurs(x : entier) : entier def somme_diviseurs(x):
Début S = 0
S ← 0 for d in range(1,x//2+1):
Pour d de 1 à x div 2 faire if x % d == 0:
Si x mod d = 0 alors S = S + d
S ← S + d return S
finSi
finPour
Retourner S
Fin
Fonction qui permet de calculer la factorielle d'un entier strictement positif n.
fonction Factorielle (n: entier) : entier def factorielle(n): non inclus
Début F = 1
F ← 1 for i in range(2,n+1):
Pour i de 2 à n faire F = F * i
F ← F * i return F N! = 1*2*3*….*(N-1)*N
fin Pour
Retourner F 5! = 1*2*3*4*5
Fin
Fonction qui permet de calculer la puissance xn de deux entiers positifs x et n.
fonction Puissance(x,n: entier) : entier def Puissance(x,n): non inclus
Début P = 1
P ← 1 for i in range(1,n+1):
Pour i de 1 à n faire P = P * x
P ← P * x return P Xn = X*X*X*….*X
fin Pour
n fois
Retourner P
Fin
Fonction qui permet de calculer le PGCD de deux entiers positifs non nuls a et b.
fonction PGCD(a,b: entier) : entier def PGCD(a,b):
Début while a!=b:
tant que (a ≠ b) faire
if a>b:
si a > b alors
a ← a - b a = a - b
sinon else:
b ← b - a b = b - a
finSi return a
fin Tant que
Retourner a
Fin
A.S 2022-2023 1 Anis Ben Nacib
 Fiche de Révision ::: Informatique

Fonction qui permet de calculer le PGCD de deux entiers positifs non nuls a et b. (Méthode d'Euclide)
fonction PGCD_Euclide(a, b: entier) : entier def PGCD_Euclide(a,b):
Début while b!=0:
Tant que (b ≠ 0) faire
r = a % b
r ← a mod b
a = b
a ← b
b ← r b = r
fin Tant_que return a
Retourner a
Fin
Fonction qui permet de calculer le PPCM de deux entiers positifs a et b.
fonction PPCM(a,b: entier) : entier def PPCM(a,b):
Début
if a>b:
Si a > b alors
max ← a max, min = a, b
min ← b else:
sinon max, min = b, a
max ← b while max % min != 0:
min ← a
max = max + (a + b - min)
finSi
return max
Tant que (max mod min ≠ 0) faire
max ← max + (a + b - min)
fin Tant_que
Retourner max
Fin
Fonction qui permet de tester de tester la primalité d'un entier strictement supérieur à 1(Premier ou non).
NB. Un nombre premier est donc un nombre dont ses seuls diviseurs sont 1 et lui-même
fonction Premier(x : entier) : booléen def Premier(x):
début d = 2
d ← 2 while(d<= x//2 and x % d != 0):
tant que(d ≤ x div 2) et (x mod d ≠ 0 )faire d = d + 1
d ← d + 1
fin_tant_que return (d > x // 2) and (x>1)
retourner (d > x div 2) et (x>1) Par définition 1 n'est pas
fin un nombre premier

#2ème méthode #2ème Méthode

fonction Premier(x : entier) : booléen
def Premier(x):
début
ok = True
ok ← vrai
d = 2
d ← 2
while(d<= x//2) and ok:
tant que (d ≤ x div 2) et (ok) faire
if x % d != 0:
si x mod d = 0 alors d = d + 1
ok ← faux
else:
sinon
ok = False
d ← d + 1
fin_si
return ok and x>1
fin_tant_que
retourner (ok) et (x>1)
fin

A.S 2022-2023 2 Anis Ben Nacib

 Fiche de Révision ::: Informatique

Fonction qui permet de décomposer un entier x donné en produit de ses facteurs premiers.
fonction facteurs_premiers (x : entier) : chaîne def facteurs_premiers(x):
début d = 2
fp ← "" fp = ""
d ← 2 while x>1:
Tant que (x>1) faire if x % d == 0:
si x mod d = 0 alors fp = fp + str(d) + "*"
fp ← fp + convch(d) + "*" x = x // d
x ← x div d else:
sinon d = d + 1
d ← d + 1 non inclus return fp[:len(fp)-1]
fin_si
fin tant_que
retourner sous_chaîne(fp, 0, long(fp)-1)
fin

Les traitements sur les chaînes de caractères

Fonction qui permet de vérifier si une chaîne de caractère est formée uniquement par des lettres
majuscules.
fonction verif_maj(ch : chaîne) : booléen def verif_maj(ch):
début Ok = True
ok ← Vrai i = 0
i ← 0 while (i<len(ch)) and Ok:
tant que (i<long(ch)) et ok faire if "A"<=ch[i]<="Z":
si ch[i] ∈ ["A".."Z"] alors i = i + 1
i ← i + 1 else:
sinon Ok = False
ok ← Faux return Ok
fin_si
fin_tant_que
retourner ok
fin
#2ème méthode #2ème méthode
fonction verif_maj(ch : chaîne) : booléen def verif_maj(ch):
début i = 0
i ← 0 while (i<len(ch) and "A"<=ch[i]<="Z"):
tant que (i<long(ch) et ch[i]∈["A".."Z"])faire i = i + 1
i ← i + 1 return i == len(ch)
fin tant_que
retourner i = long(ch)
fin
Fonction qui permet de vérifier si une chaîne de caractère est formée uniquement par des lettres.
fonction verif_lettres(ch : chaîne) : booléen def verif_lettres(ch):
début i = 0
i ← 0 while(i<len(ch) and "A"<=ch[i].upper()<="Z"):
tant que(i<long(ch) et Majus(ch[i])∈ ["A".."Z"])faire i = i + 1
i ← i + 1 return i == len(ch)
fin tant_que
retourner i = long(ch)
fin

A.S 2022-2023 3 Anis Ben Nacib

 Fiche de Révision ::: Informatique

Fonction qui permet de vérifier si une chaîne de caractère est formée uniquement par des caractères
distincts.
fonction verif_carcteres_distincts(ch:chaîne): booléen def verif_caractres_distincts(ch):
début i = 0
i ← 0
while(i<len(ch))and(ch.find(ch[i]) == i):
tant que (i<long(ch))et (Pos(ch[i],ch)=i)faire
i ← i + 1 i = i + 1
fin_tant_que return i == len(ch)
retourner i = long(ch)
fin
#2ème méthode #2ème méthode
fonction verif_caracteres_distincts(ch:chaîne): booléen def verif_caractres_distincts(ch):
début Ok = True
Ok ← vrai i = 0
i ← 0 while (i<len(ch)) and Ok:
tant que (i<long(ch))et (Ok) faire if (ch.find(ch[i]) == i):
si (Pos(ch[i],ch)=i) alors i = i + 1
i ← i + 1 else:
sinon Ok = False
Ok ← faux return Ok
fin_si
fin_tant_que
retourner i = long(ch)
fin
Fonction qui permet de calculer le nombre de voyelles dans une chaîne ch.
fonction nb_voyelles(ch : chaîne) : entier def nb_voyelle(ch):
début nb = 0
nb ← 0 voy = "AEIOUY"
pour i de 0 à long(ch)-1 faire for i in range(len(ch)):
si Majus(ch[i]) ∈ ["A","E","I","O","U","Y"] if voy.find(ch[i].upper())!= -1:
alors nb = nb + 1
nb ← nb + 1
fin_si return nb
fin_pour
retourner nb
fin
Fonction qui prend une chaîne de caractères non vide composée uniquement par des lettres puis de la convertir en
minuscule.
fonction Minus(ch : chaîne) : chaîne #sans l'utilisation la méthode lower()
début def Minus(ch):
chmin ← "" chmin=""
pour i de 0 à Long(ch)-1 faire for i in range(len(ch)):
si (ch[i] ∈ ["a".."z"] alors if "A"<=ch[i]<="Z":
chmin ← chmin + chr(ord(ch[i])+32) chmin = chmin+chr(ord(ch[i])+32)
sinon else:
chmin ← chmin + ch[i] chmin = chmin + ch[i]
fin_si return chmin
fin_pour Ord("A") = 65
32
retourner chmin Ord("a") = 97
fin

A.S 2022-2023 4 Anis Ben Nacib

 Fiche de Révision ::: Informatique

L'algorithme d'une procédure qui prend en paramètre une chaîne de caractères non vide composée
uniquement par des lettres majuscules puis d'afficher l'ordre alphabétique de chaque lettre.
procédure rang_alphabetique(ch : chaîne) def rang_alphabetique(ch):
début for i in range(len(ch)):
pour i de 0 à long(ch)-1 faire
print(ch[i],"=>",ord(ch[i])-64)
Ecrire(ch[i],"=>",ord(ch[i])-64)
fin_pour
fin #Exemple d'exécution :
Lettre Rang Comment ?
"A" 1 65 -64
"B" 2 66-64
"C" 3 67-64
…
"Z" 26 90-64
Avec ord("A") = 65, ord("B")=66,….

Les traitements sur les tableaux

Exemples de déclarations de tableaux en Python (avec T un tableau de n entiers (2≤n≤20)
#Appel #Appel
from numpy import array from numpy import array
… T=array([int()]*20) #avec 20 la taille maximale
… …
n = saisir() …
T=array([int()]*n) n = saisir()
remplir(T,n) remplir(T,n)
Procédure qui permet de remplir un tableau T par N entiers positifs non nuls.
procédure remplir(@T: Tab, n:entier) def remplir(T,n):
début for i in range(n):
pour i de 0 à n-1 faire
T[i] = int(input("T["+str(i)+"]:"))
répéter
écrire("T[", i, "]: ") while T[i]<=0:
lire(T[i]) T[i] = int(input("T["+str(i)+"]:"))
jusqu'à (T[i] > 0)
fin_pour
fin
Procédure qui permet de remplir d'une manière aléatoire un tableau T par N entiers de trois chiffres.
procédure remplir(@T: Tab, n:entier) #Importer randint de module random
début from random import randint
pour i de 0 à n-1 faire
T[i] ← aléa(100, 999) def remplir(T,n):
fin_pour for i in range(n):
fin T[i] = randint(100,999)
Procédure qui permet de remplir un tableau T par N entiers positifs non nuls ordonnés dans l'ordre décroissant.
procédure remplir(@T: Tab, n:entier) def remplir(T,n):
début T[0] = int(input("T[0]:"))
répéter while T[0]<0:
écrire("T[0]: ")
T[0] = int(input("T[0]:"))
lire(T[0])
jusqu'à T[0] > 0
for i in range(1,n):
pour i de 1 à n-1 faire T[i] = int(input("T["+str(i)+"]:"))
répéter
while not(T[i]>T[i-1]):
écrire("T[", i, "]: ")
lire(T[i]) T[i] = int(input("T["+str(i)+"]:"))
jusqu'à (T[i] > T[i-1])
fin_pour
fin

A.S 2022-2023 5 Anis Ben Nacib

 Fiche de Révision ::: Informatique

Procédure qui permet de remplir un tableau T par N entiers positifs non nuls distincts.
procédure remplir(@T: Tab, n:entier) def remplir(T,n):
début ok = False
répéter while ok == False:
écrire("T[0]: ") T[0] = int(input("T[0]:"))
lire(T[0]) ok = T[0]>0
jusqu'à T[0] > 0
pour i de 1 à n-1 faire for i in range(1,n):
répéter T[i] =int(input("T["+str(i)+"]:"))
écrire("T[", i, "]: ") while not(T[i]>0 and distincts(T,i)):
lire(T[i]) T[i] =int(input("T["+str(i)+"]:"))
jusqu'à (T[i] > 0) et (distincts(T,i))
fin_pour
fin

fonction distincts(T : Tab, i:entier) : booléen def distincts(T,i):

début j = 0
j ← 0 while(j<i) and (T[j]!=T[i]):
tant que (j<i) et (T[j] ≠ T[i]) faire j = j + 1
j ← j + 1 return j==i
fin_tant_que
retourner j=i
fin

Fonction qui prend en paramètres un tableau T de N réels puis de retourner la somme de ses éléments.
fonction somme_tab(T : Tab, n : entier) : entier def somme_tab(T,n):
début s = 0
s ← 0 for i in range(n):
pour i de 0 à n-1 faire s = s + T[i]
s ← s + T[i] return s
fin_pour
retourner s
fin
Fonction qui permet de déterminer le nombre d'occurrence d'un entier x dans un tableau T de taille n.
fonction nb_occurrence(T:Tab, n, x:entier):entier def nb_occurrences(T,n,x):
début
nb = 0
nb ← 0
pour i de 0 à n-1 faire for i in range(n):
si T[i] = x alors
if T[i]==x:
nb ← nb + 1
fin_si nb = nb + 1
fin_pour return nb
retourner nb
fin
Fonction qui permet de déterminer la valeur maximale dans un tableau d'entiers T de taille n.
fonction max_tab(T : Tab, n: entier) : entier def max_tab(T,n):
début max = T[0]
max ← T[0]
for i in range(1,n):
pour i de 1 à n-1 faire
si T[i] > max alors if T[i]>max:
max ← T[i] max = T[i]
fin_si return max
fin_pour
retourner max
fin

A.S 2022-2023 6 Anis Ben Nacib

 Fiche de Révision ::: Informatique

Fonction qui permet de déterminer la position de la valeur minimale dans un tableau d'entiers T de taille n.
fonction pos_min_tab(T : Tab, n: entier) : entier def pos_min_tab(T,n):
début pmin = 0
pmin ← 0
for i in range(1,n):
pour i de 1 à n-1 faire
si T[i] < T[pmin] alors if T[i]<T[pmin]:
min ← i pmin = i
fin_si return pmin
fin_pour
retourner pmin
fin
Fonction qui implémente un algorithme de recherche séquentielle pour trouver un élément x dans un tableau T
de taille n
fonction Recherche_sequentielle T:tab, n,x:entier):Booléen def Recherche_sequentielle (T,n,x):
début
Trouve = False
Trouve ← faux
i ← 0 i = 0
tant que (i<n) et (Trouve=Faux) faire
while (i<n) and (Trouve==False):
si (T[i] = x) alors
Trouve ← vrai if T[i]==x:
sinon
Trouve = True
i ← i + 1
fin_si else:
fin_tant_que
i = i + 1
Retourner Trouve
fin return Trouve
#deuxième méthode
fonction Recherche_sequentielle(T:tab, n,x:entier):Booléen
début #deuxième méthode
Trouve ← faux def Recherche_sequentielle (T,n,x):
i ← 0
i = 0
Répéter
si (T[i] = x) alors while (i<n) and (T[i]!=x):
Trouve ← vrai
i = i + 1
sinon
i ← i + 1 return i<n
fin_si
Jusqu'à (Trouve) ou (i = N)
Retourner Trouve
fin
Fonction qui implémente un algorithme de recherche dichotomique pour trouver un élément x dans un tableau T
de taille n
fonction Recherche_dichotomique (T:tab ; n,x:entier):Booléen def Recherche_dichotomique(T, n, x):
Début d = 0
d ← 0
f = n - 1
f ← n-1
Trouve ← faux Trouve = False
Tant Que (d ≤ f) et (Trouve = faux) faire while (d <= f) and (Trouve==False):
Milieu ← (d + f) Div 2 milieu = (d + f) // 2
Si (T[milieu] = x) Alors
if T[milieu] == x:
Trouve ← vrai
Sinon Si (T[milieu] > x) Alors Trouve = True
f ← milieu – 1 elif T[milieu] < x:
Sinon d = milieu + 1
d ← milieu+1
else:
Fin_si
fin_Tant_Que f = milieu - 1
Retourner Trouve return Trouve
fin

A.S 2022-2023 7 Anis Ben Nacib

 Fiche de Révision ::: Informatique

Procédure qui implémente un algorithme de tri par sélection dans l'ordre croissant d'un tableau T de taille n.
procédure Tri_Selection (@T : Tab , n : Entier ) def Tri_Selection(T, n):
début for i in range(n-1):
Pour i de 0 à n-2 Faire
posmin = i
posmin ← i
for j in range(i+1, n):
Pour j de i+1 à n-1 Faire
si T[j] < T[posmin] Alors if T[j] < T[posmin]:
posmin ← j posmin = j
fin_Si if posmin != i:
T[i], T[posmin] = T[posmin], T[i]
fin_Pour
Si posmin ≠ i Alors
Aux ← T[i]
T[i] ← T[posmin]
T[posmin] ← Aux
Fin_Si
Fin_Pour
Fin
Procédure qui implémente un algorithme de tri par insertion dans l'ordre croissant d'un tableau T de taille n.
procédure Tri_Insertion (@T : Tab , n :entier) def Tri_Insertion(T, n):
début for i in range(1, n):
Pour i de 1 à n-1 faire
aux = T[i]
aux ← T[i]
j = i
j ← i
Tant Que (j>0) et (T[j-1]>aux) faire while j > 0 and T[j-1] > aux:
T[j] ← T[j-1] T[j] = T[j-1]
j ← j-1 j = j-1
fin_Tant_Que
T[j] = aux
T[j] ← Aux
Fin_Pour
fin

You Can Do It !

A.S 2022-2023 8 Anis Ben Nacib