如何在不使用 java 的 math.pow 的情况下获得指数答案

【问题标题】：how to get exponents without using the math.pow for java如何在不使用 java 的 math.pow 的情况下获得指数
【发布时间】：2014-04-19 16:44:23
【问题描述】：

这是我的程序

// ************************************************************
    // PowersOf2.java
    //
    // Print out as many powers of 2 as the user requests
    //
    // ************************************************************

    import java.util.Scanner;

    public class PowersOf2 {

    public static void main(String[] args)

    {
        int numPowersOf2; //How many powers of 2 to compute
        int nextPowerOf2 = 1; //Current power of 2
        int exponent= 1;
        double x;

         //Exponent for current power of 2 -- this
        //also serves as a counter for the loop Scanner

        Scanner scan = new Scanner(System.in);
        System.out.println("How many powers of 2 would you like printed?");
        numPowersOf2 = scan.nextInt();
        System.out.println ("There will be " + numPowersOf2 + " powers of 2 printed");
        //initialize exponent -- the first thing printed is 2 to the what?

    while( exponent <= numPowersOf2)
        {
        double x1 = Math.pow(2, exponent);
        System.out.println("2^" + exponent + " = " + x1);
                exponent++;
        }   
//print out current power of 2
//find next power of 2 -- how do you get this from the last one?
//increment exponent

    }
}

问题是我不允许使用 math.pow 方法，我需要在 while 循环中找到另一种方法来获得正确答案。

【问题讨论】：

乘以可能？！？毕竟next power = previous power * 2..eg 2^1=2 2^2 = 4, 2^3 = 4*2 = 8
一定要保存电源是否为负。如果是这样，除而不是乘。
获取您使用的指数log，而不是pow。 pow 用于获取权限

标签： java math pow exponent

【解决方案1】：

2 的幂可以通过 Bit Shift Operators 简单计算

int exponent = ...
int powerOf2 = 1 << exponent;

即使是更一般的形式，您也应该不通过“乘以 n 次”来计算指数。相反，你可以这样做Exponentiation by squaring

【讨论】：

【解决方案2】：

这是一个允许负/正功率计算的帖子。

https://stackoverflow.com/a/23003962/3538289

处理具有 O(log(n)) 复杂度的 +/- 指数的函数。

double power(double x, int n){
 if(n==0)
  return 1;

  if(n<0){
      x = 1.0/x;
      n = -n;
  }
 double ret = power(x,n/2);
 ret = ret * ret;
 if(n%2!=0)
   ret = ret * x;
 return ret;
}

【讨论】：

【解决方案3】：

您可以实现自己的power 函数。

power 函数的复杂性取决于您的要求和约束。例如，您可以将指数限制为仅是正整数。

这是power函数的示例：

public static double power(double base, int exponent) {
    double ans = 1;
    if (exponent != 0) {
        int absExponent = exponent > 0 ? exponent : (-1) * exponent;
        for (int i = 1; i <= absExponent; i++) {
            ans *= base;
        }

        if (exponent < 0) {
            // For negative exponent, must invert
            ans = 1.0 / ans;
        }
    } else {
        // exponent is 0
        ans = 1;
    }

    return ans;
}

【讨论】：

【解决方案4】：

如果没有性能限制，您可以这样做：

double x1=1;

for(int i=1;i<=numPowersOf2;i++){
   x1 =* 2
}

【讨论】：

这个有性能限制。将是O(n)。可以在O(1)时间完成。

【解决方案5】：

你可以尝试根据这个explanation来做这个：

 public double myPow(double x, int n) {

    if(n < 0) {
        if(n == Integer.MIN_VALUE) {
            n = (n+1)*(-1);
            return 1.0/(myPow(x*x, n));
        }
        n = n*(-1);
        return (double)1.0/myPow(x, n);
    }
    double y = 1;
    while(n > 0) {
        if(n%2 == 0) {
           x = x*x; 
        }
        else {
            y = y*x;
            x = x*x;
        }
         n = n/2;
    }
    return y;   
}

【讨论】：

【解决方案6】：

目前尚不清楚您对使用循环的评论是一种愿望还是一种要求。如果这只是一个愿望，那么您可以使用不依赖于Math.Pow 的数学身份。

x<sup>y</sup> = e<sup>y∙ln(x)</sup>

在 Java 中是这样的

public static double myPow(double x, double y){
  return Math.exp(y*Math.log(x));
}

如果你真的需要一个循环，你可以使用类似下面的东西

public static double myPow(double b, int e) {
  if (e < 0) {
    b = 1 / b;
    e = -e;
  }

  double pow = 1.0;
  double intermediate = b;
  boolean fin = false;

  while (e != 0) {
    if (e % 2 == 0) {
      intermediate *= intermediate;
      fin = true;
    } else {
      pow *= intermediate;
      intermediate = b;
      fin = false;
    }
    e >>= 1;
  }

  return pow * (fin ? intermediate : 1.0);
}

【讨论】：

【解决方案7】：

// Set the variables

int numPowersOf2;        //How many powers of 2 to compute
int nextPowerOf2 = 1;    //Current power of  2
int exponent = 0;  


/* User input here */

// Loop and print results

do
   {

    System.out.println ("2^" + exponent + " = " + nextPowerOf2);

    nextPowerOf2 = nextPowerOf2*2;

    exponent ++;
  } 
while (exponent < numPowersOf2);

【讨论】：

【解决方案8】：

这是我不使用“myPow(x,n)”而是使用“while”的管理方式。（我才学 Java 2 周，请原谅，如果代码有点笨拙:)

    String base ="";
    String exp ="";
    BufferedReader value = new BufferedReader (new InputStreamReader(System.in));
    try {System.out.print("enter the base number: ");
        base = value.readLine();
        System.out.print("enter the exponent: ");
        exp = value.readLine(); }
    catch(IOException e){System.out.print("error");}

    int x = Integer.valueOf(base);
    int n = Integer.valueOf(exp);
    int y=x;
    int m=1;       
    while(m<n+1) {
        System.out.println(x+"^"+m+"= "+y);
        y=y*x;
        m++;    
    }

【讨论】：

【解决方案9】：

要在不使用内置 Math.pow() 的情况下实现 pow 函数，我们可以使用下面的递归方式来实现它。为了优化运行时，我们可以存储 power(a, b/2) 的结果并根据偶数或奇数的次数重复使用它。

static float power(float a, int b)
{
    float temp;
    if( b == 0)
        return 1;
    temp = power(a, b/2); 

    // if even times
    if (b%2 == 0)
        return temp*temp;
    else  // if odd times
    {
        if(b > 0)
            return a * temp * temp;
        else  // if negetive i.e. 3 ^ (-2)
            return (temp * temp) / a;
    }
}

【讨论】：

【解决方案10】：

我知道这个答案已经很晚了，但是如果允许您拥有存储基数和指数的变量，则可以使用一个非常简单的解决方案。

public class trythis {
    public static void main(String[] args) {
        int b = 2;
        int p = 5;
        int r = 1;
        for (int i = 1; i <= p; i++) {
            r *= b;
        }
        System.out.println(r);
    }
}

这适用于正基和负基，但不适用于负幂。

【讨论】：

【解决方案11】：

要在不使用Math.pow() 的情况下获得指数值，您可以使用循环：只要计数小于 b （你的力量），你的循环就会有附加“* a”。从数学上讲，它与拥有Math.pow() 相同

while (count <=b){
    a= a* a;
}

【讨论】：

【解决方案12】：

试试这个简单的代码：

public static int exponent(int base, int power) {
   int answer = 1;

   for(int i = 0; i < power; i++) {
      answer *= base;
   }

   return answer;
}

【讨论】：