Modules utiles type tableau

➢ Saisie d’un entier n avec une condition

Algorithme Python Appel dans le prog. principal

Procédure Saisie (@ n: entier) def Saisie(): En algorithme :
Début n=int(input("Saisir un entier : ")) Saisie(n)
Répéter while not(2<=n<=10) : En Python :
Ecrire ("Saisir un entier : ") n=int(input("Saisir un entier : ")) n=Saisie()
Lire (n) return n
Jusqu’à (n є [2..10])
Fin
➢ Remplir un tableau avec n éléments quelconques
Algorithme Python Appel dans le prog. principal
Procédure Remplir (n:entier,@ T :Tab) def Remplir(n,T): En algorithme :
Début for i in range(n) : Remplir(n,T)
Pour i de 0 à (n-1) Faire T[i]=int(input("Saisir T[",i,"] : ")) En Python :
Ecrire("Saisir T[",i,"] : ") Remplir(n,T)
Lire(T[i])
Fin pour
Fin
NB: si on a une condition sur les éléments du tableau
➢ Remplir un tableau avec n entiers positifs
Algorithme Python
Procédure Remplir (n:entier,@ T :Tab) def Remplir(n,T):
Début for i in range(n) :
Pour i de 0 à (n-1) Faire T[i]=int(input("Saisir T[",i,"] : "))
Répéter while(T[i]<0) :
Ecrire("Saisir T[",i,"] : ") T[i]=int(input("Saisir T[",i,"] : "))
Lire(T[i])
Jusqu’à (T[i]>=0)
Fin pour
Fin
➢ Remplir un tableau avec n caractères alphabétiques majuscules
Algorithme Python
Procédure Remplir (n:entier,@ T :Tab) def Remplir(n,T):
Début for i in range(n) :
Pour i de 0 à (n-1) Faire T[i]=int(input("Saisir T[",i,"] : "))
Répéter while('A'<=T[i]<='Z') :
Ecrire("Saisir T[",i,"] : ") T[i]=int(input("Saisir T[",i,"] : "))
Lire(T[i])
Jusqu’à ('A'<=T[i]<='Z')
Fin pour
Fin
---------------------------- Remplir un tableau avec n entiers aléatoires ------------------------
Algorithme Python Remarque
Procédure Remplir (n:entier,@ T :Tab) def Remplir(n,T): On doit importer la bibliothèque
Début for i in range(n) : random pour utiliser randint
Pour i de 0 à (n-1) Faire T[i]=randint(binf, bsup) from random import*
T[i]  aléa(binf, bsup)
Fin pour
Fin
NB: s’il s’agit des éléments aléatoires de 2 chiffres par exemple, on écrit : T[i]  aléa(10,90)

1
 ------------ Remplir un tableau avec n éléments saisis dans un ordre strictement croissant -------------
Algorithme Python
Procédure Remplir (n:entier,@ T :Tab) def Remplir(n,T):
Début T[0]=int(input("Saisir T0] : "))
Ecrire("Saisir T[0] : ") for i in range(1,n) :
Lire (T[0]) T[i]=int(input("Saisir T["+str(i)+"] : "))
Pour i de 1 à (n-1) Faire while((T[i] <=T[i-1]):
Répéter T[i]=int(input("Saisir T["+str(i)+"] : "))
Ecrire("Saisir T[",i,"] : ")
Lire(T[i])
Jusqu’à (T[i] >T[i-1])
Fin pour
Fin
-------------------------------------- Afficher les éléments d’un tableau ----------------------------------------
Algorithme Python
Procédure Affiche(n:entier,T:Tab) def Affiche(n,T) :
Début for i in range(0,n) :
Pour i de 0 à (n-1) Faire print(T[i])
Ecrire(T[i])
Fin pour
Fin
NB: pour afficher un élément du tableau par ligne, on utilise Ecrire_nl(T[i])
-------------------------------------- Somme des éléments d’un tableau ----------------------------------------
Algorithme Python
Fonction Somme (n:entier, T:Tab) : entier def Somme(n,T):
Début S=0
S 0 for i in range(0,n) :
Pour i de 0 à (n-1) Faire S= S+T[i]
S S+T[i] return S
Fin pour
Retourner S
Fin
---------------------- nombre d’occurrences (fréquence) d’un élément x dans un tableau --------------------
Algorithme Python
Fonction occurrence (x,n: entier ; T:Tab) : entier def occurrence (x,n,T):
Début nb =0
nb0 for i in range(0,n) :
Pour i de 0 à (n-1) Faire if (T[i]==x):
Si(T[i]= x) nb=nb+1
Alors nbnb+1 return nb
Fin si
Fin pour
Retourner nb
Fin
-------------------------------------- Inverser les éléments d’un tableau ----------------------------------------
Algorithme Python
Procédure Inverse (n:entier ; var T:Tab) def Inverse(n,T):
Début i=0
i0 while(i< n //2):
Répéter Aux = T[i]
Aux  T[i] T[i] = T[n-1-i]
T[i]  T[n-1-i] T[n-1-i]=Aux
T[n-1-i]  Aux i=i+1
ii+1
Jusqu’à (i= n div 2)
Fin
2
 -------------------------------------- Tester la symétrie d’un tableau ----------------------------------------
Un tableau est symétrique si le dernier élément est égal au premier, l’avant dernier est égal au deuxième …
Algorithme Python
Fonction symetrie (n:entier; T:Tab) : booléen def symetrie (n,T):
Début i =0
i0 s =True
s  vrai while(i<n //2) and (s==True):
Répéter if (T[i] !=T[n-1-i]):
Si (T[i] ≠T[n-1-i]) alors s =False
s  Faux else:
Sinon i  i + 1 i=i+1
Fin si return s
jusqu’à (i=n div 2) ou (s=Faux)
Retourner s
Fin
----------------------- Recherche de x dans un tableau T (Recherche séquentielle) -------------------------
Algorithme Python
Fonction Recherche (n,x: entier; T:Tab) : booléen def Recherche (n,x,T) :
Début V=False
V Faux i=0
i0 while (V==False) and (i<n) :
Répéter if (T[i]==x):
Si(T[i]=x) Alors V=True
Vvrai else: i=i+1
Sinon i  i+1 return V
Fin si
Jusqu’à (V=vrai) ou (i=n)
Retourner V
Fin
Ou bien
Algorithme Python
Fonction Recherche (n,x: entier; T:Tab) : booléen def Recherche (n,x,T) :
Début V=False
V Faux for i in range(0,n):
Pour i de 0 à (n-1) faire if (T[i]==x):
Si(T[i]=x) Alors V=True
Vvrai return V
Fin si
Fin pour
Retourner V
Fin
------------------------------ Recherche de minimum d’un tableau ---------------------------------
Algorithme Python
Fonction Minimum (n: entier; T:Tab) : entier def Minimum (n,T) :
Début m =T[0]
mT[0] for i in range(1,n) :
Pour i de 1 à n Faire if (T[i]<m):
Si(T[i]<m) m=T[i]
Alors mT[i] return m
Fin si
Fin pour
Retourner m
Fin

3
 --------------------------- Eclater un tableau en deux tableaux selon un critère ---------------------------
Exemple : Ranger les éléments positifs de T dans TP et les éléments négatifs dans TN
Algorithme Python
Procédure Eclater (@ j,k,n:entier;T:Tab; @TN,TP :Tab) def Eclater (j,k,n,T,TN,TP):
Début j =-1
j-1 k =-1
k-1 for i in range(0,n) :
Pour i de 0 à (n-1) Faire if (T[i]>=0):
Si(T[i]>=0) j =j+1
Alors jj+1 TP[j] =T[i]
TP[j]  T[i] else:
Sinon kk+1 K =k+1
TN[k]  T[i] TN[k]= T[i]
Fin si
Fin pour
Fin
------------------------------ Remplir un tableau par des éléments distincts ---------------------------------
Algorithme Python
Procédure Remplir (n:entier ; @ T :Tab) def Remplir (n,T) :
Début T[0]=int(input("Saisir T[0]= "))
Ecrire ("Saisir T[0] : ") for i in range(1,n) :
Lire (T[0]) T[i]=int(input("Saisir T["+str(i)+"]= "))
Pour i de 1 à n Faire while(distinct(T[i],i,T)==False):
Répéter T[i]=int(input("Saisir T["+str(i)+"]= "))
Lire(T[i])
Jusqu’à (Distinct(T[i],i,T))
Fin pour
Fin
Fonction distinct :
Algorithme Python
Fonction distinct (x,y: entier, T :Tab): booléen def distinct(x,y, T):
Début d=True
dvrai j=0
j0 while(j<y)and(d==True):
répéter if (T[j]==x):
Si (T[j]=x) Alors d=False
d faux else:
Sinon j  j +1 j = j+1
Finsi return d
jusqu’à (j=y-1) ou (d=faux)
Retourner d
Fin