Este é um desafio curto realmente interessante.

Adicione uma função ou um procedimento que tem dois parâmetros, xe ye devolve o resultado de SEM utilizando laços, ou construído em funções de energia.xy

O vencedor é a solução mais criativa e será escolhido com base no maior número de votos após 3 dias.

APL (7)

{×/⍵/⍺}

O argumento esquerdo é base, o argumento direito é expoente, por exemplo:

     5 {×/⍵/⍺} 6
15625

Explicação:

• ⍵/⍺replica ⍺ ⍵vezes, por exemplo 5 {⍵/⍺} 6- ->5 5 5 5 5 5
• ×/leva o produto, por exemplo ×/5 5 5 5 5 5- -> 5×5×5×5×5×5->15625

C #: Expoentes de ponto flutuante

OK, esta solução é bastante frágil. Você pode facilmente quebrá-lo jogando números ridiculamente enormes como 6 nele. Mas funciona lindamente para coisas como DoublePower(1.5, 3.4)e não usa recursão!

    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 ++

Que tal alguma meta-programação de modelos? Dobra as pequenas regras que existiam, mas vale a pena tentar:

#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ão

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

Não funciona para poderes não-íntegros.

Haskell - 25 caracteres

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

Após a versão APL de Marinus:

f x y = product $ take y $ repeat x

Com o comentário e o espaço em branco do mniip removidos, 27 caracteres:

f x y=product$replicate y x

Pitão

Se yé um número inteiro 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

Explicação:

A função acima cria uma expressão que multiplica x yvezes e depois a avalia.

Estou surpreso ao ver que ninguém escreveu uma solução com o Y Combinator, ainda ... assim:

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)))

Sem loops, sem operações de vetor / lista e sem recursão (explícita)!

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

C #: 45

Funciona apenas para números inteiros:

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

bash & sed

Sem números, sem loops, apenas um abuso globamente embaraçosamente perigoso. De preferência, execute em um diretório vazio para ser 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;});}

Usa expressões regulares para criar uma matriz de tamanho y + 1, cujo primeiro elemento é 1. Em seguida, reduza a matriz com multiplicação para calcular a energia. Quando y = 0, o resultado é o primeiro elemento da matriz, que é 1.

É certo que meu objetivo era: i) não usar recursão, ii) torná-lo obscuro.

Mathematica

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

Provavelmente trapaça para usar o fato de que x ^ (1 / y) = y√x

Javascript

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

Golfscript, 8 caracteres (incluindo E / S)

~])*{*}*

Explicação:

TLDR: outro "produto de matriz repetida" solução.

A entrada esperada é de dois números, por exemplo 2 5. A pilha começa com um item, a sequência "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

Rubi

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

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

Uso da amostra:

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

Em última análise, é o mesmo que várias respostas anteriores: cria uma matriz de comprimento y cujo elemento é x e leva o produto. É ofuscado gratuitamente para parecer que está usando o **operador proibido .

C, exponenciação por quadratura

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);
}

versão golfed em 46 bytes (obrigado ugoren!)

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

deve ser mais rápido do que todas as outras respostas recursivas até agora

versão ligeiramente mais lenta em 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

Já existe uma entrada de Haskell mais curto, mas eu pensei que seria interessante para escrever um que tira proveito da fixfunção, conforme definido no Data.Function. Utilizado da seguinte forma (no Repl, para facilitar):

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. Gera matriz com yinstâncias xe leva o produto.

{prd y#x}

Pode converter explicitamente para flutuar para um intervalo maior, dado int / long x:

{prd y#9h$x}

Lógica semelhante a muitas outras, em PHP:

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

Execute-o php file.php 5 3para obter 5 ^ 3

Não sei ao certo quantas votações posso esperar por isso, mas achei um tanto peculiar que eu realmente tivesse que escrever essa mesma função hoje. E tenho certeza de que é a primeira vez que um site .SE vê esse idioma (o site não parece ser muito útil).

abdômen

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);
    };

Trabalha para expoentes negativos e bases racionais.

Eu o destaquei na sintaxe Java, porque é o que estou fazendo atualmente quando estou trabalhando com essa linguagem. Parece bom.

Pascal

O desafio não especificou o tipo ou o intervalo de xey, portanto, acho que a seguinte função Pascal segue todas as regras fornecidas:

{ 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;

Sem loop, sem energia embutida ou função de exponenciação, nem mesmo recursão ou aritmética!

J - 5 ou 4 bytes

Exatamente o mesmo que a resposta do APL de marinus .

Para x^y:

*/@$~

Para y^x:

*/@$

Por exemplo:

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

x $~ ycria uma lista de tempos xrepetidos y(o mesmo quey $ x

*/ xé a função do produto, */ 1 2 3->1 * 2 * 3

Pitão

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

Com recursão de cauda, ​​funciona se yfor um número inteiro positivo

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

Bater

Todo mundo sabe que bashpode fazer coisas do tipo redutor de mapa;

#!/bin/bash

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

Se isso é demais para você, existe o seguinte:

#!/bin/bash

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

C

Ainda outra exponenciação recursiva ao quadrado da resposta em C, mas elas diferem (isso usa uma mudança em vez de divisão, é um pouco mais curta e se repete mais uma vez que a outra):

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

Mathematica

Isso funciona para números inteiros.

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

Exemplo

f[5,3]

125

Como funciona

Tablefaz uma lista de y x's. Timesleva o produto de todos eles.

Outra maneira de alcançar o mesmo fim :

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

Exemplo

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

125

Lote do Windows

Como a maioria das outras respostas aqui, ele usa recursão.

@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 é armazenado na variável de ambiente z.

perl

Aqui está uma entrada perl recursiva de cauda. O uso é eco $ X, $ Y | foo.pl:

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

Ou, para uma abordagem mais funcional, que tal:

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

Pitão

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

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

answer =125

Não tenho certeza se isso é contra os requisitos, mas se não, aqui está a minha tentativa.