Programang C++ para Maghanap ng GCD

Ang GCD ay tinutukoy bilang ' Pinakamahusay na Common Divisor ” (GCD). Regular itong lumilitaw sa iba't ibang mga pagkalkula at pamamaraan. Ito ay isang pangunahing konsepto sa matematika na ginagamit upang kalkulahin ang pinakamataas na positibong numero na resulta ng paghahati sa pagitan ng dalawa o higit pang mga numero na may natitirang zero na natitira.

Sa gabay na ito, susuriin namin ang iba't ibang mga pattern upang mahanap ang GCD na may mga pamamaraan sa C++.

Programang C++ para Maghanap ng GCD

Sa C++, para makuha ang pinakamalaking positive integer na naghahati sa dalawang ibinigay na numero nang hindi nag-iiwan ng anumang natitira, gamitin ang GCD (Greatest Common Divisor). Tumutulong ito sa pagpapasimple ng mga fraction at paglutas ng mga isyu na kinasasangkutan ng mga karaniwang salik. Ang GCD function sa isang programa ay nagbabalik ng pinakamalaking karaniwang salik sa pagitan ng dalawang input integer.

Nagbibigay ang C++ ng maraming pamamaraan para sa pagkalkula ng GCD ng dalawang numero. Ang ilan sa mga ito ay inilarawan sa ibaba.

Paraan 1: Maghanap ng GCD Gamit ang Euclidean-Algorithm sa C++

Ang ' Euclidean Algorithm ” ay isang malawakang ginagamit at maaasahang paraan para sa pagtukoy ng GCD ng dalawang magkaibang numero. Ito ay batay sa katotohanan na ang GCD para sa dalawang integer ay nananatiling hindi nagbabago kung ang isang mas maliit na numero(integer) ay ibabawas mula sa mas malaki, at ang diskarte na ito ay nagpapatuloy hanggang sa maging zero ang alinman sa mga integer.

Tingnan natin ang halimbawa sa ibaba, dito makikita natin ang (GCD) ng dalawang numero gamit ang Euclidean algorithm. Una, isama ang mga kinakailangang aklatan:

#include
gamit namespace std ;

dito:

“ ” header file ay kinabibilangan ng input at output stream, na nagbibigay-daan sa input at output operations.
“ gamit ang namespace std ” ay isang direktiba na nagpapadali sa paggamit ng mga pangalan na nagmumula sa std namespace.

Pagkatapos, ipahayag ang ' find_GCD() ” function na kumukuha ng dalawang integer parameters “ halaga1 'at' halaga2 ” ayon sa pagkakabanggit. Susunod, gamitin ang ' kung ” pahayag upang suriin ang “ halaga1 'na palaging magiging mas malaki at katumbas ng ' halaga2 ”. Pagkatapos nito, isang ' habang Ginagamit ang 'loop na patuloy na nagbabalik ng halaga hanggang sa kondisyon' halaga2!= 0 ” nagiging huwad. Sa loob ng 'habang' loop, ang 'value1' ay hinati sa 'value2' at sine-save ang resulta sa ' natitira ” variable.

Ang mga value ng 'value1' at 'value2' ay ina-update habang ang 'value1' ay nagiging kasalukuyang value ng 'value2', at ang 'value2' ay naging kalkuladong 'natitira'. Ang loop ay magpapatuloy hanggang ang 'value2' ay maging 0, sa puntong iyon ang GCD ay natagpuan na may Euclidean algorithm. Panghuli, ibalik ang 'value1' sa function na 'find_GCD'.

int find_GCD ( int halaga1, int halaga2 ) {
kung ( halaga2 > halaga1 ) {
magpalit ( halaga1, halaga2 ) ;
}
habang ( halaga2 ! = 0 ) {
int natitira = halaga1 % halaga2 ;
halaga1 = halaga2 ;
halaga2 = natitira ;
}

bumalik halaga1 ;
}

Nasa ' pangunahing() 'function, ipinahayag' num1 ” at num1 ” mga variable. Pagkatapos, gamitin ang ' cout ” pahayag upang makakuha ng input mula sa mga gumagamit. Susunod, ang ' kumakain Ang bagay na ” ay ginagamit upang basahin ang mga ipinasok na integer mula sa karaniwang input at i-save ang mga ito sa mga variable na “num1” at “num2”. Pagkatapos nito, tinawag ang ' find_GCD() ' paraan na kumukuha ng 'num1' at 'num2' bilang mga parameter, at nag-imbak ng mga resulta sa ' my_resulta ” variable. Panghuli, ginamit ang ' cout ' kasama ang ' << ” insertion operator para i-print ang tinantyang GCD sa console:

int pangunahing ( ) {
int num1, num2 ;
cout << 'Maglagay ng dalawang numero' << endl ;
kumakain >> num1 >> num2 ;

int my_resulta = find_GCD ( num1, num2 ) ;
cout << 'GCD ng dalawang integer gamit ang Euclidean Algorithm: ' << my_resulta << endl ;

bumalik 0 ;
}

Output

Paraan 2: Hanapin ang GCD Recursively sa C++

Ang isa pang paraan para kalkulahin ang GCD sa C++ ay recursively gamit ang if statement. Tingnan natin ang ibinigay na simpleng halimbawa ng programa sa C++.

Sa ibaba ng code, tukuyin ang ' kalkulahin_Gcd() ” function upang kalkulahin ang GCD ng dalawang numero. Kailangan ng dalawang integer na parameter, ' a 'at' b ”. Susuriin nito kung ang ' b 'ay katumbas ng' 0 ”, pagkatapos ay ibalik ang “ a ”. Kung hindi, ang ' kalkulahin_Gcd() Ang function na 'recursively calls with parameters' b 'at' a%b ”:

#include
gamit namespace std ;
int kalkulahin_Gcd ( int a, int b )
{
kung ( b == 0 )
bumalik a ;
bumalik kalkulahin_Gcd ( b, a % b ) ;
}

Susunod, ideklara ang mga variable na 'num1' at 'num2' sa loob ng ' pangunahing() ” function. Pagkatapos nito, gamitin ang ' cout ” pahayag upang ipakita ang “ Maglagay ng dalawang numero 'mensahe, pagkatapos ay ang' kumakain ” binabasa at sine-save ng object ang mga variable na ipinasok ng user. Pasulong, tinawag ang ' kalkulahin_Gcd() ” function na may mga halaga ng input na “num1” at “num2”. Naka-save sa loob ng ' resulta ” variable at ginamit ang “ cout ” upang ipakita ang resultang halaga:

int pangunahing ( )
{
int num1, num2 ;
cout << 'Magpasok ng dalawang numero: ' <> num1 >> num2 ;
int resulta = kalkulahin_Gcd ( num1, num2 ) ;
cout << 'GCD ng dalawang numero gamit ang Recursive Method ' << resulta << endl ;
bumalik 0 ;
}

Output

Paraan 3: Maghanap ng GCD Gamit ang para sa Loop sa C++

Ginamit ng programang ibinigay sa ibaba ang loop na 'para sa' upang matuklasan ang pinakamalaking karaniwang divisor:

#isama
gamit namespace std ;
int pangunahing ( ) {
int value1, value2, gcd ;
cout << 'Magpasok ng dalawang halaga ng uri ng integer' <> halaga1 >> halaga2 ;
kung ( halaga2 > halaga1 ) {
int temp = halaga2 ;
halaga2 = halaga1 ;
halaga1 = temp ;
}

para sa ( int i = 1 ; i <= halaga2 ; ++ i ) {
kung ( halaga1 % i == 0 && halaga2 % i == 0 ) {
gcd = i ;
}
}
cout << 'GCD ng dalawang value na ginagamit para sa Loop: ' << gcd ;

bumalik 0 ;
}

Sa code sa itaas, una, ideklara ang tatlong integer variable na “ halaga1 ”, “ halaga2 ”, at “ gcd ' sa loob ng ' pangunahing() ” function. Susunod, gamitin ang ' cout ” object upang makuha ang mga halaga ng input mula sa mga user. Ang mga value ng input ng user ay naka-save sa 'value1' at 'value2' gamit ang ' >> 'operator na may ' kumakain ” bagay. Pagkatapos, gamitin ang ' kung ” pahayag upang suriin kung ang “ halaga1 'ay' > 'kaysa sa' halaga2 'sa pamamagitan ng pagsuri kung ang ' temp Ang ” variable ay may hawak na “value2” at pagkatapos ay italaga ito sa “value1” sa “value2” at “temp” sa “value1”. Pagkatapos nito, umuulit ang 'para sa' loop hanggang sa loob ng ' kung ” nasiyahan ang kundisyon. Panghuli, gamitin ang ' cout ” pahayag para i-print ang resulta. Tulad ng sumusunod:

Natutunan mo ang tungkol sa mga pamamaraan ng C++ programming para sa paghahanap ng GCD.

Konklusyon

Ang GCD ay isang mahalagang konsepto ng matematika na tumutulong sa mga user na matukoy ang pinakamalaking positive integer na naghahati sa parehong numero nang walang anumang nalalabi. Maraming paraan ang ginagamit upang mahanap ang GCD sa C++, gaya ng “ Euclidean Algorithm', ' recursive ”, at “ para sa ” loop. Sa gabay na ito, inilarawan namin ang mga pamamaraan ng C++ programming para sa paghahanap ng GCD.

Programang C++ para Maghanap ng GCD