4eme SC, Tech et Math Analyse modulaire [Link].

tn
Exercice 1:
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de :
-Saisir un tableau T1 par N chaines (2<=N<=25)
-Convertir toutes les chaines obtenues en majuscules puis les mettre dans un tableau T2
-Afficher le tableau T2
Exemple :Pour le tableau T1 suivant, avec n=3 :

Ahmed mahdi la1

Le programme affiche :

AHMED MAHDI LA1

Exercice 2
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de :
-Saisir un tableau T1 par N entiers de deux chiffres (2<=N<=10)
-Chercher tous les diviseurs de chaque élément du tableau puis les mettre dans un tableau T2
-Afficher le tableau T2
Exemple :Pour le tableau T1 suivant, avec n=3 :
6 43 5

Le programme affiche :

12 44 6

Exercice 3:
Ecrire un algorithme et son implémentation en Python d’un programme qui permet de :
-Saisir un tableau T1 par N entiers (2<=N<=10)
-Chercher tous les entiers premiers de chaque élément du tableau puis les mettre dans un
tableau T2
-Afficher le tableau T2
Exemple :Pour le tableau T1 suivant, avec n=6 :
10 2 18 7 43 10

1
Le programme affiche :

2 7 43

Exercice 4:
Ecrire un script en Python qui permet de :
A/-Saisir aléatoirement un tableau T1 par N entiers de deux chiffres (2<=N<=10)
B/-Chercher la valeur maximale de ce tableau
Exemple :
Pour le tableau T1 suivant, avec n=6 :
10 12 18 17 43 10

Le programme affiche :

La valeur maximale est : 43

C/-Saisir deux indices i et j puis permuter les deux éléments du tableau d’indice i et j
Exemple :
Donner i : 0

Donner j : 2

Le nouveau tableau après permutation de t[0] et t[2] est

18 12 10 17 43 10

D/-Vérifier l’existence d’un élément e dans le tableau

Exemple

Donner l’élément à rechercher : 23

False

2
Exercice 5
A/Ecrire un programme qui permet de saisir un entier N puis de déterminer la nature de cet
entier pair ou impaire(Routrner une chaine de caractère ‘pair’ ou ‘impair’).
C/Répondre en A mais retourner True si pair ou False dans le cas contraire
D/Redéfinir la fonction estnum() (verifier si une chaine est numérique ou non)
E/ Ecrire l’algorithme et l’implémentation en Python d’un programme qui permet de :
-Remplir un tableau T de n chaines de caractères( n>3) de longueur 5 caractères maximum
-Afficher les chaines composés uniquement par des chiffres
Exemple
T
‘1014’ ‘A29’ ‘5L79’ ‘20’
Alors on affiche
‘1014’
‘20’
F/Définir une fonction qui détermine si une chaine se compose par des caractères minuscules
ou non.
Exercice 6
Soit à saisir les moyennes de n élèves (10<=n<=30) dans un tableau. Il s’agit de trouver puis
d’afficher le nombre d’élèves qui ont réussi.
Fonction saisir n :
Fonction remplir le tableau :
Fonction Nombre :

Programme
principal

Module Module
Module
…….. ……
……..

Module Module
Module
……. …….
…….
3
Correction exercice 1

Programme
principal

Module Module
RemplirT1() Afficher()

fonction
upper()

from numpy import array def remplirT2(T1,n):

def saisirN(): T2=array([str]*n)

valide=False for i in range(n):

while valide==False: T2[i]=T1[i].upper()

n=int(input('Taille tableau ')) return T2

valide=2<=n<=25 def afficher(t,n):

return n for i in range(n):

def remplirT1(n): print(t[i])

T1=array([str]*n) #programme principale

for i in range(n): n=saisirN()

T1[i]=str(input('Donner element du tableau ')) T1=remplirT1(n)

return T1 afficher(T1,n)
T2=remplirT2(T1,n)
afficher(T2,n)

4
 Algorithmique Implémentation en python
1. Programme principal #programme principale
Algorithme Ex1 n=saisirN()
Debut T1=remplirT1(n)
saisirN(n) afficher(T1,n)
RemplirT1(T1,n) T2=remplirT2(T1,n)
afficher(T1,n) afficher(T2,n)
remplirT2(T2,T1,n)
afficher(T2,n)
Fin

[Link] de declarations des nouveaux types (T.D.N.T)

Type
Tab = tableau de 25 chaines
3. Tableau de declarations des objets globaux
(T.D.O.G)

Objet Type /
Nature
T1 Tab
T2 Tab
n Entier

Algorithmique Implémentation en python

4. Procedure « saisirN » : def saisirN():
Procedure saisirN(@n :entier) valide=False
Debut while valide==False:
Repeter n=int(input('Taille tableau '))
Ecrire (‘’Taille tableau ‘’) valide=2<=n<=25
Lire (n) return n
Jusqu’à 2<=n<=25)
Fin

5
 Algorithmique Implémentation en python
def remplirT1(n):
5. Procedure « remplirT1 » : T1=array([str]*n)
Procedure remplirT1 (@t : Tab,n :entier) for i in range(n):
Debut t[i]=input(‘'Donner element
Pour i de 0 à n-1 faire du tableau :’)
Ecrire (‘’ 'Donner element du tableau : ‘’) return T1
Lire (t[i]) TDO Locaux
Fin Pour
Objet Type/Nature
Fin
i Entier

Algorithmique Implémentation en python

6. Procedure « remplirT2 » : def remplirT2(T2,n):

Procedure remplirT2 (@T2 : Tab,t1 :tab,n :entier) T2=array([str]*n)
Debut for i in range(n):
Pour i de 0 à n-1 faire TDO Locaux
T2[i]=T1[i].upper()
T2[i]majus(t1[i]) Objet Type/Nature return T2
Fin Pour i Entier
Fin

Algorithmique Implémentation en python

def afficher(t,n):
7. Procedure « afficher » : for i in range(n):
Procedure afficher (t : Tab,n :entier) print(t[i])
Debut
Pour i de 0 à n-1 faire
TDO Locaux
Ecrire (t[i])
Objet Type/Nature
Fin Pour i Entier
Fin

Exercice 2

6
 Algorithmique Implémentation en python
1 Programme principal #programme principale
Algorithme Ex1 n=saisirN()
Debut T1=remplirT1(n)
saisirN(n) T2=remplirT2(T1,n)
RemplirT1(T1,n) afficher(T2,n)
remplirT2(T2,T1,n)
afficher(T2,n)
Fin

Tableau de declarations des nouveaux types (T.D.N.T)

Type
Tab = tableau de 25 chaines
2. Tableau de declarations des objets globaux
(T.D.O.G)

Objet Type /
Nature
T1 Tab
T2 Tab
n Entier

Algorithmique Implémentation en python

3. Procedure « saisirN » : def saisirN():
Procedure saisirN(@n :entier) valide=False
Debut while valide==False:
Repeter n=int(input('Taille tableau '))
Ecrire (‘’Taille tableau ‘’) valide=2<=n<=10
Lire (n) return n
Jusqu’à 2<=n<=10)
Fin

7
 Algorithmique Implémentation en python
def remplirT1(n):
4. Procedure « remplirT1 » : T1=array([str]*n)
Procedure remplirT1 (@t : Tab,n :entier) for i in range(n):
Debut while valide==False:
Pour i de 0 à n-1 faire t[i]=int(input(''Donner element du tableau : '))
Repeter valide=10<=t[i]<=99
Ecrire (‘’ Donner element du tableau : ‘’) return T1
Lire (t[i]) TDO Locaux
Jusqu’à 10<=t[i]<=99
Objet Type/Nature
Fin Pour
Fin i Entier

Algorithmique Implémentation en python

5. Fonction « diviseur » : def diviseur(n):

Fonction divideur (n :entier) s=0
Debut for i in range (1,N+1):
S0 TDO Locaux
if n%i==0:
for i in range (1,N+1): Objet Type/Nature s=s+i
if n%i=0: i Entier return s
ss+i s Entier
retourner s
Fin

8
 Algorithmique Implémentation en python

6. Procedure « remplirT2 » : def remplirT2(T2,n):

Procedure remplirT2 (@T2 : Tab,t1 :tab,n :entier) T2=array([str]*n)
Debut for i in range(n):
Pour i de 0 à n-1 faire TDO Locaux
T2[i]=diviseur(T1[i])
T2[i]diviseur(t1[i]) Objet Type/Nature return T2
Fin Pour i Entier
Fin

Algorithmique Implémentation en python

def afficher(t,n):
7. Procedure « afficher » : for i in range(n):
Procedure afficher (t : Tab,n :entier) print(t[i])
Debut
Pour i de 0 à n-1 faire
TDO Locaux
Ecrire (t[i])
Objet Type/Nature
Fin Pour i Entier
Fin

Exercice 3

Algorithmique Implémentation en python

Procedure « saisirN » : def saisirN():
Procedure saisirN(var n :entier) valide=False
Debut while valide==False:
Repeter n=int(input('Taille tableau '))
Ecrire (‘’Taille tableau ‘’) valide=2<=n<=10
return n
Lire (n)
Jusqu’à 2<=n<=10)
Fin

9
 Algorithmique Implémentation en python
def remplirT1(n):
Procedure « remplirT » : T1=array([str]*n)
Procedure remplirT (@t : Tab,n :entier) for i in range(n):
Debut t[i]=input(‘'Donner element du tableau :’)
Pour i de 0 à n-1 faire return T1
Ecrire (‘’ 'Donner element du tableau : ‘’)
Lire (t[i])
Fin Pour
Fin

TDO Locaux
Objet Type/Nature
i Entier

Algorithmique Implémentation en python

8. Programme principal #programme principale
Algorithme principal n=saisirN()
Debut T1=remplirT1(n)
saisirN(n) afficher(T1,n)
T2=remplirT2(T1,n)
remplirT(T,n) afficher(T2,n)
afficher(T,n)
Fin
[Link] de declarations des nouveaux types (T.D.N.T)

Type
Tab = tableau de n entiers
8. Tableau de declarations des objets globaux
(T.D.O.G)

Objet Type /
Nature
n entier
T Tab
saisir procedure
remplir procedure
afficher procedure

10
 Algorithmique Python

Procedure « afficher » : def afficher (t,n):

for i in range(n):
Procedure afficher (t : Tab,n :entier) if (premier(t[i])):
Debut print(t[i])
Pour i de 0 à n-1 faire
Si (premier(t[i])==vrai )alors
Ecrire (t[i])
Fin Si
Fin Pour
Fin
TDO Locaux
Objet Type/Nature
i Entier
premier fonction

Algorithmique Implémentation en python

Fonction « premier » : def premier(n):

Fonction premier (n :entier) :booleen valide= False
Debut somme=0
valide Faux for i in range(1,n+1):
Somme0 if n % i==0 :
Pour i de 1 a n faire somme=somme+1
Si n mod i==0 alors TDO Locaux if somme==2 :
sommesomme+1 Objet Type/Nature valide=True
FinSi return valide
Si somme==2 alors i Entier
valideVrai Somme Entier
FinSi valide Booleen
retourner valide
Fin

11
Exercice 4 :
from numpy import *
from random import randint

def saisir(): # fonction saisir n et remplir t1

valide = False
while valide == False:
n = int(input('Donner n'))
valide = 2 <= n <= 10
return n

def remplir(n): # fonction afficher tableau

t= array([int()] * n)
for i in range(n):
t[i] = randint(10, 99)
return t

def afficher(t, n): # procedure afficher tableau

for i in range(n):
print('t[', i, '] :', t[i])

def maximal(t, n): # fonction chercher la valeur maximale

maxi = t[0]
for i in range(n):
if t[i] > maxi:
maxi = t[i]
return maxi

def permuter(t, i, j): # Module permuter deux éléments

a = t[i]
t[i] = t[j]
t[j] = a

def verif(t1, e): # Module vérifier existence de e dans le tableau

valide = False
for i in range(n):
if t1[i] == e:
valide = True
return valide

12
n = saisir() # appel du module saisir
t1 = remplir(n)
afficher(t1, n) # appel du module afficher
print(' max :',maximal(t1, n))# appel du module maximale

valide = False
while valide == False:
i = int(input(' Donner indice i'))
j = int(input(' Donner indice j'))
valide = (i < n) and (j < n)

permuter(t1, i, j) # appel du module permuter

afficher(t1, n) ##appel du module afficher
e = int(input(' Donner element à chercher'))
print(verif(t1, e)) # appel du module verif

13