[SOLUCIONADO] Algoritmo potencia

[Lifka]

Buenas, tal vez os parezca algo tonto, pero necesito un algoritmo para potencia que no sea por recursividad, ni usando bucle, ni la función pow... sé que puede sonar extraño, ¿pero a alguien con imaginación se le ocurre algo?
Saludos!

[lareto]

Código C++:

double b = 2;
int n = 3;
// b ^ n = 2 ^ 3 = 8
std::cout << b << " elevado a la " << n << " es " << std::exp(n*std::log(b)) << std::endl;
 

Lareto :)

[Lifka]

Perfecto, muchas gracias Lareto :)
Eso sí, no puedo usar esas funciones tampoco , ¿sabes como podría hacer a mano una función que haga el logaritmo?

[Profesor_Falken]

Código C:

int pow(int base, int exp)
{
    int result = 1;
    while (exp)
    {
        if (exp & 1)
            result *= base;
        exp >>= 1;
        base *= base;
    }
 
    return result;
}
 

Un saludo

[ecfisa]

Hola.

Mas opciones.

Iterativo:

Código C++:

int pow(int b, int e)
{
  int r = 1;
  for(; e; e--) r *= b;
  return r;
}
 

Recursivo:

Código C++:

int pow(int b, int e)
{
  if (e == 0) return 1;
  return b * pow(b, e-1);
}
 

Saludos.

[eferion]

Vuestras soluciones tienen TODAS bucles... volviendo al tema... puedes optar por la nada elegante solución de usar goto... técnicamente no es un bucle, por lo que debería funcionar:

Código C:

int main( )
{
  int numero = 2;
  int potencia = 5;
  int resultado = numero;
 
  salto:
  if ( potencia > 1 )
  {
    resultado *= numero;
    potencia--;
    goto salto;
  }
 
  printf("Resultado: %d\n", resultado );
}
 

Otra opción... válida únicamente en C++ sería usar templates... esta última solución solo te vale si los valores de la base y el exponente están predefinidos en el código:

Código C++:

template <int BASE, int POTENCIA>
struct Potencia
{
    enum { value = BASE * Potencia<BASE, POTENCIA- 1>::value };
};
 
template <int BASE>
struct Potencia<BASE, 1>
{
    enum { value = BASE};
};
 
template <int BASE>
struct Potencia<BASE, 0>
{
    enum { value = 1};
};
 
int main( )
{
  std::cout << Potencia<2, 5>::value;
}
 

[Profesor_Falken]

No habia visto lo de bucles.

Pues si es sin bucles ni funciones... a mi me parece mas una broma que un ejercicio.

Usar goto es usar un bucle. Los bucles c se traducen a instrucciones goto (goto, jmp, jump, etc) de assembler.
http://assembly.ynh.io/

Un saludo

[eferion]

Iniciado por Profesor_Falken

No habia visto lo de bucles.
Pues si es sin bucles ni funciones... a mi me parece mas una broma que un ejercicio.

Yo he pensado lo mismo.

Iniciado por Profesor_Falken

Usar goto es usar un bucle. Los bucles c se traducen a instrucciones goto (goto, jmp, jump, etc) de assembler.

Lo se, pero un goto a secas no es un bucle, técnicamente es un salto... hacia atrás pero un salto.... el siguiente código dudo mucho que se pudiese interpretar como una sucesión de bucles:

Código C++:

int main( )
{
  goto a;
  f: std::cout << "M"; goto g;
  g: std::cout << "U"; goto h;
  a: std::cout << "H"; goto b;
  h: std::cout << "N"; goto i;
  d: std::cout << "A"; goto e;
  i: std::cout << "D"; goto j;
  e: std::cout << " "; goto f;
  c: std::cout << "L"; goto d;
  j: std::cout << "O"; goto k;
  b: std::cout << "O"; goto c;
  k: std::cout << std::endl; return 0;
}
 

[vangodp]

...es que por poco no dice que hay que programar sin usar lenguaje de programación >_<. Justo pensé en el goto pero vaya a causar una tormenta de malas practicas jaja.

[eferion]

Iniciado por vangodp

...es que por poco no dice que hay que programar sin usar lenguaje de programación >_<. Justo pensé en el goto pero vaya a causar una tormenta de malas practicas jaja.

Muy cierto... el goto, salvo para determinadas optimizaciones en entornos críticos no creo que sea necesario su uso...
* ¿Es una palabra reservada del lenguaje? cierto
* ¿Se puede usar si a uno le apetece? cierto
* ¿Es necesario su uso? en absoluto
* ¿Es recomendable su uso? en absoluto

[leosansan]

Y a mi que me da que lo que realmente busca es calcular las potencias de 2 y en ese caso podemos usar desplazamientos:

Código C++:

std::cout << ( 2 << 4 ) << std::endl ;
 

Si no es eso me suena a pitorreo .

¡¡¡Saluditos!!!

[vangodp]

Iniciado por leosansan

Y a mi que me da que lo que realmente busca es calcular las potencias de 2 y en ese caso podemos usar desplazamientos:

Código C++:

std::cout << ( 2 << 4 ) << std::endl ;
 

Si no es eso me suena a pitorreo .

¡¡¡Saluditos!!!

Eso que es? 2elevado a 4?

* ¿Es una palabra reservada del lenguaje? cierto
* ¿Se puede usar si a uno le apetece? cierto
* ¿Es necesario su uso? en absoluto
* ¿Es recomendable su uso? en absoluto

No se donde leí una vez que ciertas cosas solo existen por retro compatibilidad con programas antiguos, y que no se aconseja usar mas. Aun que como bien dices ahí siguen y se pueden usar. XDD

[eferion]

Iniciado por leosansan

Si no es eso me suena a pitorreo .

¿No te gustó mi forma de calcularlo por templates?

[leosansan]

Iniciado por eferion

¿No te gustó mi forma de calcularlo por templates?

No sé por qué será pero me suena a función recursiva, bien disfrazada por cierto .

Un fuerte saludo eferion.

¡¡¡Saluditos!!!

[eferion]

Iniciado por leosansan

No sé por qué será pero me suena a función recursiva, bien disfrazada por cierto .

Ese template no es recursivo... el valor de la potencia en ese template lo calcula directamente el compilador, en tiempo de ejecución no hay que calcular nada... la ventaja es que el tiempo de ejecución en este caso es nula y la desventaja es que los valores tienen que estar definidos en el código.

Un saludo para tí también leosansan

[Profesor_Falken]

Iniciado por eferion

Ese template no es recursivo... el valor de la potencia en ese template lo calcula directamente el compilador, en tiempo de ejecución no hay que calcular nada... la ventaja es que el tiempo de ejecución en este caso es nula y la desventaja es que los valores tienen que estar definidos en el código.

Si la "trampa" se calcula en tiempo de compilación... ¿es válido?. Entonces aquí va mi supermacro C

Código C:

#include <stdio.h>
#include <math.h>
 
#define POW(B, E) pow(B, E)
 
int main() {
    printf("%d", (int)POW(2 ,5));
    
    return 0;
}
 

EDITO: ay no, me equivoqué!, la macro se expande y se ejecuta la función en runtime! Que tontaina soy...


Un saludo a todos

[leosansan]

Buen intento pero no se puede usar pow .......

¡¡¡Saluditos!!!

[eferion]

Iniciado por Profesor_Falken

Si la "trampa" se calcula en tiempo de compilación... ¿es válido?. Entonces aquí va mi supermacro C

Venga va, otra posibilidad...

Código C:

int main( )
{
  int base = 5;
  int potencia = 2;
  
  printf( "%d^%d=%c%c\n", base, potencia, potencia+'0', base+'0' );
}
 

... eso sí, creo que no sirve para calcular cualquier potencia...

[leosansan]

Iniciado por eferion

Venga va, otra posibilidad...

... eso sí, creo que no sirve para calcular cualquier potencia...

Pues no, para cualquier potencia no. Por ejemplo:

Código C++:

int base = 5;
int potencia = 3;
 

Se está "quedando" con nosotros .

¡¡¡Saluditos!!!

[eferion]

Iniciado por leosansan

Pues no, para cualquier potencia no.

... es que no me daba tiempo a probar todas las combinaciones jejejejeje

[Lifka]

Muchas gracias chicos! Con todo lo que habéis propuesto ya he logrado solucionarlo.
A los que les ha parecido una broma... a mí casi que también, pero es lo que hay, se trataba de un problema de eficiencia. Muchas gracias de nuevo.

Saludos!