כיצד למצוא את LCM ו- GCD של שני מספרים בשפות מרובות

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

אלגוריתמים מתמטיים הם גם נושא חשוב מאוד לראיונות תכנות. במאמר זה תלמד כיצד למצוא GCD ו- LCM של שני מספרים באמצעות C ++, Python, C ו- JavaScript.

כיצד למצוא את ה- GCD של שני מספרים

המחלק המשותף הגדול ביותר (GCD) או הגורם המשותף הגבוה ביותר (HCF) של שני מספרים הוא המספר השלם החיובי הגדול ביותר המחלק באופן מושלם בין שני המספרים הנתונים. אתה יכול למצוא את ה- GCD של שני מספרים באמצעות האלגוריתם האוקלידי.

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

לדוגמה, אם ברצונך למצוא את ה- GCD של 75 ו -50, עליך לבצע את השלבים הבאים:

• חלק את המספר הגדול יותר במספר הקטן וקח את השאר.

75 % 50 = 25

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

50 % 25 = 0

• כעת, השאר הופך ל- 0, ולכן ה- GCD של 75 ו- 50 הוא 25.

תוכנית C ++ למציאת ה- GCD של שני מספרים

להלן תוכנית C ++ לאיתור ה- GCD של שני מספרים:

// C ++ תוכנית למציאת GCD / HCF של 2 מספרים





instagram viewer


#לִכלוֹל 
באמצעות std namespace;
// פונקציה רקורסיבית לאיתור GCD / HCF של 2 מספרים
int לחשב GCD (int num1, int num2)
{
אם (מספר 2 == 0)
{
החזר מספר 1;
}
אַחֵר
{
להחזיר תשואה GCD (num2, num1% num2);
}
}
// קוד הנהג
int main ()
{
int num1 = 34, num2 = 22;
cout << "GCD של" << num1 << "ו-" << num2 << "הוא" << calcGCD (num1, num2) << endl;
int num3 = 10, num4 = 2;
cout << "GCD של" << num3 << "ו-" << num4 << "הוא" << calcGG (num3, num4) << endl;
int num5 = 88, num6 = 11;
cout << "GCD of" << num5 << "and" << num6 << "is" << calcGCD (num5, num6) << endl;
int num7 = 40, num8 = 32;
cout << "GCD של" << num7 << "ו-" << num8 << "הוא" << calcGGCD (num7, num8) << endl;
int num9 = 75, num10 = 50;
cout << "GCD של" << num9 << "ו-" << num10 << "הוא" << calcGG (num9, num10) << endl;
החזר 0;
}

תְפוּקָה:

GCD של 34 ו -22 הוא 2
GCD של 10 ו- 2 הוא 2
GCD של 88 ו -11 הוא 11
GCD של 40 ו -32 הוא 8
GCD של 75 ו- 50 הוא 25

תוכנית פייתון למציאת ה- GCD של שני מספרים

להלן תוכנית פייתון לאיתור ה- GCD של שני מספרים:

קָשׁוּר: מהי רקורסיה ואיך משתמשים בה?

# תוכנית פייתון למציאת GCD / HCF של 2 מספרים
def לחשב GCD (num1, num2):
אם מספר 2 == 0:
החזר מספר 1
אַחֵר:
להחזיר תשואה GCD (num2, num1% num2)
# קוד נהג
מספר 1 = 34
מספר 2 = 22
הדפס ("GCD of", num1, "ו-", num2, "is", calcGCD (num1, num2))
מספר 3 = 10
מספר 4 = 2
הדפס ("GCD of", num3, "ו-", num4, "is", calcGGCD (num3, num4))
מספר 5 = 88
מספר 6 = 11
הדפס ("GCD of", num5, "ו-", num6, "is", calcGCD (num5, num6))
מספר 7 = 40
מספר 8 = 32
הדפס ("GCD of", num7, "ו-", num8, "is", calcGCD (num7, num8))
מספר 9 = 75
מספר 10 = 50
הדפס ("GCD of", num9, "ו-", num10, "is", calcGGCD (num9, num10))

תְפוּקָה:

GCD של 34 ו -22 הוא 2
GCD של 10 ו- 2 הוא 2
GCD של 88 ו -11 הוא 11
GCD של 40 ו -32 הוא 8
GCD של 75 ו- 50 הוא 25

תוכנית ג למציאת ה- GCD של שני מספרים

להלן תוכנית C למציאת ה- GCD של שני מספרים:

// תוכנית C למציאת GCD / HCF של 2 מספרים
#לִכלוֹל 
// פונקציה רקורסיבית לאיתור GCD / HCF של 2 מספרים
int לחשב GCD (int num1, int num2)
{
אם (מספר 2 == 0)
{
החזר מספר 1;
}
אַחֵר
{
להחזיר תשואה GCD (num2, num1% num2);
}
}
// קוד הנהג
int main ()
{
int num1 = 34, num2 = 22;
printf ("GCD של% d ו-% d הוא% d \ ⁠⁠n", num1, num2, calcGCD (num1, num2));
int num3 = 10, num4 = 2;
printf ("GCD של% d ו-% d הוא% d \ ⁠⁠n", num3, num4, calcGCD (num3, num4));
int num5 = 88, num6 = 11;
printf ("GCD של% d ו-% d הוא% d \ ⁠⁠n", num5, num6, calcGG (num5, num6));
int num7 = 40, num8 = 32;
printf ("GCD של% d ו-% d הוא% d \ ⁠⁠n", num7, num8, calcGCD (num7, num8));
int num9 = 75, num10 = 50;
printf ("GCD של% d ו-% d הוא% d \ ⁠⁠n", num9, num10, calcGCD (num9, num10));
החזר 0;
}

תְפוּקָה:

GCD של 34 ו -22 הוא 2
GCD של 10 ו- 2 הוא 2
GCD של 88 ו -11 הוא 11
GCD של 40 ו -32 הוא 8
GCD של 75 ו- 50 הוא 25

תוכנית JavaScript למציאת ה- GCD של שני מספרים

להלן ה- JavaScript תוכנית למציאת ה- GCD של שני מספרים:

// תוכנית JavaScript למציאת GCD / HCF של 2 מספרים
// פונקציה רקורסיבית לאיתור GCD / HCF של 2 מספרים
פונקציה calcGCD (num1, num2) {
אם (מספר 2 == 0)
{
החזר מספר 1;
}
אַחֵר
{
להחזיר תשואה GCD (num2, num1% num2);
}
}
// קוד הנהג
var num1 = 34, num2 = 22;
document.write ("GCD של" + num1 + "ו-" + num2 + "הוא" + חישוב GCD (num1, num2) + "
");
var num3 = 10, num4 = 2;
document.write ("GCD של" + num3 + "ו-" + num4 + "הוא" + חישוב GCD (num3, num4) + "
");
var num5 = 88, num6 = 11;
document.write ("GCD של" + num5 + "ו-" + num6 + "הוא" + חישוב GCD (num5, num6) + "
");
var num7 = 40, num8 = 32;
document.write ("GCD של" + num7 + "ו-" + num8 + "הוא" + חישוב GCD (num7, num8) + "
");
var num9 = 75, num10 = 50;
document.write ("GCD של" + num9 + "ו-" + num10 + "הוא" + חשב GCD (num9, num10) + "
");

תְפוּקָה:

GCD של 34 ו -22 הוא 2
GCD של 10 ו- 2 הוא 2
GCD של 88 ו -11 הוא 11
GCD של 40 ו -32 הוא 8
GCD של 75 ו- 50 הוא 25

כיצד למצוא את ה- LCM של שני מספרים

הכפולה הפחות נפוצה (LCM) של שני מספרים היא המספר החיובי הקטן ביותר הניתן לחלוקה מושלמת בשני המספרים הנתונים. אתה יכול למצוא את ה- LCM של שני מספרים באמצעות הנוסחה המתמטית הבאה:

num1 * num2 = LCM (num1, num2) * GCD (num1, num2)
LCM (num1, num2) = (num1 * num2) / GCD (num1, num2)

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

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

תוכנית C ++ למציאת ה- LCM של שני מספרים

להלן תוכנית C ++ לאיתור ה- LCM של שני מספרים:

// C ++ תוכנית למציאת LCM של 2 מספרים
#לִכלוֹל 
באמצעות std namespace;
// פונקציה רקורסיבית לאיתור LCM של 2 מספרים
int לחשב GCD (int num1, int num2)
{
אם (מספר 2 == 0)
{
החזר מספר 1;
}
אַחֵר
{
להחזיר תשואה GCD (num2, num1% num2);
}
}
int לחשב LCM (int num1, int num2)
{
החזר (מספר 1 / חישוב GCD (מספר 1, מספר 2)) * מספר 2;
}
// קוד הנהג
int main ()
{
int num1 = 34, num2 = 22;
cout << "LCM של" << num1 << "ו-" << num2 << "הוא" << calcLCLC (num1, num2) << endl;
int num3 = 10, num4 = 2;
cout << "LCM של" << num3 << "ו-" << num4 << "הוא" << calcLCLC (num3, num4) << endl;
int num5 = 88, num6 = 11;
cout << "LCM של" << num5 << "ו-" << num6 << "הוא" << calcLCLC (num5, num6) << endl;
int num7 = 40, num8 = 32;
cout << "LCM של" << num7 << "ו-" << num8 << "הוא" << calcLCLC (num7, num8) << endl;
int num9 = 75, num10 = 50;
cout << "LCM של" << num9 << "ו-" << num10 << "הוא" << calcLCLC (num9, num10) << endl;
החזר 0;
}

תְפוּקָה:

LCM של 34 ו- 22 הוא 374
LCM של 10 ו- 2 הוא 10
LCM של 88 ו- 11 הוא 88
LCM של 40 ו- 32 הוא 160
LCM של 75 ו- 50 הוא 150

תוכנית פייתון למציאת ה- LCM של שני מספרים

להלן תוכנית פייתון לאיתור ה- LCM של שני מספרים:

# תוכנית פייתון למציאת LCM של 2 מספרים
def לחשב GCD (num1, num2):
אם מספר 2 == 0:
החזר מספר 1
אַחֵר:
להחזיר תשואה GCD (num2, num1% num2)
def לחשב LCM (num1, num2):
החזר (מספר 1 // חישוב GCD (מספר 1, מספר 2)) * מספר 2
# קוד נהג
מספר 1 = 34
מספר 2 = 22
הדפס ("LCM of", num1, "ו-", num2, "is", calcLCLC (num1, num2))
מספר 3 = 10
מספר 4 = 2
הדפס ("LCM of", num3, "ו-", num4, "is", calcLCLC (num3, num4))
מספר 5 = 88
מספר 6 = 11
הדפס ("LCM of", num5, "ו-", num6, "is", calcLCLC (num5, num6))
מספר 7 = 40
מספר 8 = 32
הדפס ("LCM of", num7, "ו-", num8, "is", calcLCLC (num7, num8))
מספר 9 = 75
מספר 10 = 50
הדפס ("LCM of", num9, "ו-", num10, "is", calcLCLC (num9, num10))

תְפוּקָה:

LCM של 34 ו- 22 הוא 374
LCM של 10 ו- 2 הוא 10
LCM של 88 ו- 11 הוא 88
LCM של 40 ו- 32 הוא 160
LCM של 75 ו- 50 הוא 150

תוכנית ג למציאת ה- LCM של שני מספרים

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

// תוכנית C למציאת LCM של 2 מספרים
#לִכלוֹל 
// פונקציה רקורסיבית לאיתור LCM של 2 מספרים
int לחשב GCD (int num1, int num2)
{
אם (מספר 2 == 0)
{
החזר מספר 1;
}
אַחֵר
{
להחזיר תשואה GCD (num2, num1% num2);
}
}
int לחשב LCM (int num1, int num2)
{
החזר (מספר 1 / חישוב GCD (מספר 1, מספר 2)) * מספר 2;
}
// קוד הנהג
int main ()
{
int num1 = 34, num2 = 22;
printf ("LCM של% d ו-% d הוא% d \ ⁠n", num1, num2, חישובLCM (num1, num2));
int num3 = 10, num4 = 2;
printf ("LCM של% d ו-% d הוא% d \ ⁠n", num3, num4, calcLCLC (num3, num4));
int num5 = 88, num6 = 11;
printf ("LCM של% d ו-% d הוא% d \ ⁠n", num5, num6, calcLCLC (num5, num6));
int num7 = 40, num8 = 32;
printf ("LCM של% d ו-% d הוא% d \ ⁠n", num7, num8, calcLCLC (num7, num8));
int num9 = 75, num10 = 50;
printf ("LCM של% d ו-% d הוא% d \ ⁠n", num9, num10, calcLCLC (num9, num10));
החזר 0;
}

תְפוּקָה:

LCM של 34 ו- 22 הוא 374
LCM של 10 ו- 2 הוא 10
LCM של 88 ו- 11 הוא 88
LCM של 40 ו- 32 הוא 160
LCM של 75 ו- 50 הוא 150

תוכנית JavaScript למציאת ה- LCM של שני מספרים

להלן תוכנית JavaScript למציאת ה- LCM של שני מספרים:

// תוכנית JavaScript למציאת LCM של 2 מספרים
// פונקציה רקורסיבית לאיתור LCM של 2 מספרים
פונקציה calcGCD (num1, num2) {
אם (מספר 2 == 0)
{
החזר מספר 1;
}
אַחֵר
{
להחזיר תשואה GCD (num2, num1% num2);
}
}
פונקציה לחשבLCM (num1, num2)
{
החזר (מספר 1 / חישוב GCD (מספר 1, מספר 2)) * מספר 2;
}
// קוד הנהג
var num1 = 34, num2 = 22;
document.write ("LCM של" + num1 + "ו-" + num2 + "הוא" + חישוב LCM (num1, num2) + "
");
var num3 = 10, num4 = 2;
document.write ("LCM של" + num3 + "ו-" + num4 + "הוא" + חישובLCM (num3, num4) + "
");
var num5 = 88, num6 = 11;
document.write ("LCM של" + num5 + "ו-" + num6 + "הוא" + חישוב LCM (num5, num6) + "
");
var num7 = 40, num8 = 32;
document.write ("LCM של" + num7 + "ו-" + num8 + "הוא" + חישובLCM (num7, num8) + "
");
var num9 = 75, num10 = 50;
document.write ("LCM של" + num9 + "ו-" + num10 + "הוא" + חישובLCM (num9, num10) + "
");

תְפוּקָה:

LCM של 34 ו- 22 הוא 374
LCM של 10 ו- 2 הוא 10
LCM של 88 ו- 11 הוא 88
LCM של 40 ו- 32 הוא 160
LCM של 75 ו- 50 הוא 150

למידע נוסף על אלגוריתמים מתמטיים

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

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

5 שפות תכנות פונקציונליות שכדאי להכיר

רוצה לדעת יותר על תכנות? כדאי ללמוד על תכנות פונקציונלי ואילו שפות תכנות תומכות בכך.

קרא הבא

על הסופר