Đây là một thử thách ngắn thực sự gọn gàng.

Viết một hàm hoặc một thủ tục mà phải mất hai tham số, xvà yvà trả kết quả của KHÔNG sử dụng các vòng lặp, hoặc xây dựng trong các chức năng điện.xy

Người chiến thắng là giải pháp sáng tạo nhất và sẽ được chọn dựa trên số phiếu bầu cao nhất sau 3 ngày.

APL (7)

{×/⍵/⍺}

Đối số bên trái là cơ sở, đối số bên phải là số mũ, ví dụ:

     5 {×/⍵/⍺} 6
15625

Giải trình:

• ⍵/⍺nhân rộng ⍺ ⍵thời gian, ví dụ 5 {⍵/⍺} 6->5 5 5 5 5 5
• ×/lấy sản phẩm, ví dụ ×/5 5 5 5 5 5-> 5×5×5×5×5×5->15625

C #: Số mũ điểm nổi

OK, giải pháp này khá dễ vỡ. Bạn có thể dễ dàng phá vỡ nó bằng cách ném những con số khổng lồ như 6 vào nó. Nhưng nó hoạt động rất tốt cho những thứ như DoublePower(1.5, 3.4), và không sử dụng đệ quy!

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

Làm thế nào về một số lập trình meta mẫu? Nó bẻ cong những quy tắc nhỏ đã có, nhưng nó đáng để thử:

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

Con trăn

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

Không làm việc cho các quyền lực noninteger.

Haskell - 25 ký tự

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

Theo phiên bản APL của Marinus:

f x y = product $ take y $ repeat x

Với nhận xét và khoảng trắng của mniip đã bị xóa, 27 ký tự:

f x y=product$replicate y x

Con trăn

Nếu ylà số nguyên dương

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)

Sử dụng:

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

Giải trình:

Hàm trên xây dựng một biểu thức nhân số x ylần sau đó đánh giá nó.

Tôi ngạc nhiên khi thấy rằng không ai viết một giải pháp với Bộ kết hợp Y, tuy nhiên ... do đó:

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

Không có vòng lặp, Không có hoạt động véc tơ / danh sách và Không đệ quy (rõ ràng)!

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

C #: 45

Chỉ hoạt động cho số nguyên:

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

bash & sed

Không có số, không có vòng lặp, chỉ là một sự lạm dụng toàn cầu nguy hiểm. Tốt nhất là chạy trong một thư mục trống để được an toàn. Kịch bản 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;});}

Sử dụng các biểu thức chính quy để tạo ra một mảng có kích thước y + 1 có phần tử đầu tiên là 1. Sau đó, giảm mảng với phép nhân để tính công suất. Khi y = 0, kết quả là phần tử đầu tiên của mảng, là 1.

Phải thừa nhận rằng, mục tiêu của tôi là i) không sử dụng đệ quy, ii) làm cho nó tối nghĩa.

Toán học

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

Có lẽ gian lận để sử dụng thực tế là x ^ (1 / y) = y√x

JavaScript

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

Golfscript, 8 ký tự (bao gồm cả I / O)

~])*{*}*

Giải trình:

TLDR: một giải pháp "sản phẩm của mảng lặp lại" khác.

Đầu vào dự kiến ​​là hai số, ví dụ 2 5. Ngăn xếp bắt đầu với một mục, chuỗi "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

Hồng ngọc

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

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

Sử dụng mẫu:

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

Điều này cuối cùng cũng giống như một số câu trả lời trước: tạo một mảng có độ dài y mỗi phần tử trong đó là x, sau đó lấy sản phẩm. Nó chỉ bị che khuất một cách vô cớ để làm cho nó trông giống như nó đang sử dụng **toán tử bị cấm .

C, lũy thừa bằng bình phương

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

phiên bản golf trong 46 byte (cảm ơn ugoren!)

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

nên nhanh hơn tất cả các câu trả lời đệ quy khác cho đến nay oO

phiên bản chậm hơn một chút trong 45 byte

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

Đã có một mục Haskell ngắn hơn, nhưng tôi nghĩ sẽ rất thú vị khi viết một mục tận dụng fixchức năng, như được định nghĩa trong Data.Function. Được sử dụng như sau (trong phần Thay thế để dễ sử dụng):

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 ký tự. Tạo mảng với các ythể hiện xvà lấy sản phẩm.

{prd y#x}

Có thể truyền rõ ràng để nổi cho phạm vi lớn hơn cho int / long x:

{prd y#9h$x}

Logic tương tự như nhiều người khác, trong PHP:

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

Chạy với php file.php 5 3để nhận 5 ^ 3

Tôi không chắc có bao nhiêu upvote tôi có thể mong đợi cho điều này, nhưng tôi thấy nó hơi kỳ lạ khi tôi thực sự phải viết chính chức năng đó ngày hôm nay. Và tôi khá chắc chắn rằng đây là lần đầu tiên bất kỳ trang web .SE nào nhìn thấy ngôn ngữ này (trang web có vẻ không hữu ích lắm).

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

Làm việc cho số mũ âm và cơ sở hợp lý.

Tôi đã đánh dấu nó bằng cú pháp Java, vì đó là những gì tôi đang làm khi tôi làm việc với ngôn ngữ này. Có vẻ ổn.

Pascal

Thử thách không chỉ định loại hoặc phạm vi của x và y, do đó tôi cho rằng hàm Pascal sau tuân theo tất cả các quy tắc đã cho:

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

Không có vòng lặp, không có hàm tích hợp hoặc hàm lũy thừa, thậm chí không có đệ quy hoặc số học!

J - 5 hoặc 4 byte

Chính xác giống như câu trả lời APL của bến du thuyền .

Dành cho x^y:

*/@$~

Dành cho y^x:

*/@$

Ví dụ:

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

x $~ ytạo một danh sách các xlần lặp lại y(giống nhưy $ x

*/ xlà chức năng của sản phẩm, */ 1 2 3->1 * 2 * 3

Con tră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

Với đệ quy đuôi, hoạt động nếu ylà một số nguyên dương

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

Bash

Mọi người đều biết bashcó thể thực hiện các công cụ giảm bản đồ điên cuồng ;-)

#!/bin/bash

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

Nếu đó là quá trolly cho bạn thì có điều này:

#!/bin/bash

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

C

Tuy nhiên, một phép lũy thừa đệ quy khác bằng câu trả lời bình phương trong C, nhưng chúng khác nhau (điều này sử dụng một sự thay đổi thay vì chia, ngắn hơn một chút và đệ quy nhiều lần hơn lần khác):

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

Toán học

Điều này làm việc cho số nguyên.

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

Thí dụ

f[5,3]

125

Làm thế nào nó hoạt động

Tabletạo ra một danh sách các y x's. Timeslấy sản phẩm của tất cả chúng.

Một cách khác để đạt được cùng một kết thúc :

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

Thí dụ

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

125

Batch Windows

Giống như hầu hết các câu trả lời khác ở đây, nó sử dụng đệ quy.

@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 được lưu trữ trong biến môi trường z.

perl

Đây là một mục nhập đệ quy perl. Cách sử dụng là echo $ X, $ Y | foo.pl:

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

Hoặc đối với cách tiếp cận kiểu chức năng hơn, làm thế nào về:

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

Con trăn

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

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

answer =125

Tôi không chắc chắn nếu điều này là trái với yêu cầu, nhưng nếu không ở đây là nỗ lực của tôi.