So finden Sie GCD, LCM auf einer Reihe von Zahlen

Ich verwendet habe, Euklid-Algorithmus zu finden, die den größten gemeinsamen Teiler von zwei zahlen; Sie Durchlaufen werden können, erhalten den GCD von einer größeren Menge von zahlen.

private static long gcd(long a, long b)
{
    while (b > 0)
    {
        long temp = b;
        b = a % b; //% is remainder
        a = temp;
    }
    return a;
}

private static long gcd(long[] input)
{
    long result = input[0];
    for(int i = 1; i < input.length; i++) result = gcd(result, input[i]);
    return result;
}

Kleinste gemeinsame Vielfache ist ein wenig schwieriger, aber wahrscheinlich der beste Ansatz ist Reduzierung der GCDdie ebenso lässt sich iterieren:

private static long lcm(long a, long b)
{
    return a * (b / gcd(a, b));
}

private static long lcm(long[] input)
{
    long result = input[0];
    for(int i = 1; i < input.length; i++) result = lcm(result, input[i]);
    return result;
}

InformationsquelleAutor der Antwort Jeffrey Hantin

Gibt es keine build-in-Funktion. Finden Sie den GGT von zwei zahlen mit Euklid-Algorithmus.

Für eine Reihe von Anzahl

GCD(a_1,a_2,a_3,...,a_n) = GCD( GCD(a_1, a_2), a_3, a_4,..., a_n )

Wenden Sie es rekursiv.

Gleiche für LCM:

LCM(a,b) = a * b / GCD(a,b)
LCM(a_1,a_2,a_3,...,a_n) = LCM( LCM(a_1, a_2), a_3, a_4,..., a_n )

InformationsquelleAutor der Antwort J-16 SDiZ

int gcf(int a, int b)
{
    while (a != b) //while the two numbers are not equal...
    { 
        //...subtract the smaller one from the larger one

        if (a > b) a -= b; //if a is larger than b, subtract b from a
        else b -= a; //if b is larger than a, subtract a from b
    }

    return a; //or return b, a will be equal to b either way
}

int lcm(int a, int b)
{
    //the lcm is simply (a * b) divided by the gcf of the two

    return (a * b) / gcf(a, b);
}

InformationsquelleAutor der Antwort user3026735

Mit Java 8 gibt es mehr elegante und funktionale Möglichkeiten, diese zu lösen.

LCM:

private static int lcm(int numberOne, int numberTwo) {
    final int bigger = Math.max(numberOne, numberTwo);
    final int smaller = Math.min(numberOne, numberTwo);

    return IntStream.rangeClosed(1,smaller)
                    .filter(factor -> (factor * bigger) % smaller == 0)
                    .map(factor -> Math.abs(factor * bigger))
                    .findFirst()
                    .getAsInt();
}

GCD:

private static int gcd(int numberOne, int numberTwo) {
    return (numberTwo == 0) ? numberOne : gcd(numberTwo, numberOne % numberTwo);
}

Natürlich, wenn ein argument 0 ist, beide Methoden funktionieren nicht.

InformationsquelleAutor der Antwort AdHominem

import java.util.Scanner;
public class Lcmhcf {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    //TODO code application logic here
    Scanner scan = new Scanner(System.in);
    int n1,n2,x,y,lcm,hcf;
    System.out.println("Enter any 2 numbers....");
    n1=scan.nextInt();
    n2=scan.nextInt();
    x=n1;
    y=n2;

    do{
       if(n1>n2){
         n1=n1-n2;
       }
       else{
         n2=n2-n1;
       }
     } while(n1!=n2);
     hcf=n1;
     lcm=x*y/hcf;
     System.out.println("HCF IS = "+hcf);
     System.out.println("LCM IS = "+lcm);

     }
 }
//## Heading ##By Rajeev Lochan Sen

InformationsquelleAutor der Antwort Rajeev sen

//zu finden lcm von zwei zahlen [wirklich einfachen Weg]

Klasse lcm

{

static void main(int n1,int n2)

{




    int lcm;




    int a=n1;

    int b=n2;

    System.out.println("\f");


    if(n1==0||n2==0)
    {
       System.out.println("enter different number");
    }

  else
    {
        while(a!=b)
        {
          if(a>b)
            {
                a=a-b;
            }

          else
            {
                b=b-a;
            }
        }

     int GCD=a;

     lcm=(n1*n2)/GCD;

     System.out.println("the LCM is "+lcm);
    }

}
}

dass ist eine wirklich einfache Methode,...
[versuchen zu verstehen, es selbst cuz Codierung bedeutet zu verstehen ... 🙂 ]

InformationsquelleAutor der Antwort adarsh

Im Grunde zu finden gcd und lcm auf eine Reihe von zahlen, die Sie können verwenden Sie die folgende Formel,

LCM(a, b) X HCF(a, b) = a * b

Mittlerweile in java können Sie Euklid ' s Algorithmus zu finden, der gcd und lcm, wie diese

public static int GCF(int a, int b)
{
    if (b == 0)
    {
       return a;
    }
    else
    {
       return (GCF(b, a % b));
    }
}

Finden Sie diese Ressource, Beispiele zu finden, die auf Euklid ' s Algorithmus.

InformationsquelleAutor der Antwort Shiva

int lcm(int x,int y){

    int i=1;    

    while(true){

        if(!(x*i)%y)
             return x*i;

        i++;
    }

InformationsquelleAutor der Antwort soubhiks