-1

如果 x 可以表示为另一个数 b^p，我们说 p 是一个数 x 的完美 p 次方。

即如果 x=b^p ，则 p 是 x 的完美 p 次方。

我很少有 x 可以是正整数、负整数甚至分数的用例。前两种情况在 java 中可以很容易地处理，但是当 x 是分数时，如何使用 java 找出数字 x 的完美 p 次方。如果 x 是分数，我们可以简单地使用 Math.sqrt(x) 并得到一个使 b^2 =x 的数字 b，这不是真的吗？那么 2 将是 x 的完美 pth 次方。这个案子还有效吗？

我不一定要寻找代码，而是如果 x 是分数，则确定 java 中 x 的完美 pth 幂的逻辑。如果有人认为此案无效，也请说明您的理由。

下面是我编写的用于处理 x 是正整数或 0 到 1 之间的数字的情况的代码。但是我们可以处理 x 是的情况，例如。45.487,875515.54884 等？

public class PerfectPower {

public PerfectPower() {

    }

    public Integer getPerfectPower(double x){

        // x=b^p

        int p = 0;
        double b;

        if(x==0){
            throw new IllegalArgumentException("Cannot accept number 0.");
        }

        if (x > 1) {
            for (b = 2; b <= x; b++) {

                double value = 0;
                p = 1;

                while (value <= x) {

                    value = Math.pow(b, p);

                    if (value == x) {
                        return p;
                    } else if (value > x) {
                        break;
                    } else {
                        p++;
                    }
                }

            }
        } else if(x>0 && x<1){

            for (b = 2; (1/b) >= x; b++) {

                double value = 1;
                p = -1;

                while (value >= x) {

                    value = Math.pow(b, p);

                    if (value == x) {
                        return p;
                    } else if (value < x) {
                        break;
                    } else {
                        p--;
                    }
                }

            }

        }

        return null;

    }
4

2 回答 2

0

我们可以使用对数以简单的方式做到这一点。它如下： 

x = b^p    log(base b)x = p     log x/log b = p

所以我们可以通过 x 迭代 b = 2 并检查 p 是否为完美整数并返回值。对于十进制情况，我们可以进一步调整对数公式。 

log b = (log x)/p    Hence b = 10^(log x)/p)

在每次迭代中，我们可以检查是否 b^p = x 以及是否返回 p。我解决了这个问题，假设 p 应该是一个整数。然而，对于 p 可以是十进制且 x 介于 0 到 1 之间的情况，应该对该解决方案进行更多调整。下面是我在 scala 中实现的代码。

def perfectpowerlog(x: Double): Double = {
    var i: Double = 2
    var n: Double = 1
    var p: Double = 0
    val loop = new Breaks
    if (x == 1) {
        return n
    }
    if (x.ceil == x) {
        loop.breakable {
            while (i<=x) {
                p = math.log(x)/math.log(i)
                if (p.toInt == p) {
                    n = p
                    loop.break()
                }
                else
                    i=i+1
            }
        }
    }
    else {
        loop.breakable {
            while(i<=x.ceil) {
                p = pow(10,(log10(x)/i))
                if(pow(p,i) == x) {
                    n = i
                    loop.break()
                }
                else
                    i = i+1
            }
        }
    }
    return n
}
于 2018-09-18T10:19:54.027 回答
0

由于 45 487.875 515 548 84 （以这个为例）不是整数，它可以表示为 b ^ p 其中 b 和 p 是整数的唯一方法是如果 p 是负数。也就是说，您的数字可能是某个（大）整数的平方根、立方根、四次根等。

第一个问题是精度问题。您的数字不能在 Java 双精度中精确表示。您可以使用BigDecimal. 它也不能精确地是某个整数的某个根，因此您必须决定接受的容差。

据我所知，您的大问题是可能的 p 值范围是无限的。甚至可能所有数字都足够接近某个（大）整数的第 p 根，而您无法合理区分；我不知道，这当然取决于你的容忍度。

我认为您可以尝试的最好的事情是将您的数字提高到 2、3、4 等，然后看看您何时接近整数。如果你的 q 次方数足够接近整数，则返回 -q 作为你的 p。在失去耐心之前停止搜索。:-)

于 2018-09-01T12:08:16.143 回答