Fiche de révision Bac Scientifique 2023

Algorithme Code python

1 Traitement des entiers
Procedure permute (@ a,b :entier) def permute(a,b) :
x  a x=a
a  b a=b
b  x b=x
fin permute **************2 methode ****************
********2 methode*************** def (a,b) :
Procedure permute (@ a,b :entier) a=a+b
a  a+b b=a-b
b  a-b a=a-b
a  a-b
fin permute

Calculer somme des chiffres d’un entier x def som_chiff (x) :

fonction som_chiff(x :entier) :entier 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
fin pour
retourner s **************2 methode ****************
Fin som_chiff def som_chiff(x) :
*****2eme méthode****************** s=0
Fonction som_chiff(x :entier) :entier while x !=0 :
S  0 s=s+x%10
Tantque x<>0 faire x=x//10
S  s+ x mod 10 return s
X  x div 10
Fin tant que
Retourner s
Fin som_chiff
Calculer somme des diviseurs d’un entier x def som_div(x) :
fonction som_div(x :entier) :entier s=0
S 0 for i in range (1,x+1) :
Pour i de 1 à x faire If x%i==0 :
si( x mod i=0)alors s=s+i
s  s+i return s
Fin pour
Retourner s
Fin som_div
Calculer la factorielle d’un entier n def fact(n) :
fonction Fact (n :entier ) :entier f=1
f← 1 for i in range (1,n+1) :
pour i de 1 à n faire f =f*i
f←f*i return f
FinPour
Retourner f
Fin Fact
Calculer la combinaison def com(n,p) :
fonction comb (n ,p :entier) :entier c=fact(n)//(fact(n-p)*fact(p))
c ←Fact (n) div (Fact(n-p)* Fact(p)) return c
Retourner c fin comb

1
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Calculer l’arrangement def arrang(n,p) :
fonction arrang(n,p : entier):entier a=fact (n)//fact(n-p)
a ←Fact (n) div Fact(n-p) return a
Retourner a
fin arrang
Calculer la puissance an def puissance(a,n) :
fonction puissance (a,n :entier) :entier p=1
p← 1 for i in range (1,n+1) :
pour i de 1 à n faire p=p*a
p←p*a return p
fin Pour
retourner p
fin puissance
Tester s un entier n donnée est premier ou non def premier (n) :
fonction premier(n :entier) :booleen nb=0
nb0 for i in range (2,n//2 +1 ) :
Pour i de 2 à n div 2 faire If n %i==0 :
si n mod i= 0 alors nbnb+1 fin si nb=nb+1
fin pour return nb ==0
retourner nb=0 ************2eme methode*************
fin premier def premier (n) :
************2eme methode************* i=2
fonction premier(n :entier) :booleen while (n%i==0) and (i<= n// 2) :
i2 i=i+1,
tantque (n mod i <> 0 ) ET ( i<= n div 2) faire return i>n // 2
i  i +1
fin tantque
retourner i >n div 2
fin premier
Sauvegarder dans une chaine les Facteurs Premier d’un entier x def fact premier (x) :
fonction Facteur_Premier(x :entier) :chaine i=2
i  2 ch=’’
ch  ’’ while n !=1 :
repeter If n%i==0 :
tantque N mod i=0 faire ch=ch+str(i)+’*’
c convch(i) n=n//i
Ch ch+c+’*’ else :
n n div i i=i+1
fin tantque return ch [ :len(ch)-1]
i i+1
Jusqu’à n=1 ************ autre méthode*************
retourner ch def fact premier (x) :
Fin Facteur_Premier i=2
************autre méthode************* j=0
Sauvegarder dans un vecteur t les Facteurs Premier d’un entier x while x !=1 :
procedure Facteur (n :entier ; @ t:tab) while x%i==0 :
j  0 t[j]=i
i  2 j=j+1
Repeter x=x//i
Tant quei n mod i=0 faire i=i+1
t[ j ] i return t
j j+1
nn div i
fin tantque
i i+1
jusqu’à n=1
Fin Facteur

2
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Tester s un entier x est divisble ar 3 ou non def divis_3(x) :
fonction divis_3(x :entier ) :booleen ch=str(x)
ch convch(x) s=0
s0 for i in range (0,len(ch)) :
pour i de 0 à long (ch)-1faire s=s+int(ch[i])
s s+ valeur(ch[i]) return s%3 ==0
fin pour
retourner s mod 3 = 0
fin divis_3
Tester s un entier x est divisble ar 25 ou non def div_25(x) :
fonction div_25(x :entier ) :booleen c=x%100
c x mod 100 return c%25==0
retourner C MOD 25 =0
Fin div_25
Tester s un entier x est divisble ar 7 ou non def div_7(x) :
fonction div_7(x :entier ) :booleen while x<=10:
ch  convch(x) ch=str(x)
repeter u=ch[len(ch)-1]
ich[long(ch)-1] ch =ch[0:len(ch)-1 ]
ch sous_chaine(ch,0,long(ch)-2) x=int(ch)-(2*int(u))
n val(ch) return x%7==0
u  val(l)
n n-2*u
jusqu’à long(ch)<=1 **************2eme methode**********
retourner n mod 7=0 def div_7(x):
fin div_7 while x>=10 :
************2eme methode************* u=x%10
Fontion div_7(x:entire):entier mcd=x//10
Repeter x=mcd-2*u
u  x mod 10 return x%7==0
mcd  x div 10
x  mcd-2*u
Jusqu’a x<10
retourner x mod 7 = 0
Calculer le PPCM de deux entiers a et b Def ppcm (a,b) :
fonction PPCM (a,b :entier) :entier m=a
m a while (m %b) !=0 :
tantque (m mod b) <>0 faire m=m+a
mi  m+a Return m
fin tantque **************2eme methode ************
retourner m Def ppcm (a,b) :
fin PPCM p=a*b
************2eme methode ********* while a !=b :
Fonction ppcm(a,b:entire): entire If a<b :
P a*b b=b-a
Tant que a<>b faire else :
Si a<b alors b  b-a a=a-b
Sinon a  a-b return p/a
Fin si
Fin tant que
retourner p/a
Fin ppcm

3
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Calculer le PGCD de deux entiers a et b def pgcd_div (a,b) :
fonction PGCD_ div(a,b:entier):entier while b !=0 :
tant que b<>0 faire r=a%b
ra mod b a=b
ab b=r
br return a
fin tantque
retourner a ************2eme methode ***************
fin PGCD def pgcd_div(a,b) :
***************2eme methode ******* while a !=b :
fonction PGCD_ sous(a,b:entier):entier if a< b :
tant que a<>b faire b=b-a
si a<b alors b  b-a else :
Sinon a  a-b a=a-b
fin si return a
fin tant que
retourner a
fin PGCD
saisir une suite de caractères qui se termine par ‘*’ (inclus), et def occurrence () :
calculer le nombre d’apparition de la lettre ‘A’. s=0
Fonction occurrence () :entier c=input(‘donner un caractere ’)
S  0 while not(c=’*’) :
Repeter if c=’a’ :
lire(c) s=s+1
Si c=’A’ alors c=input(‘donner un caractere ’)
S  s+ 1 return s
Jusqu’à c=’*’
retourner s
fin occurence
calculer la valeur du Nème terme de la suite Un définie par : def suite 1 (n) :
x=2
y=3
fonction suite1(n :entier) :réel for i in range (2,n+1) :
x← 2 y←3 u=2/3*y-1/4*x
pour i de 2 à n faire x=y
u ←2/3*y–¼*x y=u
x ← y return u
y ← u
fin Pour
retourner u
Fin suite1
calcule la somme d’ordre N définie comme def suite 2(x ,n) :
suit sans l’utilisation de l’opérateur de k =-1
puissance. s=0
fonction suite2 (x,n :entier) :réel p =1
k← -1 for i in range (0,n+1) :
s ←0 s=k/p
p ← 1 P=p*x
pour i de 0 à n faire K=-k
s ← s+k/p return s
k ← -k
p ← p*x
finPour
retourner s fin suite2
4
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Ecrire une fonction suite3 qui calcule la racine carré d’un def abs (x) :
nombre positif en utilisant la formule If x<0 :
suivante : return -x

à 10-3 prés def suite 3(a) :

x=a
fonction suite3 (a :réel) :réel d=1
x← a while not (abs(d)<0,001)
repeter y=1/2*(x+a/x)
y← ½*(x+a/x) d=y-x
d ← y-x X=y
x← y return y
Jusqu’à abs(d)<0.001
retourner y
fin suite3
Convertir un entier n binaire base 2 vers la base dix def conv2_10(n):
fonction conv2_10(n :entier) :entier p=1 d=0
P←1 d←0 while n!=0:
Repeter d = d+(n % 10)*p
d ← d +(n mod 10)*p p = p*2
p ← p*2 n = n // 10
n← n div 10 return d
Jusqu’à n=0 ***********2eme methode *********
retorner d def puissance(b,x):
fin conv2_10 p=1
***********2eme methode ********* for i in range (x):
fonction conv2_10(n :entier) :entier p=p*b
ch←convch(n) return p
d← 0 def conv2_10(n):
pour i de long(ch)-1 à 0 faire (pas=-1) ch=str(n)
x=valeur (ch[i]) d=0
d←d+x* puissance (2, long(ch)-1- i) for i in range (len(ch)-1,-1,-1):
finPour x=int(ch[i])
retourner d d=d+x*puissance(2,len(ch)-1-i)
fin conv2_10 return d

5
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Convertir un entier n de la base dix vers la base 2 def conv10_2(n):
fonction conv10_2(n :entier) :entier p=1
P←1 b← 0 b=0
repeter while n!=0:
b ←(n mod 2)*p+b b = (n % 2)*p+b
P ← p*10 p = p*10
n ← n div 2 n = n // 2
Jusqu’à n=0 return b
retorner B ***********2eme methode *********
fin conv10_2 def conv10_2(n):
***********2eme methode ********* b =''
fonction conv10_2(n :entier) :entier while n!=0:
b← ‘’ b= str(n%2)+b
repeter n=n//2
b ← convch(n mod 2)+b return b
n ← n div 2
Jusqu’à n=0
retorner b
fin conv10_2 # conversion un entier n de la base 10 vers la base b <= 16
conversion un entier n de la base dix vers une base b <= 16
fonction DB(n,b : entier) : chaine def DB(n,b):
chl← '0123456789ABCDEF' chl='0123456789ABCDEF'
ch←'' ch=''
tantque n<>0 faire while n!=0:
r← n mod b r=n%b
n← n div b n=n//b
ch← chl[r]+ch ch=chl[r]+ch
retourner ch return ch
#****************2eme methode************* n=int(input('donnez un nombre en décimal'))
Fonction Conv10_16 (n : Entier ) : Chaîne b=int(input('donnez la base destinataire'))
Ch ← " " print(DB(n,b))
Répéter #****************2eme methode*************
r ← n Mod 16
Si r ≥ 10 Alors
Ch1 ← Majus (Chr (55 + r)) def conv10_16 (n):
Sinon Ch1 ← Convch (r) ch=''
FinSi while n!= 0 :
Ch ← Ch1 + Ch r=n%16
n ← n Div 16 if r>=10 :
Jusqu'à n = 0 ch=chr(55+r)+ch
Retourner Ch else:
Fin Conv10_16 ch=str(r)+ch

n=n//16
return ch

6
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
fonction conv16_10(ch:chaine):entier def conv16_10 (ch) :
dec ← 0 dec=0
Pour i de 0 à Long (ch)-1 Faire ch=ch.upper()
Si Majus (ch[i]) Dans ["A".."F"] Alors for i in range(len(ch)):
n ← Ord (Majus (ch[i])) - 55 if 'A'<=ch[i]<='F':
Sinon n ←Valeur (ch[i]) n=ord(ch[i])-55
FinSi else: n=int(ch[i])
dec ← dec + n * Puissb1 ( 16,long (ch) – i-1)
FinPour dec=dec+n*puissb1(16,len(ch)-i-1)
Retourner Dec
Fin Conv_10 return dec
fin conv16_10

1. Conversion base b1 vers b2 # Conversion base b1 vers base 10

Conversion base b1 vers base 10 def conv_10 (ch,b1) :
Fonction Conv_10 (Ch : Chaîne; b1 : Entier) : Entier dec=0
dec ← 0 ch=ch.upper()
Pour i de 0 à Long (Ch)-1 Faire for i in range(len(ch)):
Si Majus (Ch[i]) Dans ["A".."F"] Alors if 'A'<=ch[i]<='F':
N ← Ord (Majus (Ch[i])) - 55 n=ord(ch[i])-55
Sinon N ←Valeur (Ch[i]) else: n=int(ch[i])
FinSi
dec ← dec + N * Puissb1 ( b1,long (Ch) – i-1) dec=dec+n*puissb1(b1,len(ch)-i-1)
FinPour
Retourner Dec return dec
Fin Conv_10
Conversion base 10 vers base b2 #Conversion base 10 vers base b2
Fonction Conv_b2 (n : Entier Long; b2 : Entier) : Chaîne def conv_b2 (n,b2):
Ch ← " " ch=''
Répéter while n!= 0 :
r ← n Mod b2 r=n%b2
Si r ≥ 10 Alors Ch1 ← Majus (Chr (55 + r)) if r>=10 :
Sinon Convch (r, Ch1) ch=chr(55+r)+ch
FinSi else:
Ch ← Ch1 + Ch ch=str(r)+ch
n ← n Div b2
Jusqu'à n = 0 n=n//b2
Retourner Ch return ch
Fin Conv_b2

7
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
2. Traitement des chaines
inverser une chaine ch Autre Solution spéciale python
fonction inverse(ch :chaine) :chaine def inverse(ch ) :
c  ‘’ c=''
pour i de 0 à long(ch)-1 faire for i in range(len(ch)-1,-1,-1):
c  ch[i]+c c=c+ch[i] #ajout à droite
Fin pour *********2eme méthode**************
retourner c def inverse(ch ) :
fin inverser c=''
*********2eme methode************** for i in range(len(ch)):
fonction inverse(ch :chaine) :chaine c=ch[i]+c # ajout à gauche
pour i de 0 à long(ch)-1 faire **3eme méthode**# méthode de permutation**
x  ch[i] def inverse(ch ) :
ch[i]  ch[long(ch)-i-1] for i in range (len(ch)):
ch[long(ch)-i-1]  ch[i] x = ch[i]
fin pour ch[i] = ch[len(ch)-i-1]
retourner ch ch[len(ch)-i-1] = ch[i]
fin inverser return ch

Verifier que la chaine ch ne contient que des lettres majuscules def valide(ch) :
fonction valide(ch :chaine) : booleen i= 0
i  0 while ( ‘A’ <=ch[i] <=’Z’)and (i<=len(ch)-1) :
Tantque (ch[i]€[‘A’..’Z’])et (i<=long(ch)-1) faire i  i+1
i  i+1 return i>len(ch)-1
fin tantque
retourner i>long(ch)-1 ********2 methode*****************
fin valide def valide(ch) :
********2 methode***************** s = 0
fonction valide(ch :chaine) : booleen for i in range (len(ch)):
s  0 if ( ‘A’ <=ch[i] <=’Z’) :
pour i de 0 à long(ch)-1 faire s = s+1
si ch[i]€[‘A’..’Z’] alors s  s+1 return s==len(ch)-1
fin pour
retourner s= long(ch)-1 *******************
fin valide def saisie( ch ) :
procedure saisie(@ ch :chaine) ch=input(‘donner une chaine’)
repeter while not ( valide(ch) ) :
Ecrire(‘donner une chaine’),lire(ch) ch=input(‘donner une chaine’)
Jusqu’à valide(ch)

Supprimer les espaces superflut d’une chaine ch def espace_superflut(ch) :

fonction espace_superflut (ch :chaine) :chaine while ch.find(' ') !=-1:
tantque pos(‘ ‘,ch)<>-1 faire ch=ch [0:ch.find(' ')]+ch[ch.find(' ')+1:len(ch)]
Efface(ch, pos(‘ ‘,ch), long(ch)-1-pos(‘ ‘,ch))
fin tantque if ch[0]==' ' :
si ch[0]=’ ‘ alors efface(ch , 0,1) finsi ch=ch[1:]
si ch[long(ch)-1]=’ ‘ alors efface(ch , long(ch)-1 ,1) if ch[len(ch)-1]==' ' :
finsi ch=ch[:len(ch)-1]
retourner ch return ch
fin espace_superflut

8
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Calculer le nombre de mot d’une chaine ch def nombre_mot (ch):
fonction nombre_mot(ch :chaine) :entier s=0
s  0 p=ch.find(' ')
p  pos(‘ ‘,ch) while p!=-1:
tant que p <> -1 faire s=s+1
s  s+1 ch=ch[p+1:]
efface(ch,0, pos(‘ ‘,ch)+1) p=ch.find(' ')
p  pos(‘ ‘,ch) return s+1
fin tantque
retourner s+1
fin nombre_mot
Tester si une Chaine composer par des lettres distincts Def distincte (ch):
Fonction distincte (ch:chaine):booleen i =0
i 0 test=True
test vrai while not(test=False) ou (i=len(ch)) :
repeter if ch.find (ch[i]) !=i :
si pos(ch[i],ch)<>i alors test=False
testfaux i =i+1
fin si return test
i i+1
jusqu’à (test=faux) ou (i=long(ch))
retourner test
fin distincte
Trouver la position d’une lettre en alphabet alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
Alpha  "ABCDEFGHIJKLMNOPQRSTUVWXYZ" for i in range (len(ch)):
Pour i de 0 à long(ch)-1 faire p=alpha.find(ch[i].upper())+1
p  pos(majus(ch|i]),alpha)+1
Calculer le nombre des mots communs de deux chaines ch et def nombremotscommuns(ch,ph):
ph s=0
fonction nombremotscommuns (ch,ph:chaine): entier p=ch.find(' ')
s  0 while p!=-1:
p  pos(‘ ‘,ch) c=ch[0:p]
tant que p <> -1 faire if ph.find(c)!=-1:
c  sous chaine (ch, 0,p) s=s+1
si pos(c, ph) <> -1 alors ch=ch[p+1:]
s  s+1 p=ch.find(' ')
fin si return s+1
efface(ch, p+1, long(ch))
p  pos(‘ ‘,ch)
fin tantque
retourner s+1
fin nombremotscommuns

9
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
3 Traitement vecteur
Remplir tableau T de n (2<=n<=15) entier from numpy import*
procedure remplir (@ n :entier ; @ T :tab) def remplir(n,t):
repeter t[i]=int(input('t['+str(i)+']='))
ecrire(‘donner la taille’), lire(n) ***************pp*******
jusqu’à n € [2..15] n=int(input('n='))
pour i de 0 à n-1 faire while not(2 <=n <=15)) :
ecrire(‘‘t[‘’,i,’’]=’’) lire(T[i]) n=int(input('n='))
fin pour t=array( [int()]*n)
fin remplir remplir(n,t)
Remplir aléatoirement un vecteur T par n entiers positifs, from numpy import*
non nul et inférieurs à 1000. def remplir(n,t):
procedure remplir (@ n :entier; @ T :tab) for i in range (n):
ecrre(‘‘n=’’ ) Lire(n) t[i]=randint(1,999)
Pour i de 0 à n-1 faire print (t[i])
T[i] aléa(1,999) ***************pp*******
Ecrire(T[ i]) n=int(input('n='))
fin pour t=array( [int()]*n)
Fin remplir remplir(n,t)
Remplir aléatoirement un vecteur T par N entiers à deux from numpy import*
chiffres. T[i] € [10..99] def remplir(n,t):
procedure remplir (@ n :entier ; @ T :tab) for i in range (n):
ecrre(‘‘n=’’ ) Lire(n) t[i]=randint(10,99)
Pour i de 0 à n-1 faire print (t[i])
T[i] aléa(10,99) ***************pp*******
Ecrire(T[ i]) n=int(input('n='))
Fin pour t= array([int()]*n)
fin remplir remplir(n,t)
Remplir aléatoirement un vecteur T par N lettres majuscules. from numpy import*
procedure remplir (@ n :integer ; @ T :tab) def remplir(n,t):
ecrre(‘‘n=’’ ) Lire(n) for i in range (n):
Pour i de 0 à n-1 faire t[i]=chr (randint(65,90))
T[i] chr(aléa(65,90)) print (t[i])
ecrire(T[ i]) ***************pp*******
fin pour n=int(input('n='))
Fin remplir t= array([int()]*n)
remplir(n,t)
Remplir aléatoirement un vecteur T par N caractères. from numpy import*
procedure remplir (@ n :integer ; @ T :tab) def remplir(n,t):
ecrre(‘‘n=’’ ) lire(n) for i in range (n):
pour i de 0 à n-1 faire t[i]=chr (randint(1,255))
T[i] chr(aléa(1,255)) print (t[i])
ecrire(T[ i]) ***************pp*******
fin pour n=int(input('n='))
fin remplir t=array( [int()]*n)
remplir(n,t)

Remplir un vecteur T par n chaînes non vide de longueur maximale from numpy import*
10. n compris entre 5 et 10. def remplir(n,t):
procedure remplir (@ n :integer ; @ T :tab) for i in range (n):
répéter t[i]=int(input('t['+str(i)+']='))
ecrre(‘‘n=’’ ) lire(n) while not(len(T[i])<=10) and (T[i] !=’’):
Jusqu'à n € [5..10] t[i]=int(input('t['+str(i)+']='))
pour i de 0 à n-1 faire ***************pp*******
répéter n=int(input('n='))
Ecrire(‘‘T[’’ , i , ’’]=’’ ), Lire(T[i]) while not(2 <=n <=15)) :
Jusqu'à (long(T[i])<=10) et (T[i]<>’’) n=int(input('n='))
fin pour t=array( [int()]*n)
fin remplir remplir(n,t)

10
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Remplir un vecteur T par N entiers distincts deux à deux from numpy import*
N compris entre 5 et 10. remplir(n,t):
procedure remplir (@ n :integer ; @ T :tab) t[0]=int(input('t[0]='))
répéter for i in range (1,n):
ecrre(‘‘n=’’ ) lire(n) t[i]=int(input('t['+str(i)+']='))
Jusqu'à n € [5..10] while not(T[i] != T[i-1]):
lire(T[0]) t[i]=int(input('t['+str(i)+']='))
Pour i de 1 à n-1 faire ***************pp*******
répéter n=int(input('n='))
Ecrire(‘‘T[’’ , i , ’’]=’’ ) Lire(T[i]) while not(2 <=n <=15)) :
Jusqu'à T[i]<>T[i-1] n=int(input('n='))
Fin pour t=array( [int()]*n)
Fin remplir remplir(n,t)
Remplir un vecteur T par N entiers distincts et N compris from numpy import*
entre 5 et 30. def existe(t,x,i):
procedure remplir (@ n :integer ; @ T :tab) j=i-1
répéter ok=False
ecrre(‘‘n=’’ ) lire(n) while (j>=0) and(ok==False):
Jusqu'à n dans [5..30] if x==t[j]:
lire(T[0]) ok=True
pour i de 1 à n-1 faire j=j-1
répéter return ok
ecrire(‘‘T[’’ , i , ’’]=’’ ), lire(T[i]) *********************************************
jusqu'à existe(t,t[i],i) =faux def remplir(n,t):
fin pour t[0]=int(input('t[0]='))
fin remplir for i in range (1,n):
fonction existe(t :tab ;x ,i :entier) :booleen t[i]=int(input('t['+str(i)+']='))
j  i while not(existe(t,t[i],i)==False):
ok  faux t[i]=int(input('t['+str(i)+']='))
répéter ***************pp*******
si x=t[j] alors n=int(input('n='))
ok  vrai while not(5 <=n <=30)) :
fin si n=int(input('n='))
j  j-1 t=array( [int()]*n)
Jusqu'à (j<0) ou (ok) remplir(n,t)
retourner ok
Remplir tableau T de n éléments triés on ordre croissant from numpy import*
procedure remplir (@ n :integer ; @ T :tab) def remplir(n,t):
répéter t[0]=int(input('t[0]='))
ecrre(‘‘n=’’ ) lire(n) for i in range (1,n):
jusqu'à n € [5..10] t[i]=int(input('t['+str(i)+']='))
lire(T[0]) while not(T[i] > T[i-1]):
pour i de 1 à n-1 faire t[i]=int(input('t['+str(i)+']='))
répéter ***************pp*******
ecrire(‘‘T[’’ , i , ’’]=’’ ) lire(T[i]) n=int(input('n='))
jusqu'à T[i] >T[i-1] while not(5 <=n <=30)) :
fin pour n=int(input('n='))
fin remplir t=array( [int()]*n)
remplir(n,t)
Inverser un vecteur T def inverse(n,t):
procedure inverser(@t :tab ;n :entier) for i in range ((n//2)+1):
pour i de 0 à n div 2 faire x=t[i]
x  t[i] t[i]=t[n-i-1]
t[i]  t[n-i-1] t[n-i-1]=x
t[n-i-1]  t[i]
fin pour
fin inverser

11
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Calculer la somme des éléments d’un vecteur T def som(n,t):
fonction somme (n :entier ; T :tab) :entier 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 somme
Tester la symetrie d’un vecteur T def symetrique(n,t):
fonction symetrie (n :entier ; T :tab) :booleen i=0
i← 1 while (t[i]==t[n-i-1]) and (i<=n //2):
tantque (T[i]=T[n-i+1]) ET (i<=n div 2) faire i=i+1
i ← i+1 return i>n //2
fin tantque
si i > n div 2 alors retourner ← vrai
Sinon retourner ← faux Retourner i > n div
2
finsi
fin symetrie
Calculer l’occurrence d’un entier x dans T def occurrence (n,x,t):
fonction occurence (n,x :entier ; T :tab) :entier nb=0
occ ← 0 for i in range (n):
pour i de 0 à n-1 faire if (t[i])=x :
si T[i]=x alors occ ← occ+1 fin si nb=nb+1
fin pour return nb
retourner occ
fin Occurrence
Chercher le plus grand élément d’un vecteur T def maximum(t,n):
fonction maximum (n :entier ; T :tab) :entier max=t[0]
max ← T[0] for i in range (n):
pour i de 1 à n-1 faire if t[i]>max :
si T[i]> max alors max ← T[i] fin si max=t[i]
fin pour return max
retourner max
fin maximum
Insertion d’un élément x dans T à la position P def insertion1 (p ,x ,n ,T) :
Procédure insertion1 (p ,x :entier ;@ n :entier ;@T :tab); n = n+1
n ← n+1 #modification de la taille for i in range (n-1 , p+1, -1) :
pour i de n-1 à p faire (pas=-1) #décalage à droite T[i] = T[i-1]
T[i] ← T[i-1] T[p] = x
Fin pour
T[p] ← x #insertion de x
Fin insertion1

Insertion d’un élément x dans un vecteur T trié def insertion2 (,x ,n ,T) :
procedure insertion2 (x :entier ;@ n :entier ;@T :tab) i=0
i ← 0 while (t[i] <x) and (i<=n):
tantque (T[i]<x) ET (i<=n) faire #recherche position i =i+1
i ← i+1 n=n+1
Fin tantque for j in range (n-1 , i+2 , -1) :
n ← n+1 #modification de la taille T[j] = T[j-1]
pour j de n-1 à i+1 faire #décalage à droite T[ i] = x
T[j] ← T[j-1]
12
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Fin pour
T[i] ← x
Fin insertion2
Recherche séquentielle d’un élément x dans un tableau t def recherche1 (n,x,t):
fonction recherche1 (n,x :entier ; T :tab) :booleen i=0
i ← 0 exist=False
exist ← faux while (i<=n) and(exist==False):
repeter if t[i]==x :
si t[i]=x alors exist ← vrai fin si exist =True
i ← i+1 i=i+1
jusqu’à (exist) ou (i>n) return exist
retourner exist
fin recherche1
Recherche Dichotomique d’un élément x dans un tableau Trié def recherche2 (n,x,t):
function recherche2 (n ,x:entier ; T :tab) :booleen; g=0
g ← 0 d= n-1
d ← n-1 exist=False
exist ← faux while not ((exist) ou (g>d)):
répéter m ← (g+d) div 2
m ← (g+d) div 2 if t[m]==x :
si t[m]=x alors exist ← vrai exist ← vrai
sinon si T[m] < x alors g ← m+1 elif T[m] < x :
sinon d ← m-1 g ← m+1
fin si Else : d ← m-1
jusqu’à (exist) ou (g>d)
retourner exist return exist
fin recherche2
Eclater un vecteur T en deux vecteurs T1 & T2 def eclater(t,n,t1,t2):
procedure eclater (n :entier ;T :tab ; @ T1,T2 :tab ;@j,k :entier) j=0
K ← 0 k=0
J ← 0 for i in range (n):
pour i de 0 à n-1 faire if t[i]%2==0 :
t1[j]=t[i]
si T[i ] mod 2=0 alors
j=j+1
T1[j] ← T[i]
else :
j ← j+1 t2[k]=t[i]
Sinon k=k+1
T2[k ] ← T[i] return t1,t2,j,k
k ← k+1 fin si
fin pour
fin eclater

13
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023
Fusion de deux vecteurs triés T1 &T2 en un vecteur T def fusion (n1 ,n2 , T, T1,T2) :
procédure fusion (n1,n2 :entier ; @ T :tab ; T1,T2 :tab) i=0
i←0 j←0 k ← 0 j=0
tant que j≤n1 et k≤n2 faire k = 0
si T1[j]≤T2[k] alors while j≤n1 and k≤n2 :
T[i] ← T1[j] j ← j+1 if T1[j]≤T2[k] :
sinon T[i] = T1[j]
T[i] ← T2[k] k ← k+1 j = j+1
finsi else :
i ← i+1 T[i] ← T2[k]
fintantque k ← k+1
si j > n1 alors i = i+1
pour c de k a n2 faire if j > n1 :
t[ i ]←t2[c] for c in range (k ,n2+1):
i ← i +1 t[ i ]=t2[c]
fin pour i = i +1
sinon
pour c de j a n1 faire else :
t[ i ] ←t1[c] for c in range (j ,n1+1):
i ← i +1 t[ i ] =t1[c]
fin pour i = i +1
fin fusion return t

Mettre en ordre décroissant les éléments d’un vecteur t tri à bulles def tri_bulles(t,n):
Procedure tri_bulles(@t :tab ;n :entier) trié= True
repeter while trié:
trié ← Faux trié = False
pour i 1 à n-1 faire for i in range (n-1):
si t[i] < t[i+1] alors if t[i] < t[i+1]:
aux ← t[i] aux =t[i]
t[i]← t[i+1] t[i] = t[i+1]
t[i+1] ←aux t[i+1] = aux
trié ←vrai trié =True
fin si return t
fin pour
jusqu’à trié=Faux
fin tri_bulles
procedure tri_sel( n:entier; @ t:tab) tri par selection def ind_min( i,n,t ):
pour i de 1 à n-1 faire ind=i
min ← ind_min( i,n,t) for j in range(i+1, n+1):
si t[i] ≠t[min] alors if t[ind]>t[j] :
aux ← t[i] ind=j
t[i]← t[min] return ind
t[min] ←aux end;
Fin si def tri_sel( n, t):
Fin pour for i in range(1 , n):
Fin tri_sel min= ind_min( i,n,t)
fonction ind_min( i,n:ientier;t :tab): entier if t[i]!=t[min] :
ind←i aux = t[i]
pour j de i+1 à n faire t[i]= t[min]
si t[ind]>t[j] alors t[min] =aux
ind←j Return t
fin si
fin pour
retourner ind
fin ind_min
14
Réaliser par : mme Belhassen chedlia
 Fiche de révision Bac Scientifique 2023

15
Réaliser par : mme Belhassen chedlia