Question

Java中还有其他方法可以计算整数的幂吗？

我现在使用Math.pow(a, b)，但它会返回double，这通常需要做很多工作，当您只想使用int时，它看起来不太干净然后也将始终产生int）。

像Python中的a**b一样简单吗？

Answer 1

最佳算法基于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）。参考：More information

Answer 2

整数只有32位。这意味着其最大值为2^31 -1。如您所见，对于非常小的数字，您很快就会得到一个无法用整数表示的结果。这就是Math.pow使用double的原因。

如果您想要任意整数精度，请使用BigInteger.pow。但它的效率当然不高。

Answer 3

不，没有像a**b

那么短的东西

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

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

如果要使用pow并将结果转换为整数，请按如下方式转换结果：

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

Answer 4

当它的力量为2时。请记住，你可以使用简单快速的移位表达1 << exponent

示例：

2 ² = 1 << 2 = (int) Math.pow(2, 2)
2 ¹⁰ = 1 << 10 = (int) Math.pow(2, 10)

对于较大的指数（超过31），请使用long

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

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

（java）1L << 32 = 1L shl 32（kotlin）

Answer 5

Google Guava有整数的数学工具。 IntMath

Answer 6

您可以简单地使用之前使用过的Math.pow(a,b)，只需在其之前使用(int)转换其值即可。下面可以作为一个例子。

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

其中a和b可以是double或int个值。这将简单地将其输出转换为您需要的整数值。

Answer 7

Guava的数学库提供了两种在计算精确整数幂时很有用的方法：

pow(int b, int k)计算b到kth的幂，并包裹溢出

除了在溢出

上抛出ArithmeticException之外，

checkedPow(int b, int k)是完全相同的

个人checkedPow()满足了我对整数求幂的大部分需求，并且比使用双版本和舍入等更清洁和更好。在几乎所有我需要幂函数的地方，溢出是一个错误（或者不可能，但我想被告知是否有可能变得可能了。）

如果您想获得long结果，可以使用相应的LongMath方法并传递int个参数。

Answer 8

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 < b; c++)
            power *= a;

        return power;
    }

}

Answer 9

我设法修改（边界，甚至检查，否定nums检查）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;
        }
    }

Answer 10

用于计算功率的重复平方算法的简单（不检查溢出或参数有效性）实现：

/** 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<<i)) > 0)
            res *= a;
    }
    return res;
}

时间复杂度与指数p成对数（即与表示p所需的位数成线性关系）。

Answer 11

pow方法存在一些问题：

我们可以替换（y＆1）== 0; y％2 == 0
按位运算总是更快。

您的代码总是将y减1并执行额外的乘法运算，包括y为偶数的情况。最好将此部分放在else子句中。

public static long pow(long x, int y) {
        long result = 1;
        while (y > 0) {
            if ((y & 1) == 0) {
                x *= x;
                y >>>= 1;
            } else {
                result *= x;
                y--;
            }
        }
        return result;
    }

Answer 12

与Python（其中权力可以通过** b计算）不同，JAVA没有这种快捷方式来完成两个数字的强大效果。 Java在Math类中有一个名为pow的函数，它返回一个Double值

double pow(double base, double exponent)

但您也可以使用相同的函数计算整数的幂。在下面的程序中我做了同样的事情，最后我将结果转换为整数（类型转换）。按照示例：

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)返回一个BigInteger，其值为（this ^ exponent）。指数是整数而不是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 );
   }
}

Answer 13

使用以下逻辑计算a的n次方。

通常，如果我们想要计算a的n次幂。我们将'a'乘以n次。这种方法的时间复杂度将是O（n）将幂n除以2，计算Exponentattion =乘以'a'直到n / 2。价值加倍。现在时间复杂度降低到O（n / 2）。

public  int calculatePower1(int a, int b) {
    if (b == 0) {
        return 1;
    }

    int val = (b % 2 == 0) ? (b / 2) : (b - 1) / 2;

    int temp = 1;
    for (int i = 1; i <= val; i++) {
        temp *= a;
    }

    if (b % 2 == 0) {
        return temp * temp;
    } else {
        return a * temp * temp;
    }
}

Answer 14

base是您要加电的数字，n是电源，如果n为0，则返回1；如果n为1，则返回基数；如果不满足条件，则使用公式< strong> base *（powerN（base，n-1））例如：2升为使用此公式的公式是：2（base）* 2（powerN（base，n-1））。

-no-deduplicate

Answer 15

Apache有ArithmeticUtils.pow(int k, int e)。

Answer 16

import java.util.Scanner;

class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();

        for (int i = 0; i < t; i++) {

            try {
                long x = sc.nextLong();
                System.out.println(x + " can be fitted in:");
                if (x >= -128 && x <= 127) {
                    System.out.println("* byte");
                }
                if (x >= -32768 && x <= 32767) {
                    //Complete the code
                    System.out.println("* short");
                    System.out.println("* int");
                    System.out.println("* long");
                } else if (x >= -Math.pow(2, 31) && x <= Math.pow(2, 31) - 1) {
                    System.out.println("* int");
                    System.out.println("* long");
                } else {
                    System.out.println("* long");
                }
            } catch (Exception e) {
                System.out.println(sc.next() + " can't be fitted anywhere.");
            }

        }
    }
}

计算整数的幂

16 个答案: