Java中的LCM（最小公倍数）答案

【问题标题】：LCM (lowest common multiple) in JavaJava中的LCM（最小公倍数）
【发布时间】：2013-01-29 15:15:38
【问题描述】：

我需要有关此循环的帮助。我的课程任务之一是制作 LCM 程序。

Sample output:
(8,12) LCM is 24
(4,3) LCM is 12
(5,10,20) LCM is 20
(18,24,52) LCM is 936
(12,10,26) LCM is 780
(99,63,24) LCM is 5544
(62,16,24) LCM is 1488

到目前为止，我有 2 个数字，但我不确定如何处理 3 个数字。我们应该在其他类上使用方法，所以这就是我为 LCM 类所拥有的。

public class LCM {
    private int n, x, s = 1, t = 1;

    public LCM()
    {
        n = 0;
        x = 0;
        s = 1;
        t = 1;
    }
    public int lcmFind(int i, int y) {
        for (n = 1;; n++) {
            s = i * n;
            for (x = 1; t < s; x++) {
                t = y * x;
            }
            if (s == t)
                break;
        }
        return (s);
    }
}

【问题讨论】：

只是一个一般性的建议，使用更明显的变量名，而不仅仅是单个字母。否则它会很快变得复杂。
我不会阅读该代码。由于上述原因。
而不是for (...) { t = y * x; } if (s == t) break;，只需if (y % s == 0) break;。
请不要省略for 循环条件，然后在循环块的末尾添加if ... break。这让那些必须阅读/维护代码的人感到困惑。变量名称同上。不，不会维护家庭作业代码，但它会被评分者阅读，最好马上养成好习惯。
检查这个：stackoverflow.com/questions/4201860/…

标签： java

【解决方案1】：

如果您想获得 3+ 号码的 LCM，您可以通过以下方式使用您的方法lcmFind：

int a = 2;
int b = 3;
int c = 5;
LCM l = new LCM();
int lcm = l.lcmFind(l.lcmFind(a, b), c);

推荐：

使n、x、s 和t 变量在lcmFind 中成为本地变量。因为您仅在 lcmFind 方法中需要它们，并且您需要在每次调用 lcmFind 时重置它们的值。
将您的lcmFind 方法设为静态。您无需实例化新对象即可计算 lcm。这样您就可以像LCM.lcmFind(3,4) 一样使用它，或者甚至更好的重命名方法并使用像LCM.find(3,4) 这样的东西。

编辑
如果您需要制作采用可变数量参数的方法，您应该检查varargs。所以你会得到类似的东西：

public int lcmFind(int.. args) {
    // args is actually array of ints.
    // calculate lcm of all values in array.
    // usage: lcmFind(1,4) or lcmFind(1,5,6,3)
}

您可以使用您的第一个版本的lcmFind，它接受 2 个参数并使用它计算多个值的 lcm。

编辑 2
如果您只需要 lcmFind 的 2 和 3-args 版本，则可以添加 3-arg 版本：

public int lcmFind(int a, int b, int c) {
    return lcmFind(lcmFind(a, b), c); 
}

【讨论】：

我的老师很严格。他不会允许的。他希望它像 lcmFind(a, b, c) 一样使用重载。
我们还没有学过数组。我们只是开始方法和类。还在学习。我只需要帮助找到 2 和 3 数字的 LCM。
@GarrettOutlaw 我已经更新了我的答案。您可以只创建使用 2-arg 版本的 lcmFind 的 3-arg 版本。

【解决方案2】：

我发现了这个link，我想这是最简单和干净的解决方案：

/**
* Calculate Lowest Common Multiplier
*/
public static int LCM(int a, int b) {
    return (a * b) / GCF(a, b);
}

/**
* Calculate Greatest Common Factor
*/
public static int GCF(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return (GCF(b, a % b));
    }
}

【讨论】：

【解决方案3】：

试试

public int lcm(int... a) {
    for (int m = 1;; m++) {
        int n = a.length;
        for (int i : a) {
            if (m % i != 0) {
                break;
            }
            if (--n == 0) {
                return m;
            }
        }
    }
}

【讨论】：

【解决方案4】：

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

public static int gcd(int... args){
    int r = args[0];
    int i = 0;
    while(i < args.length - 1)
        r = gcd(r,args[++i]);
    return r;
}

public static int lcm(int a, int b){
    return a * b / gcd(a,b);
}

public static int lcm(int... args){
    int r = args[0];
    int i = 0;
    while(i < args.length - 1)
        r = lcm(r,args[++i]);
    return r;
}

【讨论】：

【解决方案5】：

static int  getLCM(int a,int b)
{
    int x;
    int y;
    if(a<b)
    {
        x=a;
         y=b;   
    }
    else
    {
         x=b;
         y=a;   
    }
    int i=1;
    while(true)
    {

        int x1=x*i;
        int y1=y*i;
        for(int j=1;j<=i;j++)
        {
        if(x1==y*j)
        {
            return x1;
        }
        }

        i++;
    }



}

【讨论】：

我想鼓励您使用两个具有适当增量的循环而不是 while(true)。

【解决方案6】：

我想你已经有了答案，因为这是一篇旧帖子。仍然发布我的答案。下面是查找数组的 LCM 的代码：

 import java.util.Arrays;
 import java.util.Scanner;

public class ArrayEqualAmz {
    static int lcm =1;
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int [] arr = new int[n];

    for(int i=0; i<n; i++){
        arr[i] = sc.nextInt();
    }
    System.out.println("lcm = "+lcm(arr));

    }

    // find the factor
    public static int divisor(int x[]){
        Arrays.sort(x);
        int num=0;
        for(int i=x.length-1; i>=0; i--){
            if(x[i] != 1 )
            num=x[i];
        }
        for(int j=2; j<=num; j++){
            if(num%j==0){
            return j;}
        }
        return num;
    }

    //finding the lcm
    public static int lcm(int arr[]){
        while(true){

        int j = divisor(arr);
        if(j==0){break;}
        lcm = lcm*j;
        for(int i=0; i<arr.length; i++){
            if(arr[i]%j==0){
            arr[i] = arr[i]/j;}
        System.out.print(arr[i]+",");
        }
        System.out.println( " factor= "+lcm);
        return lcm(arr);
        }
        return lcm;
    }


}

【讨论】：

【解决方案7】：

试试这个

     int n1 = 72, n2 = 120, lcm;

    // maximum number between n1 and n2 is stored in lcm
    lcm = (n1 > n2) ? n1 : n2;

    // Always true
    while(true)
    {
        if( lcm % n1 == 0 && lcm % n2 == 0 )
        {
            System.out.printf("The LCM of %d and %d is %d.", n1, n2, lcm);
            break;
        }
        ++lcm;
    }

【讨论】：

【解决方案8】：

您可以重复使用为两个数字的 lcm 编写的相同函数。只需传递以下参数之一：

功能代码可以是这样的：

public static int lcm(int num1,int num2) {
        boolean flag = false;
        int lcm = 0;
        for(int i= 1;!flag; i++){
           flag = (num1 < num2)?(num2*i)%num1==0:(num1*i)%num2==0;
           lcm = num1<num2?num2*i:num1*i;
        }
        return lcm;
    }

这样调用函数：

    public static void main(String[] args) {
        System.out.println("lcm "+lcm(lcm(20,80),40));
    }

【讨论】：