如何编写一个可以用 Java 计算幂的函数。没有循环

Question

我一直在尝试用 Java 编写一个简单的函数，它可以在不使用循环的情况下计算一个数的 n 次方。
然后我发现 Math.pow(a, b) 类...或方法仍然无法区分两者，理论不太好。所以我写了这个..

public static void main(String[] args) {

    int a = 2;

    int b = 31;

    System.out.println(Math.pow(a, b));

    }

然后我想在不使用循环的情况下制作自己的 Math.pow 我希望它看起来比循环更简单，比如使用某种类型的 Repeat 我做了很多直到我遇到我尝试使用 StringUtils.repeat
的 commons-lang3 包之前的研究 到目前为止，我认为这是语法：-

public static String repeat(String str, int repeat)
    StringUtils.repeat("ab", 2);

我在过去 24 小时 或更长时间内一直面临的问题是 StringUtils.repeat(String str, int 2); 重复字符串不输出puts、数字或计算。
我可以做些什么来克服这个问题，或者有没有其他更好的方法来创建一个计算幂的函数？
不使用循环或 Math.pow

这可能很有趣，但我花了一段时间才发现 StringUtils.repeat 只重复字符串，这就是我试图克服它的方法。万一它有帮助

 public static int repeat(int cal, int repeat){
     cal = 2+2;
     int result = StringUtils.repeat(cal,2);
     return result;
}  

我可以不使用递归吗？可能是这样的

public static RepeatThis(String a)
{
     System.out.println(a);
     RepeatThis(a);
} 

只是想深入了解 java，感谢您的所有 cmets，即使存在语法错误，只要理解逻辑对我有好处 :)

Answer 1

另一个复杂度为 O(Log(n)) 的实现

public static long pow(long base, long exp){        
    if(exp ==0){
        return 1;
    }
    if(exp ==1){
        return base;
    }

    if(exp % 2 == 0){
        long half = pow(base, exp/2);
        return half * half;
    }else{
        long half = pow(base, (exp -1)/2);
        return base * half * half;
    }       
}

Answer 2

尝试递归：

int pow(int base, int power){
    if(power == 0) return 1;
    return base * pow(base, --power);
}

Answer 3

处理具有 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;

}

Answer 4

这个处理负指数：

public static double pow(double base, int e) {
    int inc;
    if(e <= 0) {
        base = 1.0 / base;
        inc = 1;
    }
    else {
        inc = -1;
    }
    return doPow(base, e, inc);
}

private static double doPow(double base, int e, int inc) {
    if(e == 0) {
        return 1;
    }
    return base * doPow(base, e + inc, inc);
}

Answer 5

我认为在生产递归中只是不能提供高端性能。

double power(double num, int exponent)
{

double value=1;
int Originalexpn=exponent;
double OriginalNumber=num;

if(exponent==0)
    return value;

if(exponent<0)
{
    num=1/num;
    exponent=abs(exponent);
}

while(exponent>0)
{
    value*=num;
    --exponent;
}

cout << OriginalNumber << " Raised to  " << Originalexpn << " is " << value << endl;
return value;

}

Answer 6

使用此代码。

public int mypow(int a, int e){
    if(e == 1) return a;
    return a * mypow(a,e-1);
}

Answer 7

当然，创建你自己的递归函数：

public static int repeat(int base, int exp) {
 if (exp == 1) {
  return base;
 }

 return base * repeat(base, exp - 1);
}

数学.pow(a, b)

Math是类，pow是方法，a和b是参数。

Answer 8

这是一个计算数字幂的 O(log(n)) 代码。使用的算法技术是分而治之。它还接受负幂，即 x^(-y)

import java.util.Scanner;

public class PowerOfANumber{
        public static void main(String args[]){
                float result=0, base;
                int power;
                PowerOfANumber calcPower = new PowerOfANumber();
                /* Get the user input for the base and power */
                Scanner input = new Scanner(System.in);
                System.out.println("Enter the base");   
                base=input.nextFloat();
                System.out.println("Enter the power");
                power=input.nextInt();
                result = calcPower.calculatePower(base,power);
                System.out.println(base + "^" + power + " is " +result);
        }   
        private float calculatePower(float x, int y){ 
                float temporary;
                /* Termination condition for recursion */    
                if(y==0)
                        return 1;
                temporary=calculatePower(x,y/2);
                /* Check if the power is even */
                if(y%2==0)
                        return (temporary * temporary);
                else{
                        if(y>0)
                                return (x * temporary * temporary);
                        else
                                return (temporary*temporary)/x;
                }    
        }
}

Answer 9

记住definition of the logarithm，如果允许这些功能，可以使用ln 和exp 来完成。适用于任何正基数和任何实数指数（不一定是整数）：

x = 6.7^4.4
ln(x) = 4.4 * ln(6.7) = about 8.36
x = exp(8.36) = about 4312.5

您可以阅读更多here 和here。 Java 提供了ln 和exp。

Answer 10

递归方法是最简单的：

int power(int base, int exp) {
    if (exp != 1) {
        return (base * power(base, exp - 1));
    } else {
        return base;
    }
}

其中base 是数字，exp 是指数网络