这是我的程序
// ************************************************************
// 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循环中找到另一种方法来获得正确的答案。
2的幂可以简单地由位移算子计算
int exponent = ...
int powerOf2 = 1 << exponent;
即使对于更通用的形式，也不应该通过"将n乘以"来计算指数。相反，您可以通过对进行平方来进行指数运算
这是一篇允许进行负/正功率计算的文章。
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;
}
您可以实现自己的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;
}
如果没有性能限制，您可以执行：
double x1=1;
for(int i=1;i<=numPowersOf2;i++){
x1 =* 2
}
您可以根据以下解释尝试这样做：
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;
}
目前尚不清楚您对使用循环的评论是愿望还是需求。如果这只是一个愿望，那么你可以使用一个不依赖于Math.Pow的数学身份。
xy = ey∙ln(x)在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);
}
// 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);
以下是我如何在不使用"myPow（x，n）"的情况下进行管理，而是使用"while"。（我只学习了两周Java，如果代码有点不稳定，请原谅：）
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++;
}
要在不使用内置Math.pow（）的情况下实现pow函数，我们可以使用以下递归方式来实现它。为了优化运行时，我们可以存储幂（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;
}
}
我知道这个答案已经很晚了，但如果允许您使用存储基数和指数的变量，您可以使用一个非常简单的解决方案。
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);
}
}
这将在积极和消极的基础上发挥作用，但不适用于消极的力量。
要在不使用Math.pow()的情况下获得指数值，可以使用循环：只要计数小于b（你的幂），你的循环就会有一个在数学上，它与拥有Math.pow() 相同
while (count <=b){
a= a* a;
}
试试这个简单的代码：
public static int exponent(int base, int power) {
int answer = 1;
for(int i = 0; i < power; i++) {
answer *= base;
}
return answer;
}