Algorithm 查找列表中所有数字的因子中的最小整数

有没有办法从列表中找出N个数的最大公约数

例如： 有一个类似于4、24、64、80、401264等的列表。。。我想要一种方法，用它我可以找到列表中最大的公约数。在上述情况下，4是最大公约数。我想要的是一个在列表上工作并给出值的动态解决方案。（一个整数，它将列表中的所有数字分开，而不给出提示）

解决方案可以是任何语言，最好是C语言（利用Linq）

附言： 抱歉，如果你认为这是math.stackexchange.com的，我实际上不知道该发布到哪一个

---

编辑：很抱歉我不知道我最初使用的是LCD。

您可以这样做，只需缩短列表，然后运行一个循环，该循环将访问每个值并在内部循环中除以列表中的所有其他值。每次成功除法后，递增一个计数器，然后将上一次计数与内部循环外的电流进行比较，如果是电流计数小于存储的实际值。希望这能解决您的问题

您可以这样做，只需缩短列表并运行一个循环，该循环将访问列表中的每个值并在内部循环中分割列表中的所有其他值。每次成功分割后，增加一个计数器，然后将以前的计数与内部循环外的当前计数进行比较，如果当前计数较小，则存储实际值。希望这能解决您的问题

最不常见的多重函数（LCM）是关联的和可交换的。因此，只需执行以下操作，就可以计算n个数的数组的LCM

k = 1
for i = 1..n
    k = LCM(k, A[i])

---

已有的LCM算法。请参见此处：

最不常见的多重函数（LCM）是关联的和可交换的。因此，只需执行以下操作，就可以计算n个数的数组的LCM

k = 1
for i = 1..n
    k = LCM(k, A[i])

已有的LCM算法。请看这里：

我想你想要的是代替。示例的GCD和LCM应分别为

4

和

75840

您可以通过获取数字列表的GCD和LCM。它可以作为动态解进行反编码（通过记录每个素因子的最小和最大指数）。以您的列表为例：

4 = 2^2
24 = 2^3 * 3
64 = 2^6
80 = 2^4 * 5
40 = 2^3 * 5
1264 = 2^4 * 79

因此，GCD为

2^2=4

，LCM为

2^6*3*5*79=75840

我想你想要的不是。示例的GCD和LCM应分别为

4

和

75840

您可以通过获取数字列表的GCD和LCM。它可以作为动态解进行反编码（通过记录每个素因子的最小和最大指数）。以您的列表为例：

4 = 2^2
24 = 2^3 * 3
64 = 2^6
80 = 2^4 * 5
40 = 2^3 * 5
1264 = 2^4 * 79

---

因此，GCD为

2^2=4

，LCM为

2^6*3*5*79=75840

计算GCD和LCM，以便：

• 在素数中解析列表中的每个元素。As 60=2^2*3*5。把这些素数表示写成向量。As 60=（2,1,1,0,0，…）
• 对于GCD，在所有表示中找到相同位置的最小值。对所有位置重复上述步骤
• 对于LCM，它将是最大值
• 将这些表示转换回素数并相互转换回素数

---

我记得，这是学校六年级的课程。（对于12岁儿童）

GCD和LCM的计算如下：

• 在素数中解析列表中的每个元素。As 60=2^2*3*5。把这些素数表示写成向量。As 60=（2,1,1,0,0，…）
• 对于GCD，在所有表示中找到相同位置的最小值。对所有位置重复上述步骤
• 对于LCM，它将是最大值
• 将这些表示转换回素数并相互转换回素数

我记得，这是学校六年级的课程。（适用于12岁儿童）

执行以下操作：-

在列表中找到最小的数字S

求S的所有素因子

对于每个素数pi，求xi=最小值（k1，k2，k3，…），其中ki是pi在数arr[i]中的幂

GCD=x1*x2*.xk

注意：您可以在3中的任何迭代中停止。当ki=1时，因为它将是最小值

Java实现：-

public static long lgcd(long[] arr) {

        long min = arr[0];

        for(int i=0;i<arr.length;i++) {
            if(min>arr[i]) {
                min = arr[i];
            }
        }

        ArrayList div_primes = new ArrayList();
        boolean isPrime[] = new boolean[(int)Math.sqrt(min)+1];
        for(int i=0;i<isPrime.length;i++)
            isPrime[i] = true;

        for(int j=2;j<isPrime.length;j++) {
            if(isPrime[j]) {
                int x = 2*j;
                if(min%j==0) {
                    div_primes.add(j);
                } 
                for(;x<isPrime.length;x=x+j) {
                    isPrime[x] = false;
                }
            }
        }

        if(div_primes.size()<1) {
           div_primes.add(min);
        }

        long gcd = 1;

        for(int i=0;i<div_primes.size();i++) {
            long curr = (Integer)div_primes.get(i);
            long x = min;
            for(int j=0;j<arr.length;j++) {
                long acc = arr[j];
                long fact = 1;
                while(acc>1&&acc%curr==0) {
                    acc = acc/curr;
                    fact = fact*curr;
                }
                x = Math.min(x,fact);
                if(fact==1)
                    break;
            }
            gcd = gcd*x;
        }
        return(gcd);
    }

公共静态长lgcd（长[]arr）{
长min=arr[0]；
对于（int i=0；iarr[i]）{
最小值=arr[i]；
}
}
ArrayList div_primes=新的ArrayList（）；
布尔isPrime[]=新布尔[（int）Math.sqrt（min）+1]；
对于（int i=0；i执行以下操作：-

在列表中找到最小的数字S
求S的所有素因子
对于每个素数pi，求xi=最小值（k1，k2，k3，…），其中ki是pi在数arr[i]中的幂
GCD=x1*x2*.xk
注意：当ki=1时，您可以在3中的任何迭代中停止，因为它将是最小值

Java实现：-

public static long lgcd(long[] arr) {

        long min = arr[0];

        for(int i=0;i<arr.length;i++) {
            if(min>arr[i]) {
                min = arr[i];
            }
        }

        ArrayList div_primes = new ArrayList();
        boolean isPrime[] = new boolean[(int)Math.sqrt(min)+1];
        for(int i=0;i<isPrime.length;i++)
            isPrime[i] = true;

        for(int j=2;j<isPrime.length;j++) {
            if(isPrime[j]) {
                int x = 2*j;
                if(min%j==0) {
                    div_primes.add(j);
                } 
                for(;x<isPrime.length;x=x+j) {
                    isPrime[x] = false;
                }
            }
        }

        if(div_primes.size()<1) {
           div_primes.add(min);
        }

        long gcd = 1;

        for(int i=0;i<div_primes.size();i++) {
            long curr = (Integer)div_primes.get(i);
            long x = min;
            for(int j=0;j<arr.length;j++) {
                long acc = arr[j];
                long fact = 1;
                while(acc>1&&acc%curr==0) {
                    acc = acc/curr;
                    fact = fact*curr;
                }
                x = Math.min(x,fact);
                if(fact==1)
                    break;
            }
            gcd = gcd*x;
        }
        return(gcd);
    }

公共静态长lgcd（长[]arr）{
长min=arr[0]；
对于（int i=0；iarr[i]）{
最小值=arr[i]；
}
}
ArrayList div_primes=新的ArrayList（）；
布尔isPrime[]=新布尔[（int）Math.sqrt（min）+1]；
对于（int i=0；iI）可以从阅读开始-它应该告诉您实现这个（欧几里德算法）需要知道什么，你可能还想确保你清楚最大公约数和最小公倍数之间的区别和联系。你是说最大公约数吗？因为4>2让我担心我的无知。我会从阅读开始——它应该告诉你实现这个（欧几里德算法）需要知道什么，你可能还想弄清楚最大公约数和最小公约数之间的区别和联系。你是说最大公约数吗？因为4>2让我担心我的无知。