web-dev-qa-db-fra.com

Comment écrire un programme Java simple qui trouve le plus grand commun diviseur entre deux nombres?

Voici la question:

"Ecrivez une méthode nommée gcd qui accepte deux entiers en tant que paramètres et retourne le plus grand commun diviseur des deux nombres. Le plus grand commun diviseur (GCD) de deux entiers a et b est le plus grand entier représentant les facteurs a et b Le GCD de n'importe quel nombre et 1 est 1, et le GCD de n'importe quel nombre et 0 est ce nombre.

Un moyen efficace de calculer le GCD de deux nombres consiste à utiliser l'algorithme d'Euclid, qui indique ce qui suit:

GCD(A, B) = GCD(B, A % B) 
GCD(A, 0) = Absolute value of A"

Je suis vraiment confus quant à la façon de résoudre ce problème. Je veux juste quelques conseils et astuces quant à ce que j’ai mal fait dans le programme que j’ai jusqu’à présent. (Je dois mettre un scanner, c'est la condition de mon professeur.) Ne me donnez pas un code complet car je veux résoudre ce problème moi-même. Peut-être juste me donner un indice sur la façon dont j'intègre cette formule que vous voyez ci-dessus. (Et si vous vous demandez pourquoi j'ai mis le == 0, c'est parce que je pensais que si vous aviez deux nombres, disons 0 et 90, leur PGCD serait 0, pas vrai?)

De plus, mon code doit inclure des boucles while ... J'aurais préféré les boucles ...

Merci d'avance! :)

Mon programme actuel:

public static void main(String[] args) {
        Scanner console = new Scanner(System.in);
        int a = console.nextInt();
        int b = console.nextInt();
        gcd (a, b);
    }

    public static void gcd(int a, int b) {
        System.out.print("Type in two numbers and I will print outs its Greatest Common Divisor: ");
        int gcdNum1 = console.nextInt();
        int gcdNum2 = console.nextInt();
        while (gcdNum1 == 0) {
            gcdNum1 = 0;
        }
        while (gcdNum2 > gcdNum1) {
            int gcd = gcdNum1 % gcdNum2;
        }
        System.out.print(gcdNum1 + gcdNum2);
    }
}
javaloopswhile-loopgreatest-common-divisor
12
user1029481

Une méthode récursive serait:

static int gcd(int a, int b)
{
  if(a == 0 || b == 0) return a+b; // base case
  return gcd(b,a%b);
}

Utiliser une boucle while:

static int gcd(int a, int b)
{
  while(a!=0 && b!=0) // until either one of them is 0
  {
     int c = b;
     b = a%b;
     a = c;
  }
  return a+b; // either one is 0, so return the non-zero value
}

Lorsque je retourne a+b, je renvoie en fait le nombre non nul en supposant que l’un d’eux est 0.

33
Rushil Paul

Vous pouvez également le faire avec une méthode de trois lignes:

public static int gcd(int x, int y){
  return (y == 0) ? x : gcd(y, x % y);
}

Ici, si y = 0, x est renvoyé. Sinon, la méthode gcd est appelée à nouveau, avec des valeurs de paramètre différentes.

8
Jason
public static int GCD(int x, int y) {   
    int r;
    while (y!=0) {
        r = x%y;
        x = y;
        y = r;
    }
    return x;
}
2
dansalmo
import Java.util.Scanner;


public class Main {




public static void  main(String [] args)
{
    Scanner input = new Scanner(System.in);
    System.out.println("Please enter the first integer:");
    int b = input.nextInt();
    System.out.println("Please enter the second integer:");
    int d = input.nextInt();

    System.out.println("The GCD of " + b + " and " + d + " is " +  getGcd(b,d) + ".");
}


public static int getGcd(int b, int d)
{
    int gcd = 1;

    if(b>d)
    {
        for(int i = d; i >=1; i--)
        {
            if(b%i==0 && d%i ==0)
            {
                return i;
            }
        }
    }
    else
    {
        for(int j = b; j >=1; j--)
        {
            if(b%j==0 && d% j==0)
            {
                return j;
            }
        }
    }   
    return gcd;

}
}
1
Ricardo Saca
import Java.util.Scanner;

class CalculateGCD 
{   
  public static int calGCD(int a, int b) 
  { 
   int c=0,d=0;  
   if(a>b){c=b;} 
   else{c=a;}  
   for(int i=c; i>0; i--) 
   { 
    if(((a%i)+(b%i))==0) 
    { 
     d=i; 
     break; 
    } 
   } 
   return d;  
  }  

  public static void main(String args[]) 
  { 
   Scanner sc=new Scanner(System.in); 
   System.out.println("Enter the nos whose GCD is to be calculated:"); 
   int a=sc.nextInt(); 
   int b=sc.nextInt(); 
   System.out.println(calGCD(a,b));  
  } 
 }
0
mkn24
private static void GCD(int a, int b) {

    int temp;
    // make a greater than b
    if (b > a) {
         temp = a;
         a = b;
         b = temp;
    }

    while (b !=0) {
        // gcd of b and a%b
        temp = a%b;
        // always make a greater than bf
        a =b;
        b =temp;

    }
    System.out.println(a);
}
0
Andy

Maintenant, je viens de commencer à programmer il y a environ une semaine, donc rien d’exceptionnel, mais j’ai eu cela comme problème et j’ai proposé cela, qui pourrait être plus facile à comprendre pour les personnes qui commencent à programmer. Il utilise la méthode d'Euclid comme dans les exemples précédents.

public class GCD {
  public static void main(String[] args){
    int x = Math.max(Integer.parseInt(args[0]),Integer.parseInt(args[1]));    
    int y = Math.min(Integer.parseInt(args[0]),Integer.parseInt(args[1]));     
    for (int r = x % y; r != 0; r = x % y){
      x = y;
      y = r;
    }
    System.out.println(y);
  }
}
0
Forrest G.

Une façon de le faire est le code ci-dessous:

        int gcd = 0;
        while (gcdNum2 !=0 && gcdNum1 != 0 ) {
        if(gcdNum1 % gcdNum2 == 0){
            gcd = gcdNum2;
        }
            int aux = gcdNum2; 
            gcdNum2 = gcdNum1 % gcdNum2;
            gcdNum1 = aux;
    }

Vous n'avez pas besoin de récursivité pour le faire.

Et faites attention, il est dit que lorsqu'un nombre est égal à zéro, alors le GCD est le nombre qui n'est pas zéro. 

    while (gcdNum1 == 0) {
    gcdNum1 = 0;
}

Vous devez modifier cela pour répondre à l'exigence. 

Je ne vais pas vous dire comment modifier votre code entièrement, mais comment calculer le gcd.

0
andreih