以Java计算能力

在Java中有没有其他的方式来计算一个整数的幂? 我现在使用Math.pow(a,b),但是它返回一个double,这通常是很多工作,并且当你只想使用整数时看起来不那么干净(一个权力总是会产生一个整数) 。

Python中有没有像Python那样简单的东西?

整数只有32位。 这意味着它的最大值是2 ^ 31 -1。 正如你所看到的,对于非常小的数字,你很快就会有一个不能用整数表示的结果。 这就是为什么Math.pow使用双。

如果你想要任意的整数精度,使用BigInteger.pow 。 但它当然效率较低。

最好的算法是基于a ^ b的递归功率定义。

 long pow (long a, int b) { if ( b == 0) return 1; if ( b == 1) return a; if (isEven( b )) return pow ( a * a, b/2); //even a=(a^2)^b/2 else return a * pow ( a * a, b/2); //odd a=a*(a^2)^b/2 } 

运行的运行时间是O(logb)。 参考: 更多信息

不,没有什么比a**b

这是一个简单的循环,如果你想避免双打:

 long result = 1; for (int i = 1; i <= b; i++) { result *= a; } 

如果要使用pow并将结果转换为整数,则按如下所示投射结果:

 int result = (int)Math.pow(a, b); 

谷歌番石榴有整数数学实用程序。 IntMath

番石榴的数学图书馆提供了两种方法,在计算确切的整数权力时很有用:

pow(int b, int k)计算b到k的权力,并包装溢出

checkedPow(int b, int k)除了在溢出时抛出ArithmeticException之外是相同的

就个人而言, checkedPow()满足了我对整数幂checkedPow()大部分需求,比使用double版本和四舍五入更清晰,更经济。在几乎所有需要function函数的地方,溢出是一个错误(或不可能,但是我想被告知是否不可能变得可能)。

如果你想得到一个long结果,你可以使用相应的LongMath方法并传递int参数。

那么您可以简单地使用Math.pow(a,b)就像之前使用的一样,只需在它之前使用(int)来转换它的值即可。 下面可以作为一个例子。

 int x = (int) Math.pow(a,b); 

其中ab可以是你想要的double或者int值。 这将简单地将其输出转换为一个整数值,如你所需。

 import java.util.*; public class Power { public static void main(String args[]) { Scanner sc=new Scanner(System.in); int num = 0; int pow = 0; int power = 0; System.out.print("Enter number: "); num = sc.nextInt(); System.out.print("Enter power: "); pow = sc.nextInt(); System.out.print(power(num,pow)); } public static int power(int a, int b) { int power = 1; for(int c=0;c 

对于计算功率的重复平方算法实现一个简单的(不检查溢出或对参数的有效性):

 /** Compute a**p, assume result fits in a 32-bit signed integer */ int pow(int a, int p) { int res = 1; int i1 = 31 - Integer.numberOfLeadingZeros(p); // highest bit index for (int i = i1; i >= 0; --i) { res *= res; if ((p & (1< 0) res *= a; } return res; } 

时间复杂度是指数p的对数(即对于表示p所需的位数是线性的)。

我设法修改(边界,甚至检查,负数检查)Qx__答案。 使用风险自负。 0 ^ -1,0 ^ -2等。返回0。

 private static int pow(int x, int n) { if (n == 0) return 1; if (n == 1) return x; if (n < 0) { // always 1^xx = 1 && 2^-1 (=0.5 --> ~ 1 ) if (x == 1 || (x == 2 && n == -1)) return 1; else return 0; } if ((n & 1) == 0) { //is even long num = pow(x * x, n / 2); if (num > Integer.MAX_VALUE) //check bounds return Integer.MAX_VALUE; return (int) num; } else { long num = x * pow(x * x, n / 2); if (num > Integer.MAX_VALUE) //check bounds return Integer.MAX_VALUE; return (int) num; } } 

与Python(可以通过** b计算权力)不同,JAVA没有这样的快捷方式来完成两个数字的结果。 Java在Math类中有名为pow的函数,它返回一个Double值

 double pow(double base, double exponent) 

但是你也可以使用相同的函数来计算整数的幂。 在下面的程序中,我做了同样的事情,最后我将结果转换为一个整数(types转换)。 根据例子:

 import java.util.*; import java.lang.*; // CONTAINS THE Math library public class Main{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); int n= sc.nextInt(); // Accept integer n int m = sc.nextInt(); // Accept integer m int ans = (int) Math.pow(n,m); // Calculates n ^ m System.out.println(ans); // prints answers } } 

或者, java.math.BigInteger.pow(int exponent)返回值为(this ^ exponent)的BigInteger。 指数是一个整数,而不是一个BigInteger。 例:

 import java.math.*; public class BigIntegerDemo { public static void main(String[] args) { BigInteger bi1, bi2; // create 2 BigInteger objects int exponent = 2; // create and assign value to exponent // assign value to bi1 bi1 = new BigInteger("6"); // perform pow operation on bi1 using exponent bi2 = bi1.pow(exponent); String str = "Result is " + bi1 + "^" +exponent+ " = " +bi2; // print bi2 value System.out.println( str ); } } 

当它是2的幂。记住,你可以使用简单而快速的1 <<指数的例子。

 2^2 == (int) Math.pow(2,2) == 1 << 2 2^10 == (int) Math.pow(2,10) == 1 << 10 

对于更大的指数(超过31)使用长而不是

 2^32 == (long) Math.pow(2,32) == 1L << 32 

顺便说一句。 在Kotlin你有shl而不是<< so

 1L << 32 == 1L shl 32