นี่เป็นความท้าทายที่สั้นมาก ๆ

เขียนฟังก์ชั่นหรือขั้นตอนที่ใช้สองพารามิเตอร์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])

ไม่ได้ผลกับผู้ที่ไม่ได้เป็นเอกสิทธิ์

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

หลาม

ถ้า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);}

ทุบตี & 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;});}

ใช้นิพจน์ทั่วไปเพื่อสร้างอาร์เรย์ขนาด y + 1 ซึ่งองค์ประกอบแรกคือ 1 จากนั้นลดอาร์เรย์ด้วยการคูณเพื่อคำนวณพลังงาน เมื่อ y = 0 ผลลัพธ์จะเป็นองค์ประกอบแรกของอาร์เรย์ซึ่งก็คือ 1

เป็นที่ยอมรับเป้าหมายของฉันคือ i) ไม่ใช้การเรียกซ้ำ 2) ทำให้มันไม่ชัดเจน

มาติกา

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 5การป้อนข้อมูลที่คาดว่าเป็นตัวเลขสองเช่น "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

ในที่สุดนี้ก็เหมือนกับคำตอบก่อนหน้าหลายประการ: สร้างอาร์เรย์ความยาว y ทุกองค์ประกอบที่เป็น x จากนั้นนำผลิตภัณฑ์ มันทำให้งงงวยที่จะทำให้มันดูเหมือนว่ามันกำลังใช้ตัว**ดำเนินการต้องห้าม

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

รุ่นgolfed ใน46 ไบต์ (ขอบคุณ ugoren!)

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

ควรเร็วกว่าคำตอบแบบเรียกซ้ำอื่น ๆ ทั้งหมด oO

รุ่นที่ช้ากว่าเล็กน้อยใน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

แล้วมีรายการ 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:

{prd y#9h$x}

ตรรกะที่คล้ายกันเป็นจำนวนมากใน PHP:

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

รันด้วยphp file.php 5 3เพื่อรับ 5 ^ 3

ผมไม่แน่ใจว่าวิธีการหลาย upvotes ฉันสามารถคาดหวังนี้ แต่ผมพบว่ามันค่อนข้างแปลกที่ฉันจริงมีการเขียนฟังก์ชั่นที่มากในวันนี้ และฉันค่อนข้างแน่ใจว่านี่เป็นครั้งแรกที่ไซต์. SE เห็นภาษานี้ (เว็บไซต์ดูเหมือนจะไม่เป็นประโยชน์สำหรับ atm)

เอบีเอส

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 ไบต์

เหมือนกับคำตอบ APL marinus'

สำหรับx^y:

*/@$~

สำหรับy^x:

*/@$

ตัวอย่างเช่น:

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

x $~ yสร้างรายการเวลาxซ้ำy(เช่นเดียวกับy $ x

*/ xเป็นฟังก์ชั่นผลิตภัณฑ์*/ 1 2 3->1 * 2 * 3

หลาม

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)

จาวาสคริ

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.