Question

我讨厌不得不问，但我很困惑。

我需要测试一系列数字，找出第一个有500多个因素的数字： http://projecteuler.net/index.php?section=problems&id=12

- 首先我试图强行给出答案（在很长一段时间后找到一个480的数字）

- 我现在正在考虑确定数字的素因子，然后用它们来找出所有其他因素。

我目前处于这样的阶段：我可以为我输入的任何数字得到一系列素数因子 - 即300具有素因子2 2 3 5 5

使用这个素数因子我需要能够计算剩余因子 - 这是我坚持的部分。基本上，据我所知，我需要计算数组中所有可能的数字组合......

即 2 * 2
2 * 2 * 3
2 * 2 * 3 * 5
2 * 3
2 * 3 * 3
......等等 - 但它变得有趣的地方就是... ... 2 * 5
2 * 3 * 5
......即阵列中彼此不相邻的数字

我无法想到以任何长度数组的通用方式对此进行编码的方法......

我需要帮助！ P.S - 我在Java工作

编辑：我的强力代码 - 因为有人建议暴力破解问题会起作用，所以我的代码可能会出错：（

package euler.problem12;

public class Solution {

    public static void main(String[] args) {
        int next = 1;
        int triangle = 0;
        int maxFactors = 0;

        while(true) {
            triangle = triangle + next;

            int factors = 1;
            int max = (int) triangle / 2;

            for(int i = 1; i <= max; ++i) {
                if(triangle % i == 0) {
                    factors ++;
                }
            }

            if(factors > maxFactors) {
                maxFactors = factors;

                System.out.println(triangle + "\t" + factors);
            }

            next++;
        }
    }
}

Answer 1

好的，第二次尝试，因为我太困难了。

这里给出答案：http://mathforum.org/library/drmath/view/57151.html

如果您将数字计入其素数功率因数，则总数通过添加一个来找到因子所有的指数和乘法那些结果在一起。示例：108 = 2 ^ 2 * 3 ^ 3，所以总数因子是（2 + 1）*（3 + 1）= 3 * 4 = 12。果然，108的因素是1， 2,3,4,6,9,12,18,27,36,54和 108.这是因为要成为一个因素，数字必须相同素数，并提升到相同或更低的权力。

因此，如果您知道主要因素，您只需计算重复因子并使用上述计算来计算因子数。

Answer 2

据我所知，问题12没有提及有关素数的任何内容？这是你正在看的那个吗？

通过添加自然数...
生成三角数序列

如果是这样，那么也许不考虑素数会有所帮助？ ;）

Answer 3

可能3个月太晚了，但是这里......

我看到答案二已经提供了功能，可以为您提供所需的答案，但是在回答您关于如何根据某些原因产生所有因素的原始问题时，请按照以下方式进行操作：< / p>

假设你有数组中的因子：

int [] primeFactors = new int [] {2,2,3,5,5};

您需要做的是递归每个可能深度的每个有序排列，然后将结果结果集减少为唯一值。

我会解释我的意思： “有序排列”：假设您从数组的第0位开始，下一个元素必须是1,2,3或4，如果从1开始，那么下一个元素必须是2,3或4，依此类推。

“每个可能的深度”：每个因素，然后是任何两个因素，然后是任何三个因素，依此类推，直到你得到所有五个因素。

“减少设置”：如果你采用两个元素，比如0和3,0和4,1和3或1和4它们都给你2 * 5 = 10，它们都提供因子10，所以你需要将你的设置告知不同的价值观。（哎呀，这比我预期的要长......：））

这样做的方法是使用两个方法，一个用于选择最大递归深度，启动再生，winnow用于最终结果，另一个用于递归值：

public static void main(String[] args) {
    int[] primeFactors = new int[] {2, 2, 3, 5, 5};
    List<Integer> allFactors = getAllFactors(primeFactors);
    for (int factor : allFactors) {
        System.out.println("Factor: " + factor);
    }
}

private static List<Integer> getAllFactors(int[] primeFactors) {
    Set<Integer> distinctFactors = new HashSet<Integer>();
    for (int maxDepth = 0; maxDepth <= primeFactors.length; maxDepth++) {
        permutatPrimeFactors(0, maxDepth, 0, 1, primeFactors, distinctFactors);
    }
    List<Integer> result = new ArrayList<Integer>(distinctFactors);
    Collections.sort(result);
    return result;
}

private static void permutatPrimeFactors(int depth, int maxDepth, int minIndex, int valueSoFar, int[] primeFactors, Set<Integer> distinctFactors) {
    if (depth == maxDepth) {
        distinctFactors.add(valueSoFar);
        return;
    }

    for (int index = minIndex; index < primeFactors.length; index++) {
        permutatPrimeFactors(depth + 1, maxDepth, index + 1, valueSoFar * primeFactors[index], primeFactors, distinctFactors);
    }
}

getAllFactors使用Set来确保我们只获取不同的值，而不是将它们添加到列表中并对其进行排序，以便我们可以按顺序显示因子。

虽然permutatPrimeFactors，从零项（因子= 1）到所有项（因子= 1 * 2 * 2 * 3 * 5 * 5 = 300）生成。

希望有所帮助。

欧拉项目帮助（问题12） - 主要因素等

3 个答案: