Question

我想弄明白这一点。如何编写一个java程序，找到一定值下的友好对，即10000，所以它必须比较0到0之间的所有数字，并找出哪些是友好对。然后我必须将输出作为2列矩阵。

我找出计算数字的正确除数然后总结的公式。

但我不能进一步使用将数字进行比较的for循环，以及最终输出，它将结果作为2列矩阵。

到目前为止，我是因素或分频器的总和，这就是我所拥有的

public class Amicable {

    public static int sumfactors(int n) {

        int sum=0;
            for(int div=1; div<=n; div++)
            {
                if(n%div==0)
                {
                    sum +=div;
                }

            }
            return sum-n;           
    }
}

Answer 1

首先，您可以改善方法的性能：

private static int sumFactors(int n)
{
    int sum = 0;
    for (int div=1; div<=n/2; div++)
    {
        if (n%div == 0)
        {
            sum += div;
        }
    }
    return sum;
}

然后，您可以将以下方法添加到您的班级：

private static int[][] getMatrix(int limit)
{
    int[] array = new int[limit];
    for (int i=2; i<limit; i++)
        array[i] = sumFactors(i);

    Map<Integer,Integer> map = new HashMap<Integer,Integer>();
    for (int i=2; i<limit; i++)
    {
        int j = array[i];
        if (j < i && i == array[j])
            map.put(i,j);
         // Check 'j < i' in order to:
         // 1. Avoid an illegal index when 'j >= limit'
         // 2. Avoid the insertion of the equivalent pair [j,i]
         // 3. Avoid the insertion of perfect numbers such as [6,6]
    }

    int[][] matrix = new int[map.size()][2];
    int index = 0;
    for (int key : map.keySet())
    {
        matrix[index][0] = key;
        matrix[index][1] = map.get(key);
        index++;
    }
    return matrix;
}

最后，您可以从主方法（例如）中调用它：

public static void main(String[] args)
{
    int[][] matrix = getMatrix(10000);
    for (int i=0; i<matrix.length; i++)
        System.out.println(matrix[i][0]+" "+matrix[i][1]);
}

Answer 2

我在下面提供了一个解决方案，该解决方案将找到友好的数字，直到达到限制并返回为2D数组。此处的代码

public static int[][] findAmicableNumbers(int N) {

    int checked = 0;

    Map<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();

    for (int i = 1; i <= N; i++) {

        int u = sumOfDivisors(i);

        if (i == u) {
            continue;
        }

        int v = sumOfDivisors(u);

        if (i != checked && i == v) {

            checked = u;
            map.put(i, u);
        }
    }

    int[][] result = new int[map.size()][2];

    int index = 0;
    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {

        result[index][0] = entry.getKey();
        result[index][1] = entry.getValue();

        index++;
    }

    return result;
}


public static int sumOfDivisors(int N) {

    int sum = 1;

    for (int i = 2; i * i <= N; i++) {

        if (N % i == 0) {

            sum += i;

            if (N / i != i) {
                sum += N / i;
            }
        }
    }

    return sum;
}


public static void main(String[] args) {

    int[][] res = findAmicableNumbers(10000);

    for (int[] a : res) {
        System.out.println(Arrays.toString(a));
    }
}

打印结果，

[220, 284]
[1184, 1210]
[2620, 2924]
[5020, 5564]
[6232, 6368]

Answer 3

这是一个应该起作用的简单解决方案

public static long ambicable(long c) {
int res=0;
    for(long i=1;i<c;i++){
        if(c%i==0) {
            res+=i;
        }
    }
    return res;
}
public static long pair(long a) {
    long c=0;
    for(long i=1;i<10000;i++) {
        if(i==ambicable(ambicable(i))&& i!=ambicable(i)) {
            c+=i;
        }
    }
    return c;
}

Java程序，用于查找低于10000的友好对，并将输出作为2列矩阵

3 个答案: