简单的代码不会输出所有需要的结果

Question

我有 Java 代码执行以下操作：

1. 适用于整数 a,b 从 2 到 100 的所有组合，两个一组。例如，2,2、2,3、...、100,100。为此，我只使用了两个 for 循环。

2. 对于每个集合，检查两个整数的 gcd 是否为 1（忽略 gcd 为 2 或更多的集合）。我使用 BigInteger Class 因为它有一个方法。

3. 如果 gcd 是 1，请检查这两个整数中的每一个是否都可以调和成底数 2 或更大和指数 3 或更大的完美幂。我就是这样做的：例如，让我们考虑集合 8,27。首先，代码找到两者的 max。然后，对于这个集合，我们可以检查的最大功率是 Math.log10(27)/Math.log10(2)，因为最小的基数可以是 2。这只是数学领域的一个技巧。将其保存在变量 powlim 中。然后我使用 for 循环和 Math.pow 来检查这两个整数是否都具有完美的 nth 根，就像这样；

for (double power = 3; power <= powlim; power++) {
      double roota = Math.pow(a, 1.0 / power);
      double rootb = Math.pow(b, 1.0 / power);

if ((Math.pow(Math.round(roota), power) == a) == true &&
   (Math.pow(Math.round(rootb), power) == b) == true) {

if (a < b) {
        System.out.println(a + "\t" + b);
           }
}

a<b 条件确保我不会得到重复的值，例如 8,27 和 27,8。就我的目的而言，两者是一回事。下面是完整的代码：

public static void main(String[] args) {
    for (int a = 2; a <= 100; a++) {
        for (int b = 2; b <= 100; b++) {
            BigInteger newa = BigInteger.valueOf(a);
            BigInteger newb = BigInteger.valueOf(b);
            BigInteger thegcd = newa.gcd(newb);
            if (thegcd.compareTo(BigInteger.ONE) == 0) {
                double highest = Math.max(a, b);
                double powlim = (Math.log10(highest) / Math.log10(2.0));

                for (double power = 3; power <= powlim; power++) {
                    double roota = Math.pow(a, 1.0 / power);
                    double rootb = Math.pow(b, 1.0 / power);

                    if ((Math.pow(Math.round(roota), power) == a) == true
                            && (Math.pow(Math.round(rootb), power) == b) == true {

                        if (a < b) {
                            System.out.println(a + "\t" + b);
                        }
                    }
                }
            }
        }
    }
}

到目前为止一切顺利。该代码工作正常。然而，一些满足上述所有标准的输出被忽略。例如，当我运行上面的代码时，我得到了；
8,27
16,81
27,64
我不明白的是为什么像 8,81 这样的集合会被忽略。它的 gcd 是 1 并且这两个整数都可以表示为基数 2 或更大和指数 3 或更大的完美幂。 8 是 2^3 而 27 是 3^3。为什么会这样？或者，您也可以提供自己的代码来完成相同的任务。我需要调查此类集合有多罕见（或常见）。

Answer 1

Math.pow(b, 1.0 / 幂);对于 81 是 4.32 然后你四舍五入 4.32，4 的 3 次方是 64。64 不等于 81。你应该做的是：Math.round(Math.pow(roota, power)) == a

另外，你需要分别遍历A和B的幂，看看这个数是否可以root。这意味着要额外检查 double 的舍入值是否与 double 相同。（意思是 pow 1/3、1/4 产生一个整数结果。）

    public static void main(String[] args) {
        for (int a = 2; a <= 100; a++) {
            for (int b = 2; b <= 100; b++) {
                BigInteger newa = BigInteger.valueOf(a);
                BigInteger newb = BigInteger.valueOf(b);
                BigInteger thegcd = newa.gcd(newb);

                if (thegcd.compareTo(BigInteger.ONE) == 0) {
                    double highest = Math.max(a, b);
                    double powlim = (Math.log10(highest) / Math.log10(2.0));

                    for (double powerA = 3; powerA <= powlim; powerA++) {
                        double roota = Math.pow(a, 1.0 / powerA);
                        for (double powerB = 3; powerB <= powlim; powerB++) {
                            double rootb = Math.pow(b, 1.0 / powerB);

                            if (rootb == Math.floor(rootb) && roota == Math.floor(roota))  {
                                if ((Math.round(Math.pow(roota, powerA)) == a) && (Math.round(Math.pow(rootb, powerB)) == b)) {

                                    if (a < b) {
                                        System.out.println(a + "\t" + b);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

简单的代码不会输出所有需要的结果

Simple code doesn't output all required results

java

pow