Suite série matrice

Exercice N°3 :
En python En
Algorithmique
import numpy as np
def saisir(): T.D.O.G
while True: Algorithme PP Objet T/N
l=int(input("donner nombre de lignes")) Debut L,C entier
if 2<l<=10: Saisir(L,C)
M Mat
break Remplir(L ,C,M)
while True: Affichage(M,L,C) Remplir Procedue
c=int(input("donner le nombre de colonne")) Fin Affichage
if 2<c<=10: Saisir
break
objet T/N
return(l,c)
M Tableau de 10*10 entier
def remplir(l,c): Procedure Saisir(@l,c :entier)
m=np.array([[(0)]*c]*l,dtype="int") Debut
for i in range(l): Repeter
for j in range(c): Ecrire(“donner le nb lignes”),lire(l)
while True: Jusqu’à 2<l<=10
m[i,j]=int(input("donner un nombre positif")) Repeter
if m[i,j]>0: Ecrire(“donner le nb colonnes”),lire(c)
break Jusqu’à 2<c<=10
return (m) Fin
Procedure Remplir(l,c :entier,@m :mat)
def somme(x): Debut
s=0 Pour I de 0 à l-1 faire
while x!=0: Pour j de 0 à c-1 faire
s=s+x%10 Repeter
x=x//10 Ecrire( "donner un nombre positif")
return (s) lire(m[i,j])
jusqu’à m[i,j]>0
def somme_ligne(m,i,nc): Fin pour
s=0 Fin pour
for k in range(0,nc): Fin
s+=somme(m[i,k]) T.D.L T .D.L
return(s) Objet T/N Objet T/N

def somme_col(m,j,nl):
I,j entier S entier
s=0
for k in range(0,nl):
s+=somme(m[k,j])
return(s)

def affichage(m,l,c): Fonction somme(x :entier):entier

for i in range(l): Debut
for j in range(c): S 0
if somme_ligne(m,i,c)==somme_col(m,j,l)==m[i,j]: Tant que x#0 faire
print("element",m[i,j],"ligne",i+1,"colonne",j+1) S S+ x MOD 10
x x DIV 10
#---------------pp-------------------# Fin tant que
L,C=saisir() Retourner (S)
M=remplir(L,C) Fin
affichage(M,L,C)
 Fonction somme_ligne(m :Mat,i ,nc :entier) :entier
Debut
S 0
Pour k de 0 à nc-1 faire
S S+somme(m[i,k])
Fin pour
Retourner(S)
Fin
Fonction somme_col(m :Mat,j ,nl :entier) :entier
Debut
S 0
Pour k de 0 à nl-1 faire
S S+somme(m[k,j])
Fin pour
Retourner(S)
Fin

Procedure affichage(m:Mat,l,c:entier)
Pour i de 0 àl-1 faire
Pour j de 0 à c-1 faire
Si somme_ligne(m,i,c)=somme_col(m,j,l) et
m[i,j]= somme_ligne(m,i,c ) alors
Ecrire("element",m[i,j],"ligne
",i+1,"colonne",j+1)
Fin si
Fin pour
Fin pour
Fin T.D.L
objet T/N
i,j entier
Somme_ligne Fonction
Somme_col

Exercice N°4
En python En Algorithmique
import numpy as np Algorithme PP
from random import* Debut T.D.O.G
def saisir(): Saisir(L,C) Objet T/N
while True: Remplir(M,L,C)
l=int(input("donner nombre de lignes")) Convertir(M,C,L) L,C entier
if 3<=l: Fin M Mat
break
while True: Remplir Procedure
c=int(input("donner le nombre de colonne")) Convertir
if c<=8: Saisir
break
return(l,c) Procedure Saisir(@l,c :entier)
Debut
def remplir(l,c): Repeter
m=np.array([[(0)]*c]*l,dtype="int") Ecrire(“donner le nb lignes”),lire(l)
for i in range(l): Jusqu’à 3<=l
for j in range(c):
Repeter
m[i,j]=randint(0,1)
return (m) Ecrire(“donner le nb colonnes”),lire(c)
Jusqu’à c<=8
def puissance(x,n): Fin
def puissance(x,n):
P=1 Procedure Remplir(l,c :entier,@m :mat)
for i in range(n): Debut
 P=P*x Pour i de 0 à l-1 faire
return P Pour j de 0 à c-1 faire
m[i,j] aléa(0,1)
def convertir(m,nc,nl): Fin pour
for i in range(nl): Fin pour
k,S=0,0 Fin
for j in range(nc-1,0,-1):
Fonction puissance (x,n :entier) :entier
S=S+(m[i,j]*puissance(2,k))
k+=1 Debut
print(S,"la forme decimale de",i,"ligne") P 1
#-------------------pp-------------------------# Pour i de 0 à n-1 faire
L,C=saisir() P P*x
M=remplir(L,C) Fin pour
convertir(M,C,L) Retourner (P)
Fin
Procedure Convertir(m :Mat,nc ,nl :entier)
Debut
Pour i de 0 à nl-1 faire
k 0
S 0
Pour j de (nc-1) à0 (pas=-1) faire
S S+m[i,j]*puissance(2,k)
k k+1
fin pour
Ecrire (S,“est la forme décimale de “,i,”ligne“)
Fin pour
Fin

Exercice N°5
En python En Algorithmique
import numpy as np Algorithme PP
def remplir1(): Debut T.D.O.G
while True: remplir1(M,NL,NC)
nl=int(input("donner nombre de lignes")) Objet T/N
remplir2(NC,T,N)
if 4<=nl<=20: nb_anag(M,T,N,NL,NC,TN) NL,NC,N entier
break affichage(TN,T,N) M Mat
while True:
nc=int(input("donner le nombre de colonne")) T.D.N.T Remplir1 Procedure
if 4<=nc<=20: objet T/N Remplir2
break Mat Tableau de 20*20 caracteres Nb_anag
m=np.array([[("")]*nc]*nl,dtype=(str,1)) affichage
for i in range(nl): Tabe Tableau de 20entier
T Tabc
for j in range(nc):
m[i,j]=chr(randint(65,90)) Tabc Tableau de 20 caracteres TN Tabe
return(m,nl,nc)
def verif(ch): Procedure remplir1 (@m :Mat,@nl,nc :entier)
i=0 Debut
while i<len(ch) and "A"<=ch[i]<="Z": Repeter
i+=1
Ecrire(“donner le nb lignes”),lire(nl)
return (i==len(ch))
def distinct(ch,n,T): Jusqu’à 4<=nl<=20
B=True Repeter
i=0 Ecrire(“donner le nb colonnes”),lire(nc)
while B==True and i<n: Jusqu’à 4<=nl<=20
if T[i]==ch: Pour i de 0 à l-1 faire
B=False Pour j de 0 à c-1 faire
else: m[i,j] chr(alea (65,90)))
i+=1 Fin pour
return B Fin pour
def remplir2(nc): Fin
while True : Procedure remplir2(nc :entier,@T:tabc,@n:entier)
n=int(input("donner le nombre de mots ")) Debut
if 4<=n<=20:
Repeter
break
 T=np.array([("")]*n,dtype=(str,nc)) Ecrire(“donner le nb lignes”),lire(nl)
while True: Jusqu’à 4<=nl<=20
T[0]=input("donner le premier mot") Repeter
if len(T[0])==nc and verif(T[0]): Ecrire("donner le premier mot"),lire(T[0])
break Jusqu’à long(T[0])=nc et verif(T[0])
for i in range(1,n): Pour i de 1 à n faire
while True :
Repeter
T[i]=input("donner un mot")
if len(T[i])==nc and verif(T[i])and distinct(T[i],i,T): Ecrire("donner un mot"),lire(T[i])
break Jusqu’à long(T[i])=nc et verif(T[i]) et distinct(T[i],i,T)
return (T,n) Fin pour
def nb_anag(m,T,n,nl,nc): Fin
TN=np.array([(0)]*nc,dtype="int") Fonction verif(ch:chaine):booleen
for i in range(nc): Debut
nb=0 i 0
j=0 tant que i<len(ch) et "A"<=ch[i]<="Z" faire
L=list((T[i])) i i+1
while m[i,j] in L and j<nc: fin tant que
j+=1 Retourner(i=len(ch))
if j==nc: Fin
nb+=1 Foncton distinct(ch :chaine,n :entier,T :Tabc):booleen
TN[i]=nb Debut
return(TN) B Vrai
def affichage(TN,T,n): i 0
Max,pmax=0,0 tant que B=Vrai et i<n faire
TN[0]=Max si T[i] =ch alors
for i in range(n): B faux
if TN[i]>Max: sinon
Max=T[i] i i+1
pmax=i fin si
print("le mot qui a le plus grand nombre d'anagramme fin tant que
est ",T[pmax],Max) Retourner(B)
#---------pp------# Fin
M,NL,NC=remplir1() Procedure
T,N=remplir2(NC) nb_anag(m :Mat,T :Tabc,n,nl,nc :entier,@TN:Tabe)
TN=nb_anag(M,T,N,NL,NC) Debut
affichage(TN,T,N) Pour i de 0 à nc-1 faire
nb 0
j 0
tant que pos(m[i,j],T[i])#-1 et j<nc faire
j j+1
fin tant que
si j=nc alors
nb nb+1
fin si
TN[i]=nb
Fin pour
Fin
Procedure affichage(TN :Tabe,T :Tabc,n :entier)
Debut
Max 0
pmax 0
TN[0] Max
Pour i de 0 à n-1 faire
si TN[i]>Max alors
Max T[i]
pmax i
fin si
fin pour
Ecrire("le mot qui a le plus grand nombre d'anagramme
est ",T[pmax],Max)
Fin