Java 数组中元素的组合，用于获取数字的因子

我想要一个组合算法，…将数组中的元素乘以，除了它本身以外的每一个元素

请帮我组合例如：{1,2,3,4,5,6}

输出：1*2,1*3…1*6,1*2*3*2*4…….1*2*3*4*5*6…….5*6

---

代码删除了它与我的问题逻辑要求无关…

为什么不从一开始就将

arr

声明为

Set

Set<Integer> arr = new LinkedHashSet<Integer>();

Set arr=new LinkedHashSet（）；

---

就这样吧。您永远不需要重复，如果顺序很重要，LinkedHashSet会保留插入顺序。

为什么不从一开始就将

arr

声明为

Set

Set<Integer> arr = new LinkedHashSet<Integer>();

Set arr=new LinkedHashSet（）；

---

就这样吧。您永远不需要重复，如果顺序很重要，LinkedHashSet将保留插入顺序。

首先，查找因素。这是我自己代码中的一个片段。它在名为

因子的
数组列表
中构建
目标
的因子列表。当每个因素被发现时，它被记录一次，并根据需要划分出尽可能多的时间。然后相应地降低上限。变量
residence
保存
target
的未分解部分

int trialFactor = 0;
int residue = target;
limit = iSqrt(residue);
while (trialFactor < limit) {
    trialFactor = nextPrime(trialFactor);
    if (residue % trialFactor == 0) {
        factors.add(trialFactor);
        do {
            // Remove repeated factors.
            residue /= trialFactor;
        } while (residue % trialFactor == 0);
        limit = iSqrt(residue);
    }
}
// Record largest factor, if present.
if (residue > 1) { factors.add(residue); }

int-trialFactor=0；
int剩余=目标；
限值=iSqrt（残留量）；
while（三因素<极限）{
trialFactor=nextTime（trialFactor）；
if（剩余%trialFactor==0）{
因子。添加（三因子）；
做{
//消除重复因素。
残基/=三因素；
}而（残基%trialFactor==0）；
限值=iSqrt（残留量）；
}
}
//记录最大系数（如果存在）。
如果（剩余>1）{因子。加（剩余）；}

我自己使用了两种功能：

int nexttime（int）
返回下一个最高质数

int-iSqrt（int）
返回整数平方根<代码>iSqrt（10）

返回3

现在是问题的第二部分，组合。您有一组项目，您需要所有可能的组合。如果有n个项目，则只需迭代所有数字0到（2^n）-1。这将为您提供从000开始的所有位模式。。。000到111。。。111对于组中的每个职位，“0”表示不将其包含在输出中，而“1”表示将其包含在输出中

---

以{1,2,3,4,5,6}为例，需要0到2^6-1=63的数字。例如，45是二进制的101101，因此45的输出是{1,3,4,6}。

首先，查找因子。这是我自己代码中的一个片段。它在名为

因子的
数组列表
中构建
目标
的因子列表。当每个因素被发现时，它被记录一次，并根据需要划分出尽可能多的时间。然后相应地降低上限。变量
residence
保存
target
的未分解部分

int trialFactor = 0;
int residue = target;
limit = iSqrt(residue);
while (trialFactor < limit) {
    trialFactor = nextPrime(trialFactor);
    if (residue % trialFactor == 0) {
        factors.add(trialFactor);
        do {
            // Remove repeated factors.
            residue /= trialFactor;
        } while (residue % trialFactor == 0);
        limit = iSqrt(residue);
    }
}
// Record largest factor, if present.
if (residue > 1) { factors.add(residue); }

int-trialFactor=0；
int剩余=目标；
限值=iSqrt（残留量）；
while（三因素<极限）{
trialFactor=nextTime（trialFactor）；
if（剩余%trialFactor==0）{
因子。添加（三因子）；
做{
//消除重复因素。
残基/=三因素；
}而（残基%trialFactor==0）；
限值=iSqrt（残留量）；
}
}
//记录最大系数（如果存在）。
如果（剩余>1）{因子。加（剩余）；}

我自己使用了两种功能：

int nexttime（int）
返回下一个最高质数

int-iSqrt（int）
返回整数平方根<代码>iSqrt（10）

返回3

现在是问题的第二部分，组合。您有一组项目，您需要所有可能的组合。如果有n个项目，则只需迭代所有数字0到（2^n）-1。这将为您提供从000开始的所有位模式。。。000到111。。。111对于组中的每个职位，“0”表示不将其包含在输出中，而“1”表示将其包含在输出中

---

以{1,2,3,4,5,6}为例，需要0到2^6-1=63的数字。举个例子，45是二进制的101101，所以45的输出是{1,3,4,6}。

我相信这就是您要寻找的：

//This method return a list of lists, where each "inner list" contains as
//its first number the number for which the factors are being found, and
//every other number is a factor.
//It takes an array of all the numbers whose factor you wish to find
public List<List<Integer>> getAllFactors(int[] toCalculate){
    List<List<Integer>> toReturn = new ArrayList<List<Integer>>();
    List<Integer> factors;
    for(int i = 0; i < toCalculate.length; i++){
        factors = new ArrayList<Integer>();
        factors.add(toCalculate[i]); //add the number whose factors will be calculated
        //the square root is used because it is the largest number you can divide by without getting "overlap"
        for(int j = 1; j <= Math.sqrt(toCalculate[i]); j++){ 
            if(toCalculate[i]%j==0){ //if it divides evenly, add it
                factors.add(j);
                factors.add((Integer)toCalculate[i]/j); //also add its "partner" number
            }
        }
        toReturn.add(factors);
    }
    return toReturn;
}

我意识到这不是问题所要求的。。。我想。。。我真的不知道。。。 无论如何，我写了另一种方法：

public List<Integer> getAllFactors(int number){
    List<Integer> factors = new ArrayList<Integer>();
    for(int i = 2; i <= Math.sqrt(number); i++){
        if(number%i==0){
            factors.add(number);
            factors.addAll(getAllFactors(i));
            factors.addAll(getAllFactors(number/i));
        }
    }
    if(factors.isEmpty())
        factors.add(number);
    return factors;
}

公共列表getAllFactors（整数）{
列表因子=新的ArrayList（）；
对于（int i=2；i我相信这就是您要寻找的：

//This method return a list of lists, where each "inner list" contains as
//its first number the number for which the factors are being found, and
//every other number is a factor.
//It takes an array of all the numbers whose factor you wish to find
public List<List<Integer>> getAllFactors(int[] toCalculate){
    List<List<Integer>> toReturn = new ArrayList<List<Integer>>();
    List<Integer> factors;
    for(int i = 0; i < toCalculate.length; i++){
        factors = new ArrayList<Integer>();
        factors.add(toCalculate[i]); //add the number whose factors will be calculated
        //the square root is used because it is the largest number you can divide by without getting "overlap"
        for(int j = 1; j <= Math.sqrt(toCalculate[i]); j++){ 
            if(toCalculate[i]%j==0){ //if it divides evenly, add it
                factors.add(j);
                factors.add((Integer)toCalculate[i]/j); //also add its "partner" number
            }
        }
        toReturn.add(factors);
    }
    return toReturn;
}

我意识到这不是问题的目的…我想…我真的说不出来。。。
无论如何，我写了另一种方法：

public List<Integer> getAllFactors(int number){
    List<Integer> factors = new ArrayList<Integer>();
    for(int i = 2; i <= Math.sqrt(number); i++){
        if(number%i==0){
            factors.add(number);
            factors.addAll(getAllFactors(i));
            factors.addAll(getAllFactors(number/i));
        }
    }
    if(factors.isEmpty())
        factors.add(number);
    return factors;
}

公共列表getAllFactors（整数）{
列表因子=新的ArrayList（）；
对于（int i=2；如果您希望它快速，我不使用
log
或
pow
。）你可能会发现，把所有的因子都计算到一个数字会更快，因为它更简单。@Peter Lawrey，我知道，我只是想看看这会怎样work@Peter劳瑞，谢谢，我得到了一个类似的问题，必须使用递归。如果你想让它快速，不要使用
log
或
pow
。）你可能会发现，把所有的因子都计算到一个数字会更快，因为它更简单。@Peter Lawrey，我知道，我只是想看看这会怎样work@Peter劳瑞，谢谢，我得到了一个类似的问题，必须使用递归，好的，谢谢，好的，我会修改它，你能告诉我有效组合的方法吗…好的，谢谢，好的，我会修改它，你能告诉我有效组合的方法吗…它只计算数字的素数因子…不是所有因子，我需要所有因子然后记录所有素数因子，包括重复项。移动
因子。添加（trialFactor）；
行到内部do循环中。4的因子将被记录为{2,2}15（3*5），仍然需要组合，如何组合正是我的问题，你有{1,2,3,4,5,6}。提取一个元素：{1}leavin