Cómo escribir un programa para encontrar el MCD entre dos números en C ++

Puedes escribir-

mientras que (b) a% = b, swap (a, b);

Por lo tanto, no necesita tener cuidado cuando b = 0.
Puede usar su propia función de intercambio o predefinir una.

Si quieres que se vea genial, escríbelo como
mientras que (b) b ^ = a ^ = b ^ = a% = b;

a le da un MCD de dos números dados.

Operador Xor para intercambiar el algoritmo de intercambio XOR.

Hola amigos, a continuación hay dos métodos para encontrar el mcd de dos números … Uno es por recursión y uno es por función básica de GCD … Espero que les gusten …

Este programa toma dos enteros positivos del usuario y calcula GCD usando recursividad.

  #include 
 usando el espacio de nombres estándar;

 int hcf (int n1, int n2);

 int main ()
 {
    int n1, n2;

    cout << "Ingrese dos enteros positivos:";
    cin >> n1 >> n2;

    cout << "HCF de" << n1 << "&" << n2 << "es:" << hcf (n1, n2);

    devuelve 0;
 }

 int hcf (int n1, int n2)
 {
     si (n2! = 0)
        devolver hcf (n2, n1% n2);
     más 
        retorno n1;
 }

Para obtener más información, consulte esta página para obtener más aclaraciones ...

Este programa toma dos enteros positivos del usuario y calcula GCD usando la función gcd.

  #include 
 #include 

 nulo gcd (int, int);

 vacío principal()
 {
     int a, b;
     clrscr ();
     cout << "Ingrese dos números:";
     cin >> a >> b;
     mcd (a, b);
     getch ();
   // devuelve 0;
 }

 // función para calcular mcd
 nulo gcd (int a, int b)
 {
     int m, n;

     m = a;
     n = b;

     mientras que (m! = n)
     {
         si (m> n)
             m = mn;
         más
             n = nm;
     }

     cout << "\ nH.CF de" << a << "&" << b << "es" << m;
 }

Para obtener más información, consulte esta página para obtener más aclaraciones ...

Se puede hacer usando el algoritmo euclidiano.

Función GCD :

  int calculategcd (int m, int n)
 {  
    si (n == 0)
    volver m;
    else return calculategcd (n, m% n);
 }

Función principal

  #include 
 usando el espacio de nombres estándar;
 // Pega la función GCD aquí
 int main ()
 { 
  int a, b, mcd;
  cout << "Ingrese dos números" << endl;
  cin >> a >> b;
  mcd = calculategcd (a, b);
  cout << "El GCD es:" << endl;
  cout << mcd;
  devuelve 0;
 }

Feliz codificación

Hola amigo, en realidad había 2 preguntas separadas, una para GCD y la otra para LCM, he combinado ambas. ¡Espero eso ayude!

  #include 
 largo mcd (largo, largo);
 int main () {
 largo x, y, hcf, mcm;
 cout << "Ingrese dos enteros \ n";
 cin >> x >> y;
 hcf = mcd (x, y);
 mcm = (x * y) / hcf;
 cout << "Máximo común divisor de" << x << "y" << y << "=" << hcf << "\ n";
 cout << "Mínimo común múltiplo de" << x << "y" << y << "=" << mcm << "\ n";
 devuelve 0;
 }
 / * si 1st no es 0 entonces 2nd no es gcd
 haga el segundo no 0 restando el más pequeño del más grande y devuelva el primer no como mcd * /
 mcd largo (largo x, largo y) {
 si (x == 0) {
 volver y;
 }
 while (y! = 0) {
 si (x> y) {
 x = x - y;
 }
 más {
 y = y - x;
 }
 }
 volver x;  }

SALIDA:

  int gcd (int a, int b) {return b?  mcd (b, a% b): a;  }

Puedes ver mi programa c ++ para encontrar el máximo divisor común
Encuentre el divisor común más grande de dos números en la programación de C ++
#incluir
usando el espacio de nombres estándar;
#incluir
int main ()
{
int x, y, m, i;
cout <> x >> y;
si (x> y)
m = y;
más
m = x;
para (i = m; i> = 1; i–)
{
if (x% i == 0 && y% i == 0)
{
cout << "\ nGCD de dos números es:" << i;
descanso;
}
}
getch ();
devuelve 0;
}
// Recursos para programadores y desarrolladores //

A continuación se muestra una forma de encontrar GCD.

  #include 
 usando el espacio de nombres estándar;
 long long int gcd (long long int a, long long int b) // máximo común divisor
 {
     si (b == 0)
         devolver a;
     más
         devuelve mcd (b, a% b);
 }
 int main ()
 {
     largo largo int x, n;
     cin >> x >> n;
     cout << mcd (x, n);
     devuelve 0;
 }

Otras respuestas son agradables pero no eficientes.

Akhavi y Vallée demostraron que, en teoría, el GCD binario puede ser aproximadamente un 60% más eficiente (en términos de la cantidad de operaciones de bits) en promedio que el algoritmo euclidiano.

  unsigned int gcd (unsigned int u, unsigned int v)
 {
     // casos simples (terminación)
     si (u == v)
         volver u;

     si (u == 0)
         volver v;

     si (v == 0)
         volver u;

     // busca factores de 2
     si (~ u & 1) // u es par
     {
         si (v & 1) // v es impar
             devuelve mcd (u >> 1, v);
         sino // tanto u como v son pares
             return gcd (u >> 1, v >> 1) << 1;
     }

     si (~ v & 1) // u es impar, v es par
         devuelve mcd (u, v >> 1);

     // reduce el argumento más grande
     si (u> v)
         devuelve mcd ((u - v) >> 1, v);

     devuelve mcd ((v - u) >> 1, u);
 }

Fuente: Algoritmo Binario GCD – Wikipedia [Sí, primero debes consultar el wiki]

while (a% = b) swap (a, b); // Similar al algoritmo de Euclid; b es el MCD.
// El caso b == 0 no es compatible, pero se puede verificar antes del ciclo.

Para usar swap (a, b) , su programa debe usar
#include

Por cierto, usar la recursividad para este problema es una muy mala idea, eso es algo que esperarías de personas sin una amplia experiencia en programación y personas que no entienden los gastos generales y las limitaciones de la recursividad. Sin mencionar que la recursión complicaría innecesariamente la comprensión del programa para principiantes (para la discusión de la recursividad de la cola, ver comentarios).

Usa el Algo de Euclides

MCD DE DOS NÚMEROS a, b;
int gcd (int a, int b) {
si (b == 0)
devolver a;
de lo contrario, devuelve mcd (b, a% b);

}

Si está haciendo uno, entonces haga el más increíble y use la recursividad. Y si necesitas un algoritmo, Euclid te lo dio hace unos miles de años.

Y no, el bloqueo de mayúsculas no es la clave mágica que produce un algoritmo GCD.

#include

usando el espacio de nombres estándar;

int main ()

{

auto a = 0, b = 0;

cin >> a >> b;

cout << "GCD =" << __ gcd (a, b) << endl;

cout << "LCM =" << (a * b) / __ mcd (a, b);

}

manera perezosa:
cout << __gcd(a,b) << endl;

para usar __gcd(a,b) , primero se debe
#include