4

我一直在尝试用 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); 重复字符串而不是输出或数字或计算。 我能做些什么来克服这个问题，或者有没有其他更好的方法来创建一个计算幂的函数？不使用循环或 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，感谢您的所有评论，即使存在语法错误，只要理解对我有好处的逻辑：)

4

10 回答 10

13

复杂度为 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;
    }       
}
于 2013-12-27T21:29:29.850 回答
8

尝试递归：

int pow(int base, int power){
    if(power == 0) return 1;
    return base * pow(base, --power);
}
于 2013-10-17T11:54:58.233 回答
5

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

}

于 2014-04-11T05:08:23.473 回答
1

这个处理负指数：

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);
}
于 2013-10-17T13:54:17.820 回答
1

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

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;

}

于 2014-09-07T07:48:52.773 回答
0

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

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参数。

于 2013-10-17T11:54:15.550 回答
0

使用此代码。

public int mypow(int a, int e){
    if(e == 1) return a;
    return a * mypow(a,e-1);
}
于 2013-10-17T11:54:22.327 回答
0

这是一个计算数字幂的 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;
                }    
        }
}
于 2015-04-14T05:20:51.827 回答
0

记住对数的定义，如果允许这些函数，可以使用ln和exp来完成。适用于任何正基数和任何实指数（不一定是整数）：

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

您可以在此处和此处阅读更多信息。Java 提供了ln和exp。

于 2021-11-03T07:43:28.743 回答
-1

递归方法将是最简单的：

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

哪里base是数字，exp是指数

于 2013-10-17T11:56:22.127 回答