これは本当にすてきな短い挑戦です。

関数又は2つのパラメータを取り、手順書き込みxとyの結果を返すループを使用せずに、または電力機能に内蔵されています。xy

勝者は最も創造的なソリューションであり、3日後の最高票数に基づいて選択されます。

APL（7）

{×/⍵/⍺}

左の引数は底、右の引数は指数です。例：

     5 {×/⍵/⍺} 6
15625

説明：

• ⍵/⍺⍺ ⍵時間を複製します、例えば5 {⍵/⍺} 6->5 5 5 5 5 5
• ×/製品を取得します。例×/5 5 5 5 5 5-> 5×5×5×5×5×5->15625

C＃：浮動小数点指数

OK、このソリューションは非常に脆弱です。6のような途方もなく大きな数字を投げることで簡単に破ることができます。しかしDoublePower(1.5, 3.4)、それはのようなもののために美しく機能し、再帰を使用しません！

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

テンプレートメタプログラミングはどうですか？それは小さな規則があったものを曲げますが、一撃の価値があります：

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

Python

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

非整数の力に対しては機能しません。

Haskell-25文字

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

MarinusのAPLバージョンに続いて：

f x y = product $ take y $ repeat x

mniipのコメントと空白が削除された27文字：

f x y=product$replicate y x

Python

If yが正の整数

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)

使用法：

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

説明：

上記の関数は、x y時間を掛けて評価する式を作成します。

Y Combinatorで解決策を書いた人が誰もいなかったことに驚きました。

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

ループなし、ベクター/リスト操作なし、（明示的な）再帰なし！

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

C＃：45

整数のみで動作します：

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

bash＆sed

数字もループもありません。恥ずかしいほど危険なグロブ乱用です。安全のために空のディレクトリで実行することをお勧めします。シェルスクリプト：

#!/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;});}

正規表現を使用して、最初の要素が1であるサイズy + 1の配列を作成します。次に、乗算で配列を縮小し、電力を計算します。y = 0の場合、結果は配列の最初の要素、つまり1です。

確かに、私の目標はi）再帰を使用しないこと、ii）再帰を曖昧にすることでした。

Mathematica

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

おそらくx ^（1 / y）=y√xという事実を使用するために不正行為を行う

JavaScript

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

Golfscript、8文字（I / Oを含む）

~])*{*}*

説明：

TLDR：別の「繰り返し配列の製品」ソリューション。

予想される入力は、2つの数値2 5です。スタックは1つのアイテム、文字列で始まります"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

ルビー

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

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

使用例：

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

これは、最終的には以前のいくつかの回答と同じです。すべての要素がxであるy長の配列を作成し、製品を取得します。禁じられた**演算子を使用しているように見えるようにするために、不便に難読化されています。

C、2乗によるべき乗

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

46バイトのゴルフバージョン（ugorenに感謝！）

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

これまでの他のすべての再帰的回答よりも高速でなければなりませんo

45バイトのわずかに遅いバージョン

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

ハスケル-55

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

短いHaskellエントリはすでにありfixますが、で定義されてData.Functionいるように、関数を利用するエントリを作成することは興味深いと思いました。次のように使用します（簡単にするためにReplで）。

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文字。のyインスタンスを持つ配列を生成しx、製品を取得します。

{prd y#x}

int / long xを指定すると、明示的に大きな範囲のfloatにキャストできます。

{prd y#9h$x}

他の多くのPHPと同様のロジック：

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

で実行してphp file.php 5 35 ^ 3を取得します

これにどれだけの賛成票を投じることができるかはわかりませんが、今日その機能を実際に記述しなければならなかったというのはやや奇妙です。そして.SEサイトがこの言語を見るのはこれが初めてだと確信しています（Webサイトはあまり役に立ちません）。

ABS

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

負の指数および有理数の基底に対して機能します。

Java構文で強調表示したのは、この言語で作業しているときにそれが現在行っていることだからです。よさそうだ。

パスカル

チャレンジでは、xとyのタイプまたは範囲が指定されていなかったため、次のPascal関数はすべての所定の規則に従うと考えられます。

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

ループ、組み込みの累乗または累乗関数、再帰や算術すらありません！

J-5または4バイト

marinusのAPL answerとまったく同じです。

のためにx^y：

*/@$~

のためにy^x：

*/@$

例えば：

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

x $~ yx繰り返しy回数のリストを作成します（と同じy $ x

*/ x製品の関数です*/ 1 2 3->1 * 2 * 3

Python

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

末尾再帰でyは、正の整数の場合に機能します

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

バッシュ

誰bashもが奇抜なマップリデュースタイプの作業を行えることを知っています;-)

#!/bin/bash

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

それがあなたにとってあまりにもトロリーなら、これがあります：

#!/bin/bash

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

C

Cの2乗解答によるさらに別の再帰的累乗ですが、それらは異なります（これは除算の代わりにシフトを使用し、わずかに短く、もう1回再帰します）。

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

Mathematica

これは整数に対して機能します。

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

例

f[5,3]

125

使い方

Tableのリストを作成しますy x。 Timesそれらすべての積を取ります。

同じ目的を達成する別の方法：

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

例

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

125

Windowsバッチ

ここでの他のほとんどの回答と同様に、再帰を使用します。

@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は環境変数に保存されますz。

perl

これが末尾再帰perlエントリです。使用法はecho $ X、$ Y |です foo.pl：

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

または、より機能的なタイプのアプローチの場合は、次の方法について：

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

Python

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

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

answer =125

これが要件に反するかどうかはわかりませんが、そうでない場合は私の試みです。