כיצד למצוא את המוצר של כל האלמנטים במערך

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

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

הצהרת בעיה

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

דוגמה 1: תן arr = [1, 2, 3, 4, 5, 6, 7, 8]

התוצר של כל אלמנט במערך = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 = 40320

לפיכך, התפוקה היא 40320.

דוגמה 2: תן arr = [1, 1, 1, 1, 1, 1]

התוצר של כל אלמנט במערך = 1 * 1 * 1 * 1 * 1 * 1 = 1

לפיכך התפוקה היא 1.

גישה איטרטיבית למצוא את התוצר של כל מרכיבי המערך

תוכל למצוא את המוצר של כל האלמנטים במערך באמצעות איטרציה / לולאות על ידי ביצוע הגישה הבאה:

1. אתחל משתנה תוֹצָאָה (עם ערך 1) לאחסון המוצר של כל האלמנטים במערך.
2. חזר דרך המערך והכפל כל אלמנט במערך עם ה- תוֹצָאָה.
3. לבסוף, החזר את ה- תוֹצָאָה.

תוכנית C ++ למציאת תוצר של מרכיבי מערך באמצעות לולאות

להלן תוכנית C ++ לאיתור תוצר של רכיבי מערך:

// C ++ תוכנית למציאת המוצר של רכיבי המערך
#לִכלוֹל 
באמצעות std namespace;
int findProduct (int arr [], גודל int)
{
תוצאה int = 1;
עבור (int i = 0; אני{
תוצאה = תוצאה * arr [i];
}
תוצאת החזרה;
}
בטל printArrayElements (int arr [], גודל int)
{
עבור (int i = 0; אני{
cout << arr [i] << "";
}
cout << endl;
}
int main ()
{
int arr1 [] = {1, 2, 3, 4, 5, 6, 7, 8};
int size1 = sizeof (arr1) / sizeof (arr1 [0]);
cout << "מערך 1:" << endl;
printArrayElements (arr1, size1);
cout << "מוצר של מרכיבי המערך:" << findProduct (arr1, size1) << endl;
int arr2 [] = {1, 1, 1, 1, 1, 1};
int size2 = sizeof (arr2) / sizeof (arr2 [0]);
cout << "מערך 2:" << endl;
printArrayElements (arr2, size2);
cout << "מוצר של מרכיבי המערך:" << findProduct (arr2, size2) << endl;
החזר 0;
}

תְפוּקָה:

מערך 1:
1 2 3 4 5 6 7 8 
תוצר של רכיבי המערך: 40320
מערך 2:
1 1 1 1 1 1 
תוצר של רכיבי המערך: 1

תוכנית פייתון למציאת תוצר של רכיבי מערך באמצעות לולאות

להלן תוכנית פייתון לאיתור תוצר של רכיבי מערך:

# תוכנית פייתון לאיתור תוצר של רכיבי הרשימה
def find מוצר (arr, גודל):
תוצאה = 1
עבור אני בטווח (גודל):
תוצאה = תוצאה * arr [i]
תוצאת החזרה
def printListElements (arr, גודל):
עבור אני בטווח (גודל):
הדפס (arr [i], end = "")
הדפס()
arr1 = [1, 2, 3, 4, 5, 6, 7, 8]
size1 = len (arr1)
הדפס ("מערך 1:")
printListElements (arr1, size1)
הדפס ("מוצר של רכיבי המערך:", findProduct (arr1, size1))
arr2 = [1, 1, 1, 1, 1, 1]
size2 = len (arr2)
הדפס ("מערך 2:")
printListElements (arr2, size2)
הדפס ("מוצר של רכיבי המערך:", findProduct (arr2, size2))

קָשׁוּר: כיצד להשתמש עבור לולאות בפייתון

תְפוּקָה:

מערך 1:
1 2 3 4 5 6 7 8 
תוצר של רכיבי המערך: 40320
מערך 2:
1 1 1 1 1 1 
תוצר של רכיבי המערך: 1

תוכנית JavaScript למציאת תוצר של רכיבי מערך באמצעות לולאות

להלן תוכנית JavaScript למציאת תוצר של רכיבי מערך:

// תוכנית JavaScript למציאת המוצר של רכיבי המערך
פונקציה findProduct (arr, גודל) {
תן לתוצאה = 1;
עבור (תן i = 0; אניתוצאה = תוצאה * arr [i];
}
תוצאת החזרה;
}
function printArrayElements (arr, size) {
עבור (תן i = 0; אניdocument.write (arr [i] + "");
}
document.write ("
");
}
var arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
var size1 = arr1.length;
document.write ("מערך 1:" + "
");
printArrayElements (arr1, size1);
document.write ("מוצר של רכיבי המערך:" + findProduct (arr1, size1) + "
");
var arr2 = [1, 1, 1, 1, 1, 1];
var size2 = arr2.length;
document.write ("מערך 2:" + "
");
printArrayElements (arr2, size2);
document.write ("מוצר של רכיבי המערך:" + findProduct (arr2, size2) + "
");

תְפוּקָה:

מערך 1:
1 2 3 4 5 6 7 8 
תוצר של רכיבי המערך: 40320
מערך 2:
1 1 1 1 1 1 
תוצר של רכיבי המערך: 1

קָשׁוּר: שיטות מערך JavaScript שכדאי לך לשלוט בהן היום

תוכנית C למציאת תוצר של אלמנטים מערכים באמצעות לולאות

להלן תוכנית C למציאת תוצר של רכיבי מערך:

// תוכנית C לאיתור התוצר של רכיבי המערך
#לִכלוֹל 
int findProduct (int arr [], גודל int)
{
תוצאה int = 1;
עבור (int i = 0; אני{
תוצאה = תוצאה * arr [i];
}
תוצאת החזרה;
}
בטל printArrayElements (int arr [], גודל int)
{
עבור (int i = 0; אני{
printf ("% d", arr [i]);
}
printf ("\ ⁠n");
}
int main ()
{
int arr1 [] = {1, 2, 3, 4, 5, 6, 7, 8};
int size1 = sizeof (arr1) / sizeof (arr1 [0]);
printf ("מערך 1: \ ⁠n");
printArrayElements (arr1, size1);
printf ("מוצר של רכיבי המערך:% d \ ⁠n", findProduct (arr1, size1));
int arr2 [] = {1, 1, 1, 1, 1, 1};
int size2 = sizeof (arr2) / sizeof (arr2 [0]);
printf ("מערך 2: \ ⁠n");
printArrayElements (arr2, size2);
printf ("מוצר של רכיבי המערך:% d \ ⁠n", findProduct (arr2, size2));
החזר 0;
}

תְפוּקָה:

מערך 1:
1 2 3 4 5 6 7 8 
תוצר של רכיבי המערך: 40320
מערך 2:
1 1 1 1 1 1 
תוצר של רכיבי המערך: 1

גישה רקורסיבית למצוא את המוצר של כל האלמנטים במערך

אתה יכול למצוא את המוצר של כל האלמנטים במערך באמצעות רקורסיה על ידי ביצוע הפסאוד-קוד שלמטה:

פונקציה למצוא מוצר (arr, n):
אם n == 0:
החזר (arr [n])
אַחֵר:
החזר (arr [n] * findProduct (arr, n - 1))

קָשׁוּר: מה זה Pseudocode ואיך זה הופך אותך למפתח טוב יותר?

תוכנית C ++ למציאת תוצר של רכיבי מערך באמצעות רקורסיה

להלן תוכנית C ++ לאיתור תוצר של רכיבי מערך:

// C ++ תוכנית למציאת המוצר של רכיבי המערך באמצעות רקורסיה
#לִכלוֹל 
באמצעות std namespace;
int findProduct (int arr [], int n)
{
אם (n == 0)
{
החזרה (arr [n]);
}
אַחֵר
{
החזר (arr [n] * findProduct (arr, n - 1));
}
}
בטל printArrayElements (int arr [], גודל int)
{
עבור (int i = 0; אני{
cout << arr [i] << "";
}
cout << endl;
}
int main ()
{
int arr1 [] = {1, 2, 3, 4, 5, 6, 7, 8};
int size1 = sizeof (arr1) / sizeof (arr1 [0]);
cout << "מערך 1:" << endl;
printArrayElements (arr1, size1);
cout << "מוצר של מרכיבי המערך:" << findProduct (arr1, size1-1) << endl;
int arr2 [] = {1, 1, 1, 1, 1, 1};
int size2 = sizeof (arr2) / sizeof (arr2 [0]);
cout << "מערך 2:" << endl;
printArrayElements (arr2, size2);
cout << "מוצר של רכיבי המערך:" << findProduct (arr2, size2-1) << endl;
החזר 0;
}

תְפוּקָה:

מערך 1:
1 2 3 4 5 6 7 8 
תוצר של רכיבי המערך: 40320
מערך 2:
1 1 1 1 1 1 
תוצר של רכיבי המערך: 1

קָשׁוּר: מבוא לאלגוריתם של מיון הבועות

תוכנית פייתון למציאת תוצר של רכיבי מערך באמצעות רקורסיה

להלן תוכנית פייתון לאיתור תוצר של רכיבי מערך:

תוכנית Python # כדי למצוא את התוצר של רכיבי הרשימה באמצעות רקורסיה
def find מוצר (arr, n):
אם n == 0:
החזר (arr [n])
אַחֵר:
החזר (arr [n] * findProduct (arr, n - 1))
def printListElements (arr, גודל):
עבור אני בטווח (גודל):
הדפס (arr [i], end = "")
הדפס()
arr1 = [1, 2, 3, 4, 5, 6, 7, 8]
size1 = len (arr1)
הדפס ("מערך 1:")
printListElements (arr1, size1)
הדפס ("מוצר של רכיבי המערך:", findProduct (arr1, size1-1))
arr2 = [1, 1, 1, 1, 1, 1]
size2 = len (arr2)
הדפס ("מערך 2:")
printListElements (arr2, size2)
הדפס ("מוצר של רכיבי המערך:", findProduct (arr2, size2-1))

תְפוּקָה:

מערך 1:
1 2 3 4 5 6 7 8 
תוצר של רכיבי המערך: 40320
מערך 2:
1 1 1 1 1 1 
תוצר של רכיבי המערך: 1

קָשׁוּר: מבוא לאלגוריתם המיזוג למיזוג

תוכנית JavaScript למציאת תוצר של רכיבי מערך באמצעות רקורסיה

להלן תוכנית JavaScript למציאת תוצר של רכיבי מערך:

// תוכנית JavaScript למציאת המוצר של רכיבי המערך באמצעות רקורסיה
פונקציה findProduct (arr, n) {
אם (n == 0) {
החזרה (arr [n]);
} אחר {
החזר (arr [n] * findProduct (arr, n - 1));
}
}
function printArrayElements (arr, size) {
עבור (תן i = 0; אניdocument.write (arr [i] + "");
}
document.write ("
");
}
var arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
var size1 = arr1.length;
document.write ("מערך 1:" + "
");
printArrayElements (arr1, size1);
document.write ("מוצר של רכיבי המערך:" + findProduct (arr1, size1) + "
");
var arr2 = [1, 1, 1, 1, 1, 1];
var size2 = arr2.length;
document.write ("מערך 2:" + "
");
printArrayElements (arr2, size2);
document.write ("מוצר של רכיבי המערך:" + findProduct (arr2, size2) + "
");

תְפוּקָה:

מערך 1:
1 2 3 4 5 6 7 8 
תוצר של רכיבי המערך: 40320
מערך 2:
1 1 1 1 1 1 
תוצר של רכיבי המערך: 1

תוכנית C למציאת תוצר של אלמנטים מערכיים באמצעות רקורסיה

להלן תוכנית C למציאת תוצר של רכיבי מערך:

// תוכנית C למציאת תוצר של רכיבי המערך באמצעות רקורסיה
#לִכלוֹל 
int findProduct (int arr [], int n)
{
אם (n == 0)
{
החזרה (arr [n]);
}
אַחֵר
{
החזר (arr [n] * findProduct (arr, n - 1));
}
}
בטל printArrayElements (int arr [], גודל int)
{
עבור (int i = 0; אני{
printf ("% d", arr [i]);
}
printf ("\ ⁠n");
}
int main ()
{
int arr1 [] = {1, 2, 3, 4, 5, 6, 7, 8};
int size1 = sizeof (arr1) / sizeof (arr1 [0]);
printf ("מערך 1: \ ⁠n");
printArrayElements (arr1, size1);
printf ("מוצר של רכיבי המערך:% d \ ⁠n", findProduct (arr1, size1-1));
int arr2 [] = {1, 1, 1, 1, 1, 1};
int size2 = sizeof (arr2) / sizeof (arr2 [0]);
printf ("מערך 2: \ ⁠n");
printArrayElements (arr2, size2);
printf ("מוצר של רכיבי המערך:% d \ ⁠n", findProduct (arr2, size2-1));
החזר 0;
}

תְפוּקָה:

מערך 1:
1 2 3 4 5 6 7 8 
תוצר של רכיבי המערך: 40320
מערך 2:
1 1 1 1 1 1 
תוצר של רכיבי המערך: 1

לחזק את מושגי המערך שלך

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

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

כיצד למצוא את סכום כל האלמנטים במערך

בין אם אתה משתמש ב- JavaScript, Python או C ++, תוכניות אלה בהחלט מסתכמות.

קרא הבא

על הסופר