Este es un desafío corto realmente bueno.

Escribir una función o un procedimiento que toma dos parámetros, xy yy devuelve el resultado del SIN mediante bucles, o construido en funciones de potencia.xy

El ganador es la solución más creativa y se elegirá en función del mayor número de votos después de 3 días.

APL (7)

{×/⍵/⍺}

El argumento izquierdo es base, el argumento derecho es exponente, por ejemplo:

     5 {×/⍵/⍺} 6
15625

Explicación:

• ⍵/⍺replica ⍺ ⍵tiempos, por ejemplo 5 {⍵/⍺} 6->5 5 5 5 5 5
• ×/toma el producto, por ejemplo ×/5 5 5 5 5 5-> 5×5×5×5×5×5->15625

C #: exponentes de coma flotante

OK, esta solución es bastante frágil. Puede romperlo fácilmente arrojando números ridículamente enormes como 6 a él. ¡Pero funciona maravillosamente para cosas como DoublePower(1.5, 3.4), y no utiliza la recursividad!

    static double IntPower(double x, int y)
    {
        return Enumerable.Repeat(x, y).Aggregate((product, next) => product * next);
    }

    static double Factorial(int x)
    {
        return Enumerable.Range(1, x).Aggregate<int, double>(1.0, (factorial, next) => factorial * next);
    }

    static double Exp(double x)
    {
        return Enumerable.Range(1, 100).
            Aggregate<int, double>(1.0, (sum, next) => sum + IntPower(x, next) / Factorial(next));
    }

    static double Log(double x)
    {
        if (x > -1.0 && x < 1.0)
        {
            return Enumerable.Range(1, 100).
                Aggregate<int, double>(0.0, (sum, next) =>
                    sum + ((next % 2 == 0 ? -1.0 : 1.0) / next * IntPower(x - 1.0, next)));
        }
        else
        {
            return Enumerable.Range(1, 100).
                Aggregate<int, double>(0.0, (sum, next) =>
                    sum + 1.0 / next * IntPower((x - 1) / x, next));
        }
    } 

    static double DoublePower(double x, double y)
    {
        return Exp(y * Log(x));
    } 

C ++

¿Qué tal alguna plantilla de meta programación? Dobla las pequeñas reglas que había, pero vale la pena intentarlo:

#include <iostream>


template <int pow>
class tmp_pow {
public:
    constexpr tmp_pow(float base) :
        value(base * tmp_pow<pow-1>(base).value)
    {
    }
    const float value;
};

template <>
class tmp_pow<0> {
public:
    constexpr tmp_pow(float base) :
        value(1)
    {
    }
    const float value;
};

int main(void)
{
    tmp_pow<5> power_thirst(2.0f);
    std::cout << power_thirst.value << std::endl;
    return 0;
}

Pitón

def power(x,y):
    return eval(((str(x)+"*")*y)[:-1])

No funciona para poderes no enteros.

Haskell - 25 caracteres

f _ 0=1
f x y=x*f x (y-1)

Después de la versión APL de Marinus:

f x y = product $ take y $ repeat x

Con el comentario de mniip y el espacio en blanco eliminado, 27 caracteres:

f x y=product$replicate y x

Pitón

Si yes un entero positivo

def P(x,y):
    return reduce(lambda a,b:a*b,[x]*y)

JavaScript (ES6), 31

// Testable in Firefox 28
f=(x,y)=>eval('x*'.repeat(y)+1)

Uso:

> f(2, 0)
1
> f(2, 16)
65536

Explicación:

La función anterior crea una expresión que se multiplica por x yveces y luego la evalúa.

Me sorprende ver que nadie escribió una solución con el Combinador Y, sin embargo ... así:

Python2

Y = lambda f: (lambda x: x(x))(lambda y: f(lambda v: y(y)(v)))
pow = Y(lambda r: lambda (n,c): 1 if not c else n*r((n, c-1)))

¡Sin bucles, sin operaciones de vector / lista y sin recursividad (explícita)!

>>> pow((2,0))
1
>>> pow((2,3))
8
>>> pow((3,3))
27

C #: 45

Funciona solo para enteros:

int P(int x,int y){return y==1?x:x*P(x,y-1);}

bash & sed

Sin números, sin bucles, solo un abuso vergonzosamente peligroso. Preferentemente ejecute en un directorio vacío para estar seguro. Script de shell:

#!/bin/bash
rm -f xxxxx*
eval touch $(printf xxxxx%$2s | sed "s/ /{1..$1}/g")
ls xxxxx* | wc -l
rm -f xxxxx*

Javascript

function f(x,y){return ("1"+Array(y+1)).match(/[\,1]/g).reduce(function(l,c){return l*x;});}

Utiliza expresiones regulares para crear una matriz de tamaño y + 1 cuyo primer elemento es 1. Luego, reduce la matriz con la multiplicación para calcular la potencia. Cuando y = 0, el resultado es el primer elemento de la matriz, que es 1.

Es cierto que mi objetivo era i) no usar la recursión, ii) hacerlo oscuro.

Mathematica

f[x_, y_] := Root[x, 1/y]

Probablemente haciendo trampa para usar el hecho de que x ^ (1 / y) = y√x

JavaScript

function f(x,y){return y--?x*f(x,y):1;}

Golfscript, 8 caracteres (incluidas E / S)

~])*{*}*

Explicación:

TLDR: otra solución de "producto de matriz repetida".

La entrada esperada es dos números, por ejemplo 2 5. La pila comienza con un elemento, la cadena "2 5".

Code     - Explanation                                             - stack
                                                                   - "2 5"
~        - pop "2 5" and eval into the integers 2 5                - 2 5        
]        - put all elements on stack into an array                 - [2 5]
)        - uncons from the right                                   - [2] 5
*        - repeat array                                            - [2 2 2 2 2]
{*}      - create a block that multiplies two elements             - [2 2 2 2 2] {*}
*        - fold the array using the block                          - 32

Rubí

class Symbol
  define_method(:**) {|x| eval x }
end

p(:****[$*[0]].*(:****$*[1]).*('*'))

Uso de la muestra:

$ ruby exp.rb 5 3
125
$ ruby exp.rb 0.5 3
0.125

En última instancia, esto es lo mismo que varias respuestas anteriores: crea una matriz de longitud y cada elemento cuyo x es, luego toma el producto. Se ofusca de forma gratuita para que parezca que está utilizando el **operador prohibido .

C, exponenciación por cuadratura

int power(int a, int b){
    if (b==0) return 1;
    if (b==1) return a;
    if (b%2==0) return power (a*a,b/2);
    return a*power(a*a,(b-1)/2);
}

versión de golf en 46 bytes (¡gracias ugoren!)

p(a,b){return b<2?b?a:1:p(a*a,b/2)*(b&1?a:1);}

debería ser más rápido que todas las otras respuestas recursivas hasta ahora

versión ligeramente más lenta en 45 bytes

p(a,b){return b<2?b?a:1:p(a*a,b/2)*p(a,b&1);}

Haskell - 55

pow x y=fix(\r a i->if i>=y then a else r(a*x)(i+1))1 0

Ya hay una entrada de Haskell más corta, pero pensé que sería interesante escribir una que aproveche la fixfunción, como se define en Data.Function. Usado de la siguiente manera (en la Repl en aras de la facilidad):

ghci> let pow x y=fix(\r a i->if i>=y then a else r(a*x)(i+1))1 0
ghci> pow 5 3
125

Q

9 caracteres Genera matriz con yinstancias dex y toma el producto.

{prd y#x}

Puede lanzar explícitamente a flotante para un rango mayor dado int / long x:

{prd y#9h$x}

Lógica similar a muchas otras, en PHP:

<?=array_product(array_fill(0,$argv[2],$argv[1]));

Ejecútalo con php file.php 5 3para obtener 5 ^ 3

No estoy seguro de cuántos votos positivos puedo esperar para esto, pero me pareció un tanto peculiar que en realidad tenía que escribir esa misma función hoy. Y estoy bastante seguro de que esta es la primera vez que un sitio .SE ve este idioma (el sitio web no parece ser muy útil).

abdominales

def Rat pow(Rat x, Int y) =
    if y < 0 then
        1 / pow(x, -y)
    else case y {
        0 => 1;
        _ => x * pow(x, y-1);
    };

Trabaja para exponentes negativos y bases racionales.

Lo destaqué en la sintaxis de Java, porque eso es lo que estoy haciendo actualmente cuando estoy trabajando con este lenguaje. Se ve bien

Pascal

El desafío no especificó el tipo o rango de x e y, por lo tanto, creo que la siguiente función Pascal sigue todas las reglas dadas:

{ data type for a single bit: can only be 0 or 1 }
type
  bit = 0..1;

{ calculate the power of two bits, using the convention that 0^0 = 1 }
function bitpower(bit x, bit y): bit;
  begin
    if y = 0
      then bitpower := 1
      else bitpower := x
  end;

¡Sin bucle, sin potencia incorporada o función de exponenciación, ni siquiera recursividad o aritmética!

J - 5 o 4 bytes

Exactamente igual que la respuesta APL de marinus .

Para x^y:

*/@$~

Para y^x:

*/@$

Por ejemplo:

   5 */@$~ 6
15625
   6 */@$ 5
15625

x $~ ycrea una lista de tiempos xrepetidos y(igual quey $ x

*/ xes la función del producto, */ 1 2 3->1 * 2 * 3

Pitón

from math import sqrt

def pow(x, y):
    if y == 0:
        return 1
    elif y >= 1:
        return x * pow(x, y - 1)
    elif y > 0:
        y *= 2
        if y >= 1:
            return sqrt(x) * sqrt(pow(x, y % 1))
        else:
            return sqrt(pow(x, y % 1))
    else:
        return 1.0 / pow(x, -y)

Javascript

Con recursión de cola, funciona si yes un entero positivo

function P(x,y,z){z=z||1;return y?P(x,y-1,x*z):z}

Golpetazo

Todo el mundo sabe que bashpuede hacer cosas geniales de reducción de mapas ;-)

#!/bin/bash

x=$1
reduce () {
    ((a*=$x))
}
a=1
mapfile -n$2 -c1 -Creduce < <(yes)
echo $a

Si eso es demasiado para ti, entonces hay esto:

#!/bin/bash

echo $(( $( yes $1 | head -n$2 | paste -s -d'*' ) ))

C

Otra exponenciación recursiva al cuadrar la respuesta en C, pero difieren (esto usa un cambio en lugar de división, es ligeramente más corto y se repite una vez más que la otra):

e(x,y){return y?(y&1?x:1)*e(x*x,y>>1):1;}

Mathematica

Esto funciona para enteros.

f[x_, y_] := Times@@Table[x, {y}]

Ejemplo

f[5,3]

125

Cómo funciona

Tablehace una lista de y x's. Timestoma el producto de todos ellos.`

Otra forma de lograr el mismo fin :

#~Product~{i,1,#2}&

Ejemplo

#~Product~{i, 1, #2} & @@ {5, 3}

125

Lote de Windows

Como la mayoría de las otras respuestas aquí, utiliza la recursividad.

@echo off
set y=%2
:p
if %y%==1 (
set z=%1
goto :eof
) else (
    set/a"y-=1"
    call :p %1
    set/a"z*=%1"
    goto :eof
)

x ^ y se almacena en la variable de entorno z.

perl

Aquí hay una entrada perl recursiva de cola. El uso es echo $ X, $ Y | foo.pl:

($x,$y) = split/,/, <>;
sub a{$_*=$x;--$y?a():$_}
$_=1;
print a

O para un enfoque de tipo más funcional, ¿qué tal:

($x,$y) = split/,/, <>;
$t=1; map { $t *= $x } (1..$y);
print $t

Pitón

def getRootOfY(x,y):
   return x**y 

def printAnswer():
   print "answer is ",getRootOfY(5,3)
printAnswer()

answer =125

No estoy seguro de si esto va en contra de los requisitos, pero si no, aquí está mi intento.