Dans cet exercice, vous devez créer une fonction addition_matrices capable d’additionner deux matrices. Les matrices seront représentées par des listes imbriquées. La fonction doit donc renvoyer une nouvelle matrice qui est le résultat de l’addition des deux matrices récupérées en paramètre. Attention, les deux matrices additionnées ne doivent pas être modifiées et le résultat doit être une nouvelle matrice.
Dans le cas où les deux matrices ne sont pas de la même dimension, c'est-à-dire qu’elles n’ont pas le même nombre de ligne et de colonne, l’addition ne pourra pas être réalisée et la fonction devra lever une erreur de type ValueError.
Exemples d’utilisation
matrice_a = [
[1, 2, 3],
[3, 7, 3]
]
matrice_b = [
[6, 4, 2],
[3, 1, 0]
]
>>> addition_matrices(matrice_a, matrice_b)
[[7, 6, 5], [6, 8, 3]]
matrice_a = [
[-9, 2],
[4, 0]
]
matrice_b = [
[6, 4, 2],
[3, 10, 0]
]
>>> addition_matrices(matrice_a, matrice_b)
ValueError
matrice_a = [
[1, 2, 3],
[3, 7, 3]
]
matrice_b = [
[6, 4, 2],
[3, 1, 0]
]
# Votre code ici 👇
def addition_matrices(matrice_a, matrice_b):
hauteur_matrice_a = len(matrice_a)
hauteur_matrice_b = len(matrice_b)
longueur_matrice_a = len(matrice_a[0])
longueur_matrice_b = len(matrice_b[0])
if hauteur_matrice_a == hauteur_matrice_b and longueur_matrice_a == longueur_matrice_b :
matrice_resultat = []
for hauteur in range(hauteur_matrice_b):
ligne = []
for longueur in range(longueur_matrice_b):
ligne.append(matrice_a[hauteur][longueur] + matrice_b[hauteur][longueur])
matrice_resultat.append(ligne)
return matrice_resultat
else :
raise ValueErrorArnold
matrice_a = [
[1, 2, 3],
[3, 7, 3]
]
matrice_b = [
[6, 4, 2],
[3, 1, 0]
]
# Votre code ici 👇
def addition_matrices(matrix_a, matrix_b):
h_a = len(matrix_a)
h_b = len(matrix_b)
l_a = len(matrix_a[0])
l_b = len(matrix_b[0])
if h_a == h_b and l_a == l_b:
return [[matrix_a[i][j] + matrix_b[i][j] for j in range(len(matrix_a[0]))] for i in range(len(matrix_a))]
else:
raise ValueErrorPuco
matrice_a = [
[1, 2, 3],
[3, 7, 3]
]
matrice_b = [
[6, 4, 2],
[3, 1, 0]
]
def addition_matrices(matrice_1, matrice_2):
if len(matrice_1) == len(matrice_2) and all([len(matrice_1[n]) == len(matrice_2[n]) for n in range(0, len(matrice_1), 1)]):
return list((list(n) for n in [map(lambda n1, n2: n1+n2, matrice_1[n], matrice_2[n]) for n in range(0, len(matrice_1), 1)]))
else:
raise ValueErrorP4radigmShift
matrice_a = [
[1, 2 ,0],
[3, 7 ,9]
]
matrice_b = [
[6, 4, 2],
[3, 1, 7]
]
# Votre code ici 👇
def addition_matrices(matrice_a:list , matrice_b:list) -> list:
if len(matrice_a) == len(matrice_b):
for i in range(len(matrice_a)):
res_matrice=matrice_a
if (len(matrice_a[i]) == len(matrice_b[i])):
for x in range(len(matrice_a[i])):
res_matrice[i][x] = matrice_a[i][x] + matrice_b[i][x]
else:
return 'pas le même nombre de colonne dans la ligne ' , i+1
return res_matrice
else:
return 'pas le même nombre de ligne'
print(addition_matrices(matrice_a , matrice_b))
SOUHAIL
matrice_a = [
[1, 2, 3],
[3, 7, 3]
]
matrice_b = [
[6, 4, 2],
[3, 1, 0]
]
# Votre code ici 👇
def addition_matrices(matrice_a, matrice_b):
if len(matrice_a) != len(matrice_b):
raise ValueError
for i, mat in enumerate(matrice_a):
if len(matrice_b[i]) != len(mat):
raise ValueError
new_mat = []
for i, mat in enumerate(matrice_b):
test = []
for j, num in enumerate(mat):
test.append(num + matrice_a[i][j])
new_mat.append(test)
return new_matRomu80
matrice_a = [
[1, 2, 3],
[3, 7, 3]
]
matrice_b = [
[6, 4, 2],
[3, 1, 0]
]
# Votre code ici 👇
def addition_matrices(matrice_a,matrice_b):
long_mat_a = len(matrice_a)
long_mat_a_int = len(matrice_a[0])
long_mat_b = len(matrice_b)
long_mat_b_int = len(matrice_b[0])
if (long_mat_a == long_mat_b) and (long_mat_a_int == long_mat_b_int):
matrice_tot = []
for i in range(long_mat_a):
index_ligne = []
for j in range(long_mat_a_int):
index_ligne.append(matrice_a[i][j] + matrice_b[i][j])
matrice_tot.append(index_ligne)
return matrice_tot
else:
raise ValueError
addition_matrices(matrice_a,matrice_b)
matrice_a = [
[1, 2, 3],
[3, 7, 3]
]
matrice_b = [
[6, 4, 2],
[3, 1, 0]
]
# Votre code ici 👇Un instant...
Test avec des matrices valides
La fonction doit être capable de renvoyer l'addition de deux matrices valides.
Test avec deux matrices n'ayant pas la même dimension
Vérification que l'erreur est bien levée lorsque les matrices ne sont pas de la même dimension.
Bravo, tu as réussi cet exercice de code 🥳
Soumettre ma solution
Vous avez trouvé une solution alternative pour cet exercice ? Proposez votre solution à la communauté 👇
Seules les propositions différentes de la solution proposée par Docstring peuvent être envoyées.
Ma solution :
Mes notes
Sauvegardé