Potencia sem Math.pow

Programação
#1

Ola, gostaria de saber como posso fazer a potencia sem usar a biblioteca math

#2

Usando um laço for:

int numero = 5;
int base = numero; //sem essa variavel o programa nao funciona
int expoente = 3;
        
for (int i = 1; i < expoente; i++){ //calcula o resultado final
     numero = base * numero;
}
System.out.println("resultado: " + numero); //imprime o resultado final

Porém, eu recomendo que você use a classe Math.

1 curtida
#3

Isso vai-me dizer que 5⁰ = 5 quando na realidade seria 1.

int base = 5;
int resultado = 1;
int expoente = 3;
    
for (int i = 0; i < expoente; i++){ //calcula o resultado final
 resultado = resultado * numero;
}
System.out.println("resultado: " + resultado); //imprime o resultado final
2 curtidas
#4

Depende.

Se o expoente for um número inteiro positivo, dá pra fazer um loop, como já indicaram acima.

Se o expoente for negativo, precisa de um pequeno ajuste. Como x-y é o mesmo que (1 / x)y, ficaria assim:

double base = 5;
int expoente = -3;

if (expoente < 0) {
    expoente = -expoente; // inverte o sinal do expoente, pra poder iterar corretamente
    base = 1.0 / base; // x^(-y) é o mesmo que (1 / x)^y
}
double resultado = 1.0;
for (int i = 0; i < expoente; i++) {
    resultado *= base;
}
System.out.println(resultado);

Agora se o expoente tiver casas decimais, aí já complica. Até daria para fazer alguma coisa como isso aqui:

static double pow(double base, double ex) {
    if (base == 0)
        return 0;
    if (ex == 0) {
        return 1;
    } else if (ex < 0) {
        return 1 / pow(base, -ex);
    } else if (ex > 0 && ex < 1) {
        return nthRoot(base, (int) (1 / ex));
    } else if ((int) ex % 2 == 0) {
        double half_pow = pow(base, ex / 2);
        return half_pow * half_pow;
    } else {
        return base * pow(base, ex - 1);
    }
}

static double nthRoot(double A, int n) {
    int k = 6;
    double x[] = new double[k];
    for (int i = 0; i < k; i++)
        x[i] = 1;
    for (int i = 0; i < k - 1; i++)
        x[i + 1] = (1.0 / n) * ((n - 1) * x[i] + A / pow(x[i], n - 1));
    return x[k - 1];
}

Mas aí já acho que é uma complicação desnecessária. A menos que seja um exercício para fins didáticos, o melhor é simplesmente usar Math.pow que já trata de todos esses casos para você.

Até porque fiz alguns testes com o código acima e os resultados nem sempre dão a mesma coisa. Ex:

double base = 5.2;
double expoente = 3.5;
System.out.println(Math.pow(base, expoente)); // 320.63557234467925
System.out.println(pow(base, expoente));      // 320.6357605596782
1 curtida