이것은 정말 깔끔한 짧은 도전입니다.

함수 또는 두 개의 매개 변수, 프로 시저 작성 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 # : 부동 소수점 지수

이 솔루션은 매우 약합니다. 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;
}

파이썬

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

정수가 아닌 제곱에는 작동하지 않습니다.

하스켈-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

파이썬

경우 y양의 정수이다

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

자바 스크립트 (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 컴비 네이터로 솔루션을 작성하지 않았다는 사실에 놀랐습니다.

파이썬 2

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*

자바 스크립트

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) 그것을 모호하게 만드는 것이었다.

매스 매 티카

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

아마도 x ^ (1 / y) = y√x

자바 스크립트

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

골프 스크립트, 8 자 (I / O 포함)

~])*{*}*

설명:

TLDR : 또 다른 "반복 어레이 제품"솔루션.

예상되는 입력은 두 개의 숫자입니다 (예 :) 2 5. 스택은 하나의 항목 (string)으로 시작합니다 "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, 제곱에 의한 지수화

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 바이트의 골프 버전 (고마워!)

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

지금까지 다른 모든 재귀 응답보다 빠릅니다.

45 바이트 에서 약간 느린 버전

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

There's already a shorter Haskell entry, but I thought it would be interesting to write one that takes advantage of the fix function, as defined in Data.Function. Used as follows (in the Repl for the sake of ease):

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 chars. Generates array with y instances of x and takes the product.

{prd y#x}

Can explicitly cast to float for larger range given int/long x:

{prd y#9h$x}

Similar logic as many others, in PHP:

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

Run it with php file.php 5 3 to get 5^3

I'm not sure how many upvotes I can expect for this, but I found it somewhat peculiar that I actually had to write that very function today. And I'm pretty sure this is the first time any .SE site sees this language (website doesn't seem very helpful atm).

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

Works for negative exponents and rational bases.

I highlighted it in Java syntax, because that's what I'm currently doing when I'm working with this language. Looks alright.

Pascal

The challenge did not specify the type or range of x and y, therefore I figure the following Pascal function follows all the given rules:

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

No loop, no built-in power or exponentiation function, not even recursion or arithmetics!

J - 5 or 4 bytes

Exactly the same as marinus' APL answer.

For x^y:

*/@$~

For y^x:

*/@$

For example:

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

x $~ y creates a list of x repeated y times (same as y $ x

*/ x is the product function, */ 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

With tail recursion, works if y is a positive integer

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

Bash

Everyone knows bash can do whizzy map-reduce type stuff ;-)

#!/bin/bash

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

If thats too trolly for you then there's this:

#!/bin/bash

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

C

Yet another recursive exponentiation by squaring answer in C, but they do differ (this uses a shift instead of division, is slightly shorter and recurses one more time than the other):

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

Mathematica

This works for integers.

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

Example

f[5,3]

125

How it works

Table makes a list of y x's. Times takes the product of all of them.`

Another way to achieve the same end:

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

Example

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

125

Windows Batch

Like most of the other answers here, it uses recursion.

@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 is stored in the environment variable z.

perl

Here's a tail recursive perl entry. Usage is echo $X,$Y | foo.pl:

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

Or for a more functional-type approach, how about:

($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

I am not sure if this is against the requirements, but if not here is my attempt.