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 ValueError
Arnold

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 ValueError
Puco

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 ValueError
P4radigmShift

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_mat
Romu80

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é