במדריך זה, ננתח תבניות שונות כדי למצוא את ה-GCD עם שיטות ב-C++.
תוכנית C++ לאיתור GCD
ב-C++, כדי לקבל את המספר השלם החיובי הגדול ביותר שמחלק שני מספרים מסופקים מבלי להשאיר שארית כלשהי, השתמש ב-GCD (המחלק הגדול המשותף). זה מסייע בפישוט שברים ופתרון בעיות המערבות גורמים משותפים. הפונקציה GCD בתוכנית מחזירה את הגורם המשותף הגדול ביותר בין שני מספרי קלט שלמים.
C++ מספק מספר שיטות לחישוב ה-GCD של שני מספרים. כמה מהם מתוארים להלן.
שיטה 1: מצא את GCD באמצעות אלגוריתם אוקלידי ב-C++
ה ' אלגוריתם אוקלידי ” היא שיטה בשימוש נרחב ואמינה לקביעת ה-GCD של שני מספרים שונים. הוא מבוסס על העובדה שה-GCD עבור שני מספרים שלמים נשאר ללא שינוי אם מספר קטן יותר (מספר שלם) מופחת מהגדול יותר, וגישה זו נמשכת עד שכל אחד מהמספרים השלמים הופך לאפס.
בואו נסתכל על הדוגמה שלהלן, כאן אנו מוצאים את (GCD) של שני מספרים באמצעות האלגוריתם האוקלידי. ראשית, כלול את הספריות הנדרשות:
#include
באמצעות מרחב שמות סטד ;
כאן:
- '
קובץ הכותרת כולל את זרמי הקלט והפלט, המאפשרים פעולות קלט ופלט. - ' באמצעות מרחב שמות std ” היא הנחיה שמקלה על השימוש בשמות המגיעים ממרחב השמות std.
לאחר מכן, הכריז על ' find_GCD() ' פונקציה שלוקחת שני פרמטרים שלמים ' ערך1 ' ו' ערך2 ' בהתאמה. לאחר מכן, השתמש ב' אם ' הצהרה כדי לבדוק את ' ערך1 'שתמיד יהיה גדול יותר ושווה ל' ערך2 '. אחרי זה, ' בזמן נעשה שימוש בלולאה שממשיכה להחזיר ערך עד לתנאי ' ערך2 != 0 'הופך לשקר. בתוך לולאת 'while', 'value1' מחולק ב-'value2' ושומר את התוצאה ב-' היתרה 'משתנה.
הערכים של 'value1' ו-'value2' מתעדכנים כאשר 'value1' הופך לערך הנוכחי של 'value2', ו-'value2' הופך ל'שארית' המחושבת. הלולאה נמשכת עד שה-'value2' הופך ל-0, בשלב זה ה-GCD נמצא עם האלגוריתם האוקלידי. לבסוף, החזר את 'value1' לפונקציה 'find_GCD'.
int find_GCD ( int ערך1, int ערך2 ) {אם ( ערך2 > ערך1 ) {
לְהַחלִיף ( ערך1, ערך2 ) ;
}
בזמן ( ערך2 ! = 0 ) {
int היתרה = ערך1 % ערך2 ;
ערך1 = ערך2 ;
ערך2 = היתרה ;
}
לַחֲזוֹר ערך1 ;
}
בתוך ה ' רָאשִׁי() ' פונקציה, הכריזה ' מספר 1 'ו מספר 1 ' משתנים. לאחר מכן, השתמש ב' cout ' הצהרה כדי לקבל קלט מהמשתמשים. לאחר מכן, ה' אֲכִילָה ' האובייקט משמש לקריאת המספרים השלמים שהוזנו מהקלט הסטנדרטי ולשמור אותם במשתנים 'num1' ו-'num2'. לאחר מכן, נקרא ' find_GCD() שיטה שלוקחת את 'num1' ו- 'num2' כפרמטרים, ושמרה את התוצאות ב- ' שלי_תוצאה 'משתנה. לבסוף, השתמש ב' cout ' עם ה ' << ' אופרטור הכנסה כדי להדפיס את ה-GCD המשוער בקונסולה:
int רָאשִׁי ( ) {int מספר1, מספר2 ;
cout << 'הזן שני מספרים' << endl ;
אֲכִילָה >> מספר 1 >> מספר 2 ;
int שלי_תוצאה = find_GCD ( מספר1, מספר2 ) ;
cout << 'GCD של שני מספרים שלמים באמצעות אלגוריתם אוקלידי: ' << שלי_תוצאה << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה
שיטה 2: מצא את GCD באופן רקורסיבי ב-C++
שיטה נוספת לחישוב GCD ב-C++ היא שימוש רקורסיבי במשפט if. בואו נבדוק את הדוגמה הפשוטה של התוכנית המפורטת להלן ב-C++.
בקוד שלהלן, הגדר את ' calculate_Gcd() ' פונקציה לחישוב ה-GCD של שני מספרים. זה דורש שני פרמטרים שלמים, ' א ' ו' ב '. זה יבדוק אם ' ב ' שווה ל' 0 ', ואז החזר את ' א '. אחרת ה ' calculate_Gcd() הפונקציה ' קוראת באופן רקורסיבי עם פרמטרים ' ב ' ו' a%b ”:
#includeבאמצעות מרחב שמות סטד ;
int calculate_Gcd ( int א, int ב )
{
אם ( ב == 0 )
לַחֲזוֹר א ;
לַחֲזוֹר calculate_Gcd ( ב, א % ב ) ;
}
לאחר מכן, הכריז על המשתנים 'num1' ו-'num2' בתוך ' רָאשִׁי() ' פונקציה. לאחר מכן, השתמש ב' cout ' הצהרה כדי להציג את ' הזן שני מספרים ההודעה, ואז ה- אֲכִילָה ” האובייקט קורא ושומר את המשתנים שהוכנסו על ידי המשתמש. מתקדם, הזמין את ' calculate_Gcd() ' פונקציה עם ערכי קלט 'num1' ו-'num2'. נשמר בתוך ' תוֹצָאָה ' המשתנה והשתמשו ב-' cout ' כדי להציג את הערך המתקבל:
int רָאשִׁי ( ){
int מספר1, מספר2 ;
cout << 'הזן שני מספרים:' <> מספר 1 >> מספר 2 ;
int תוֹצָאָה = calculate_Gcd ( מספר1, מספר2 ) ;
cout << 'GCD של שני מספרים באמצעות שיטה רקורסיבית' << תוֹצָאָה << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה
שיטה 3: מצא את GCD באמצעות עבור Loop ב-C++
התוכנית הנתונה להלן השתמשה בלולאת 'עבור' כדי לגלות את המחלק המשותף הגדול ביותר:
#לִכלוֹלבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int value1, value2, gcd ;
cout << 'הזן שני ערכים מסוג מספר שלם' <> ערך1 >> ערך2 ;
אם ( ערך2 > ערך1 ) {
int טמפ' = ערך2 ;
ערך2 = ערך1 ;
ערך1 = טמפ' ;
}
ל ( int אני = 1 ; אני <= ערך2 ; ++ אני ) {
אם ( ערך1 % אני == 0 && ערך2 % אני == 0 ) {
gcd = אני ;
}
}
cout << 'GCD של שני ערכים באמצעות עבור Loop: ' << gcd ;
לַחֲזוֹר 0 ;
}
בקוד שלמעלה, ראשית, הכריז על שלושה משתנים שלמים ' ערך1 ', ' ערך2 ', ו' gcd ' בתוך ה ' רָאשִׁי() ' פונקציה. לאחר מכן, השתמש ב' cout ' אובייקט כדי לקבל את ערכי הקלט מהמשתמשים. ערכי הקלט של המשתמש נשמרים ב-'value1' ו-'value2' באמצעות ' >> ' מפעיל עם ' אֲכִילָה ' חפץ. לאחר מכן, השתמש ב' אם ' הצהרה כדי לבדוק אם ' ערך1 'הוא ' > ' מאשר ' ערך2 ' על ידי בדיקה אם ' טמפ' ' המשתנה מחזיק את ה-'value2' ואז מקצה אותו ל-'value1' ל-'value2' ו-'temp' ל-'value1'. לאחר מכן, לולאת 'עבור' חוזרת עד ל' אם 'המצב מרוצה. לבסוף, השתמש ב' cout ' הצהרה כדי להדפיס את התוצאה. כדלהלן:
למדת על שיטות התכנות C++ למציאת GCD.
סיכום
ה-GCD הוא מושג חשוב של מתמטיקה שעוזר למשתמשים לקבוע את המספר השלם החיובי הגדול ביותר המחלק את שני המספרים ללא כל שארית מאחור. נעשה שימוש במספר שיטות כדי למצוא את ה-GCD ב-C++, כגון ' אלגוריתם אוקלידי', ' רקורסיבי ', ו' ל 'לולאה. במדריך זה, הדגמנו את שיטות התכנות C++ למציאת GCD.