כיצד להוסיף ולחסר שתי מטריצות ב- C ++, Python ו- JavaScript

מטריצה ​​היא מערך מלבני של מספרים, סמלים או ביטויים המסודרים בשורות ועמודות. רשת מלבנית של מספרים משמשת בדרך כלל במתמטיקה, הנדסת חשמל ומדעי המחשב. מטריצות נוצרו במקור כדי לתאר את מערכת המשוואות הליניאריות.

כעת נעשה שימוש נרחב במטריצות בעיבוד תמונה, ניתוח גנטי, נתונים גדולים ותכנות. תוספת וחיסור של מטריצות הן שתי פעולות המטריצה ​​הנפוצות ביותר. במאמר זה תלמד כיצד להוסיף ולחסר שתי מטריצות.

כללים לתוספת מטריקס

פעל לפי הכללים הבאים כדי להוסיף שתי מטריצות:

• ניתן להוסיף שתי מטריצות רק אם הן מאותו הסדר.
• אם שתי המטריצות באותה הסדר, הוסף את האלמנטים המתאימים של שתי המטריצות כלומר הוסף את האלמנטים בעלי אותם מיקומים.

בדוגמה 1 ניתן להוסיף את המטריצות מכיוון שיש להן אותו סדר. בדוגמה 2, לא ניתן להוסיף את המטריצות מכיוון שאין אותן סדר.

תוכנית C ++ להוספת שתי מטריצות

להלן תוכנית C ++ להוספת שתי מטריצות:

// C ++ תוכנית להוספת שתי מטריצות





instagram viewer


#לִכלוֹל 
באמצעות std namespace;
// סדר המטריצה ​​הוא 3 x 3
# הגדר גודל 1 3
# הגדר גודל 2 3
// פונקציה להוספת מטריצות mat1 [] [] & mat2 [] [],
// ולאחסן את התוצאה בתוצאה מטריצה ​​[] []
void addMatrices (int mat1 [] [size2], int mat2 [] [size2], int result [] [size2])
{
עבור (int i = 0; i {
עבור (int j = 0; j {
תוצאה [i] [j] = mat1 [i] [j] + mat2 [i] [j];
}
}
}
// קוד נהג
int main ()
{
// מטריקס 1
int mat1 [size1] [size2] = {{9, 8, 7},
{6, 8, 0},
{5, 9, 2} };
// מטריקס שני
int mat2 [size1] [size2] = {{4, 7, 6},
{8, 8, 2},
{7, 3, 5} };
// מטריקס לאחסון התוצאה
תוצאת int [size1] [size2];
// קורא לפונקציה addMatrices ()
addMatrices (mat1, mat2, result);
cout << "mat1 + mat2 =" << endl;
// הדפסת סכום 2 המטריצות
עבור (int i = 0; i {
עבור (int j = 0; j {
cout << תוצאה [i] [j] << "";
}
cout << endl;
}
החזר 0;
}

תְפוּקָה:

mat1 + mat2 = 
13 15 13 
14 16 2 
12 12 7

תוכנית פייתון להוספת שתי מטריצות

להלן תוכנית פייתון להוספת שתי מטריצות:

# תוכנית פייתון להוספת שתי מטריצות
# סדר המטריצה ​​הוא 3 x 3
גודל 1 = 3
גודל 2 = 3
# פונקציה להוספת מטריצות mat1 [] [] & mat2 [] [],
# ושמור את התוצאה בתוצאת מטריצה ​​[] []
def addMatrices (mat1, mat2, result):
עבור אני בטווח (גודל 1):
עבור j בטווח (גודל 2):
תוצאה [i] [j] = mat1 [i] [j] + mat2 [i] [j]
קוד הנהג
מטריקס # 1
mat1 = [[9, 8, 7],
[6, 8, 0],
[5, 9, 2] ]
מטריקס # 2
mat2 = [[4, 7, 6],
[8, 8, 2],
[7, 3, 5] ]
# מטריקס לאחסון התוצאה
תוצאה = mat1 [:] [:]
# קורא לפונקציה addMatrices
addMatrices (mat1, mat2, result)
# הדפסת סכום שתי המטריצות
הדפס ("mat1 + mat2 =")
עבור אני בטווח (גודל 1):
עבור j בטווח (גודל 2):
הדפס (תוצאה [i] [j], "", end = '')
הדפס()

תְפוּקָה:

mat1 + mat2 =
13 15 13
14 16 2
12 12 7

תוכנית ג להוספת שתי מטריצות

להלן תוכנית C להוספת שתי מטריצות:

// תוכנית C להוספת שתי מטריצות
#לִכלוֹל 
// סדר המטריצה ​​הוא 3 x 3
# הגדר גודל 1 3
# הגדר גודל 2 3
// פונקציה להוספת מטריצות mat1 [] [] & mat2 [] [],
// ולאחסן את התוצאה בתוצאה מטריצה ​​[] []
void addMatrices (int mat1 [] [size2], int mat2 [] [size2], int result [] [size2])
{
עבור (int i = 0; i {
עבור (int j = 0; j {
תוצאה [i] [j] = mat1 [i] [j] + mat2 [i] [j];
}
}
}
// קוד נהג
int main ()
{
// מטריקס 1
int mat1 [size1] [size2] = {{9, 8, 7},
{6, 8, 0},
{5, 9, 2} };
// מטריקס שני
int mat2 [size1] [size2] = {{4, 7, 6},
{8, 8, 2},
{7, 3, 5} };
// מטריקס לאחסון התוצאה
תוצאת int [size1] [size2];
// קורא לפונקציה addMatrices
addMatrices (mat1, mat2, result);
printf ("mat1 + mat2 = \ ⁠n");
// הדפסת סכום 2 המטריצות
עבור (int i = 0; i {
עבור (int j = 0; j {
printf ("% d", תוצאה [i] [j]);
}
printf ("\ ⁠n");
}
החזר 0;
}

תְפוּקָה:

mat1 + mat2 = 
13 15 13 
14 16 2 
12 12 7

תוכנית JavaScript להוספת שתי מטריצות

להלן תוכנית JavaScript להוספת שתי מטריצות:

תְפוּקָה:

mat1 + mat2 =
13 15 13
14 16 2
12 12 7

כללים לחיסור מטריקס

פעל לפי הכללים הבאים כדי להפחית שתי מטריצות:

• ניתן להפחית שתי מטריצות רק אם הן מאותו הסדר.
• אם שתי המטריצות באותה הסדר, חיסר את האלמנטים המתאימים של שתי המטריצות דהיינו, חיסר את האלמנטים בעלי אותם מיקומים.

בדוגמה 1 ניתן לחסר את המטריצות מכיוון שיש להן אותו סדר. בדוגמה 2, לא ניתן להפחית את המטריצות מכיוון שאין להן אותו סדר.

תוכנית C ++ לחיסור שתי מטריצות

להלן תוכנית C ++ להפחתת שתי מטריצות:

קָשׁוּר: אתרים אלה יעזרו לך ללמוד תכנות C ++

// C ++ תוכנית לחיסור שתי מטריצות
#לִכלוֹל 
באמצעות std namespace;
// סדר המטריצה ​​הוא 3 x 3
# הגדר גודל 1 3
# הגדר גודל 2 3
// פונקציה להפחתת מטריצות mat1 [] [] & mat2 [] [],
// ולאחסן את התוצאה בתוצאה מטריצה ​​[] []
בטל להפחית מטריצות (int mat1 [] [size2], int mat2 [] [size2], int result [] [size2])
{
עבור (int i = 0; i {
עבור (int j = 0; j {
תוצאה [i] [j] = mat1 [i] [j] - mat2 [i] [j];
}
}
}
// קוד נהג
int main ()
{
// מטריקס 1
int mat1 [size1] [size2] = {{9, 8, 7},
{6, 8, 0},
{5, 9, 2} };
// מטריקס שני
int mat2 [size1] [size2] = {{4, 7, 6},
{8, 8, 2},
{7, 3, 5} };
// מטריקס לאחסון התוצאה
תוצאת int [size1] [size2];
// קורא לפונקציה subtractMatrices ()
subtractMatrices (mat1, mat2, result);
cout << "mat1 - mat2 =" << endl;
// הדפסת ההפרש של שתי המטריצות (mat1 - mat2)
עבור (int i = 0; i {
עבור (int j = 0; j {
cout << תוצאה [i] [j] << "";
}
cout << endl;
}
החזר 0;
}

תְפוּקָה:

mat1 - mat2 = 
5 1 1 
-2 0 -2 
-2 6 -3

תוכנית פייתון להפחתת שתי מטריצות

להלן תוכנית פייתון להפחתת שתי מטריצות:

# תוכנית פייתון לחיסור שתי מטריצות
# סדר המטריצה ​​הוא 3 x 3
גודל 1 = 3
גודל 2 = 3
# פונקציה להפחתת מטריצות mat1 [] [] & mat2 [] [],
# ושמור את התוצאה בתוצאת מטריצה ​​[] []
def subtractMatrices (mat1, mat2, result):
עבור אני בטווח (גודל 1):
עבור j בטווח (גודל 2):
תוצאה [i] [j] = mat1 [i] [j] - mat2 [i] [j]
קוד הנהג
מטריקס # 1
mat1 = [[9, 8, 7],
[6, 8, 0],
[5, 9, 2] ]
מטריקס # 2
mat2 = [[4, 7, 6],
[8, 8, 2],
[7, 3, 5] ]
# מטריקס לאחסון התוצאה
תוצאה = mat1 [:] [:]
# קריאה לפונקציה subtractMatrices
subtractMatrices (mat1, mat2, result)
# הדפסת ההפרש של שתי המטריצות (mat1 - mat2)
הדפס ("mat1 - mat2 =")
עבור אני בטווח (גודל 1):
עבור j בטווח (גודל 2):
הדפס (תוצאה [i] [j], "", end = '')
הדפס()

תְפוּקָה:

mat1 - mat2 =
5 1 1
-2 0 -2
-2 6 -3

תוכנית ג לחיסור שתי מטריצות

להלן תוכנית C להפחתת שתי מטריצות:

קָשׁוּר: מאפייני תכנות C ההופכים אותו לייחודי (וטוב יותר)

// תוכנית C לחיסור שתי מטריצות
#לִכלוֹל 
// סדר המטריצה ​​הוא 3 x 3
# הגדר גודל 1 3
# הגדר גודל 2 3
// פונקציה להפחתת מטריצות mat1 [] [] & mat2 [] [],
// ולאחסן את התוצאה בתוצאה מטריצה ​​[] []
בטל להפחית מטריצות (int mat1 [] [size2], int mat2 [] [size2], int result [] [size2])
{
עבור (int i = 0; i {
עבור (int j = 0; j {
תוצאה [i] [j] = mat1 [i] [j] - mat2 [i] [j];
}
}
}
// קוד נהג
int main ()
{
// מטריקס 1
int mat1 [size1] [size2] = {{9, 8, 7},
{6, 8, 0},
{5, 9, 2} };
// מטריקס שני
int mat2 [size1] [size2] = {{4, 7, 6},
{8, 8, 2},
{7, 3, 5} };
// מטריקס לאחסון התוצאה
תוצאת int [size1] [size2];
// קורא לפונקציה subtractMatrices ()
subtractMatrices (mat1, mat2, result);
printf ("mat1 - mat2 = \ ⁠n");
// הדפסת ההפרש של שתי המטריצות (mat1 - mat2)
עבור (int i = 0; i {
עבור (int j = 0; j {
printf ("% d", תוצאה [i] [j]);
}
printf ("\ ⁠n");
}
החזר 0;
}

תְפוּקָה:

mat1 - mat2 = 
5 1 1 
-2 0 -2 
-2 6 -3

תוכנית JavaScript להפחתת שתי מטריצות

להלן תוכנית JavaScript להפחתת שתי מטריצות:

תְפוּקָה:

mat1 - mat2 =
5 1 1
-2 0 -2
-2 6 -3

אם אתה רוצה להסתכל על קוד המקור השלם המשמש במאמר זה, הנה מאגר GitHub.

קָשׁוּר: קידוד אתגרים ותחרויות העלולים להוביל לכסף או למשרות

הגדל את יכולת התכנות שלך

תוכל להגדיל את יכולת התכנות שלך על ידי תרגול של מגוון בעיות תכנות. פתרון בעיות תכנות אלה מסייע לך לפתח עקרונות תכנות בסיסיים. אלה חובה לדעת אם ברצונך להיות מתכנת יעיל.

יובראג 'צ'נדרה (19 מאמרים פורסמו)

יובראג 'הוא סטודנט לתואר ראשון במדעי המחשב באוניברסיטת דלהי, הודו. הוא נלהב מפיתוח אתרים של Full Stack. כשהוא לא כותב, הוא בוחן את עומק הטכנולוגיות השונות.

עוד מאת יוברג 'צ'נדרה