¿Cómo haces exponenciación en C?

Intenté “x = y ** e”, pero eso no funcionó.

use la función pow (toma float s / double s).

man pow :

  #include  double pow(double x, double y); float powf(float x, float y); long double powl(long double x, long double y); 

EDITAR: Por cierto, para el caso especial de potencias enteras positivas de 2 , puede utilizar el desplazamiento de bits: (1 << x) será igual a 2 a la potencia x . Hay algunos errores potenciales con esto, pero en general sería correcto.

Para agregar a lo que dijo Evan : C no tiene un operador incorporado para la exponenciación, porque no es una operación primitiva para la mayoría de las CPU. Por lo tanto, se implementa como una función de biblioteca.

Además, para calcular la función e ^ x, puede usar las funciones exp(double) , expf(float) y expl(long double) .

Tenga en cuenta que no desea utilizar el operador ^ , que es el operador OR exclusivo a nivel de bits .

pow solo funciona en números de punto flotante ( double s, en realidad). Si quieres tomar poderes de enteros, y no se sabe que la base sea un exponente de 2 , tendrás que sacar los tuyos.

Por lo general, la forma tonta es lo suficientemente buena.

 int power(int base, unsigned int exp) { int i, result = 1; for (i = 0; i < exp; i++) result *= base; return result; } 

Aquí hay una solución recursiva que toma espacio y tiempo O(log n) lugar del tiempo O(n) fácil O(1) :

 int power(int base, int exp) { if (exp == 0) return 1; else if (exp % 2) return base * power(base, exp - 1); else { int temp = power(base, exp / 2); return temp * temp; } } 

Similar a una respuesta anterior, esto manejará potencias enteras positivas y negativas de un doble muy bien.

 double intpow(double a, int b) { double r = 1.0; if (b < 0) { a = 1.0 / a; b = -b; } while (b) { if (b & 1) r *= a; a *= a; b >>= 1; } return r; } 

La versión no recursiva de la función no es demasiado difícil, aquí está para los enteros:

 long powi(long x, unsigned n) { long p = x; long r = 1; while (n > 0) { if (n % 2 == 1) r *= p; p *= p; n /= 2; } return(r); } 

(Hackeado del código para elevar un valor doble a un poder entero – tuvo que eliminar el código para tratar con los recíprocos, por ejemplo).

 int power(int x,int y){ int r=1; do{ r*=r; if(y%2) r*=x; }while(y>>=1); return r; }; 

(iterativo)

 int power(int x,int y){ return y?(y%2?x:1)*power(x*x,y>>1):1; }; 

(si tiene que ser recursivo)

imo, el algoritmo definitivamente debería ser O (logn)

o simplemente puedes escribir la función de poder, con la recursión como un bono adicional

 int power(int x, int y){ if(y == 0) return 1; return (x * power(x,y-1) ); } 

sí, sí, sé que esto es menos espacio eficiente y la complejidad del tiempo, pero la recursión es simplemente más divertido!