ఈ గైడ్‌లో, మేము C++లోని పద్ధతులతో GCDని కనుగొనడానికి వివిధ నమూనాలను విశ్లేషిస్తాము.
GCDని కనుగొనడానికి C++ ప్రోగ్రామ్
C++లో, అందించిన రెండు సంఖ్యలను శేషం లేకుండా భాగించే గొప్ప సానుకూల పూర్ణాంకాన్ని పొందడానికి, GCD (గ్రేటెస్ట్ కామన్ డివైజర్) ఉపయోగించండి. ఇది భిన్నాలను సరళీకృతం చేయడంలో మరియు సాధారణ కారకాలతో కూడిన సమస్యలను పరిష్కరించడంలో సహాయపడుతుంది. ప్రోగ్రామ్‌లోని GCD ఫంక్షన్ రెండు ఇన్‌పుట్ పూర్ణాంకాల మధ్య గొప్ప సాధారణ కారకాన్ని అందిస్తుంది.
C++ రెండు సంఖ్యల GCDని లెక్కించడానికి బహుళ పద్ధతులను అందిస్తుంది. వాటిలో కొన్ని క్రింద వివరించబడ్డాయి.
విధానం 1: C++లో యూక్లిడియన్-అల్గోరిథం ఉపయోగించి GCDని కనుగొనండి
ది ' యూక్లిడియన్ అల్గోరిథం ” అనేది రెండు వేర్వేరు సంఖ్యల GCDని నిర్ణయించడానికి విస్తృతంగా ఉపయోగించే మరియు నమ్మదగిన పద్ధతి. పెద్ద సంఖ్య నుండి చిన్న సంఖ్య (పూర్ణాంకం) తీసివేయబడినట్లయితే రెండు పూర్ణాంకాల కోసం GCD మారదు మరియు పూర్ణాంకాలలో ఏదైనా సున్నా అయ్యే వరకు ఈ విధానం కొనసాగుతుంది.
దిగువ ఉదాహరణను చూద్దాం, ఇక్కడ మనం యూక్లిడియన్ అల్గోరిథం ఉపయోగించి రెండు సంఖ్యల (GCD)ని కనుగొంటాము. ముందుగా, అవసరమైన లైబ్రరీలను చేర్చండి:
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
ఇక్కడ:
- '
”హెడర్ ఫైల్ ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌లను కలిగి ఉంటుంది, ఇది ఇన్‌పుట్ మరియు అవుట్‌పుట్ కార్యకలాపాలను ప్రారంభిస్తుంది. - ' నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ” అనేది std నేమ్‌స్పేస్ నుండి వచ్చే పేర్లను ఉపయోగించడం సులభతరం చేసే ఆదేశం.
అప్పుడు, ప్రకటించండి ' కనుగొను_GCD() 'రెండు పూర్ణాంకాల పారామితులను తీసుకునే ఫంక్షన్' విలువ1 'మరియు' విలువ2 ” వరుసగా. తరువాత, 'ని ఉపయోగించండి ఉంటే తనిఖీ చేయడానికి 'ప్రకటన' విలువ1 'అది ఎల్లప్పుడూ గొప్పగా మరియు సమానంగా ఉంటుంది' విలువ2 ”. దీని తరువాత, ఒక ' అయితే ” లూప్ ఉపయోగించబడుతుంది, అది షరతు వరకు విలువను తిరిగి ఇస్తుంది విలువ2 != 0 ” తప్పు అవుతుంది. “అయితే” లూప్ లోపల, “విలువ1” “విలువ2”తో విభజించబడింది మరియు ఫలితాన్ని “లో సేవ్ చేస్తుంది మిగిలినవి ” వేరియబుల్.
'విలువ1' మరియు 'విలువ2' విలువలు 'విలువ1' 'విలువ2' యొక్క ప్రస్తుత విలువగా మారినప్పుడు మరియు 'విలువ2' లెక్కించబడిన 'మిగిలినది'గా మారినప్పుడు నవీకరించబడ్డాయి. 'విలువ2' 0 అయ్యే వరకు లూప్ కొనసాగుతుంది, ఆ సమయంలో GCD యూక్లిడియన్ అల్గారిథమ్‌తో కనుగొనబడింది. చివరగా, “value1”ని “find_GCD” ఫంక్షన్‌కి తిరిగి ఇవ్వండి.
int కనుగొను_GCD ( int విలువ1, int విలువ2 ) {ఉంటే ( విలువ2 > విలువ1 ) {
మార్పిడి ( విలువ1, విలువ2 ) ;
}
అయితే ( విలువ2 ! = 0 ) {
int మిగిలినవి = విలువ1 % విలువ2 ;
విలువ1 = విలువ2 ;
విలువ2 = మిగిలినవి ;
}
తిరిగి విలువ1 ;
}
లో ' ప్రధాన () 'ఫంక్షన్, ప్రకటించబడింది' సంఖ్య1 ” మరియు సంఖ్య1 ” వేరియబుల్స్. అప్పుడు, 'ని ఉపయోగించండి కోట్ వినియోగదారుల నుండి ఇన్‌పుట్ పొందడానికి ప్రకటన. తరువాత, ' ఆహారపు ” ఆబ్జెక్ట్ ప్రామాణిక ఇన్‌పుట్ నుండి నమోదు చేయబడిన పూర్ణాంకాలను చదవడానికి మరియు వాటిని “num1” మరియు “num2” వేరియబుల్స్‌లో సేవ్ చేయడానికి ఉపయోగించబడుతుంది. ఆ తర్వాత, ' కనుగొను_GCD() ” పద్ధతి “num1” మరియు “num2”లను పారామీటర్‌లుగా తీసుకుంటుంది మరియు ఫలితాలను “లో నిల్వ చేస్తుంది నా_ఫలితం ” వేరియబుల్. చివరగా, ఉపయోగించబడింది ' కోట్ 'తో' << కన్సోల్‌లో అంచనా వేసిన GCDని ప్రింట్ చేయడానికి చొప్పించే ఆపరేటర్:
int ప్రధాన ( ) {int సంఖ్య 1, సంఖ్య 2 ;
కోట్ << 'రెండు సంఖ్యలను నమోదు చేయండి' << endl ;
ఆహారపు >> సంఖ్య1 >> సంఖ్య2 ;
int నా_ఫలితం = కనుగొను_GCD ( సంఖ్య 1, సంఖ్య 2 ) ;
కోట్ << 'యూక్లిడియన్ అల్గోరిథం ఉపయోగించి రెండు పూర్ణాంకాల GCD:' << నా_ఫలితం << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్
విధానం 2: C++లో GCDని పునరావృతంగా కనుగొనండి
C++లో GCDని లెక్కించడానికి మరొక పద్ధతి if స్టేట్‌మెంట్‌ను పునరావృతంగా ఉపయోగిస్తుంది. C++లో క్రింద ఇవ్వబడిన సాధారణ ప్రోగ్రామ్ ఉదాహరణను చూద్దాం.
దిగువ కోడ్‌లో, 'ని నిర్వచించండి లెక్కించు_Gcd() ”రెండు సంఖ్యల GCDని లెక్కించడానికి ఫంక్షన్. ఇది రెండు పూర్ణాంకాల పారామితులను తీసుకుంటుంది, ' a 'మరియు' బి ”. ఇది తనిఖీ చేస్తుంది ' బి ''తో సమానం 0 ', ఆపై తిరిగి' a ”. లేకపోతే, ' లెక్కించు_Gcd() 'ఫంక్షన్ పునరావృతంగా పారామితులతో కాల్ చేస్తుంది' బి 'మరియు' a%b ”:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int లెక్కించు_Gcd ( int a, int బి )
{
ఉంటే ( బి == 0 )
తిరిగి a ;
తిరిగి లెక్కించు_Gcd ( బా % బి ) ;
}
తర్వాత, “num1” మరియు “num2” వేరియబుల్స్‌ను “లోపల ప్రకటించండి ప్రధాన () ” ఫంక్షన్. దీని తరువాత, 'ని ఉపయోగించండి కోట్ ప్రదర్శించడానికి ' ప్రకటన ' రెండు సంఖ్యలను నమోదు చేయండి 'సందేశం, ఆపై ' ఆహారపు ” ఆబ్జెక్ట్ వినియోగదారు నమోదు చేసిన వేరియబుల్స్‌ని చదివి సేవ్ చేస్తుంది. ముందుకు కదులుతూ, ' లెక్కించు_Gcd() 'num1' మరియు 'num2' ఇన్‌పుట్ విలువలతో ఫంక్షన్. లోపల సేవ్ చేయబడింది ' ఫలితం 'వేరియబుల్ మరియు ఉపయోగించబడింది' కోట్ ” ఫలిత విలువను ప్రదర్శించడానికి:
int ప్రధాన ( ){
int సంఖ్య 1, సంఖ్య 2 ;
కోట్ << 'రెండు సంఖ్యలను నమోదు చేయండి:' <> సంఖ్య1 >> సంఖ్య2 ;
int ఫలితం = లెక్కించు_Gcd ( సంఖ్య 1, సంఖ్య 2 ) ;
కోట్ << 'పునరావృత పద్ధతిని ఉపయోగించి రెండు సంఖ్యల GCD' << ఫలితం << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్
విధానం 3: C++లో లూప్ కోసం GCDని కనుగొనండి
దిగువ ఇవ్వబడిన ప్రోగ్రామ్ అతిపెద్ద సాధారణ విభజనను కనుగొనడానికి 'ఫర్' లూప్‌ను ఉపయోగించింది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int విలువ1, విలువ2, gcd ;
కోట్ << 'పూర్ణాంక రకం యొక్క రెండు విలువలను నమోదు చేయండి' <> విలువ1 >> విలువ2 ;
ఉంటే ( విలువ2 > విలువ1 ) {
int ఉష్ణోగ్రత = విలువ2 ;
విలువ2 = విలువ1 ;
విలువ1 = ఉష్ణోగ్రత ;
}
కోసం ( int i = 1 ; i <= విలువ2 ; ++ i ) {
ఉంటే ( విలువ1 % i == 0 && విలువ2 % i == 0 ) {
gcd = i ;
}
}
కోట్ << 'లూప్ కోసం ఉపయోగించే రెండు విలువల GCD:' << gcd ;
తిరిగి 0 ;
}
పై కోడ్‌లో, ముందుగా మూడు పూర్ణాంకాల వేరియబుల్‌లను ప్రకటించండి “ విలువ1 ',' విలువ2 ', మరియు' gcd 'లోపల' ప్రధాన () ” ఫంక్షన్. తరువాత, 'ని ఉపయోగించండి కోట్ ” వినియోగదారుల నుండి ఇన్‌పుట్ విలువలను పొందడానికి ఆబ్జెక్ట్. వినియోగదారు ఇన్‌పుట్ విలువలు “విలువ1” మరియు “విలువ2”లో “ని ఉపయోగించి సేవ్ చేయబడతాయి. >> 'తో ఆపరేటర్' ఆహారపు ” వస్తువు. అప్పుడు, 'ని ఉపయోగించండి ఉంటే 'ఉందో లేదో తనిఖీ చేయడానికి ప్రకటన' విలువ1 'అంటే' > ' కంటే ' విలువ2 ' అని తనిఖీ చేయడం ద్వారా ' ఉష్ణోగ్రత ”వేరియబుల్ “విలువ2”ని కలిగి ఉంటుంది, ఆపై దానిని “విలువ1” నుండి “విలువ2”కి మరియు “టెంప్”ని “విలువ1”కి కేటాయించండి. దీని తరువాత, 'ఫర్' లూప్ లోపల '' వరకు పునరావృతమవుతుంది. ఉంటే ” పరిస్థితి సంతృప్తికరంగా ఉంది. చివరగా, 'ని ఉపయోగించండి కోట్ ” ప్రకటన ఫలితాన్ని ముద్రించడానికి. క్రింది విధంగా:
మీరు GCDని కనుగొనడానికి C++ ప్రోగ్రామింగ్ పద్ధతుల గురించి తెలుసుకున్నారు.
ముగింపు
GCD అనేది గణితశాస్త్రం యొక్క ముఖ్యమైన భావన, ఇది రెండు సంఖ్యలను శేషం లేకుండా విభజించే అతిపెద్ద సానుకూల పూర్ణాంకాన్ని గుర్తించడంలో వినియోగదారులకు సహాయపడుతుంది. C++లో GCDని కనుగొనడానికి అనేక పద్ధతులు ఉపయోగించబడతాయి, ఉదాహరణకు “ యూక్లిడియన్ అల్గోరిథం”, “ పునరావృత ', మరియు' కోసం ” లూప్. ఈ గైడ్‌లో, మేము GCDని కనుగొనడానికి C++ ప్రోగ్రామింగ్ పద్ధతులను వివరించాము.