Bu gerçekten düzgün bir kısa meydan okuma.

Bir fonksiyonu ya da iki parametre alır, bir işlem yazınız xve yve sonucunu döndürür döngüler kullanarak OLMADAN, ya da güç fonksiyonları inşa.xy

Kazanan en yaratıcı çözümdür ve 3 gün sonra en yüksek oy sayısına göre seçilecektir.

APL (7)

{×/⍵/⍺}

Sol argüman temel, sağ argüman üstür, örneğin:

     5 {×/⍵/⍺} 6
15625

Açıklama:

• ⍵/⍺⍺ ⍵süreleri çoğaltır , örneğin 5 {⍵/⍺} 6->5 5 5 5 5 5
• ×/ürünü alır, örneğin ×/5 5 5 5 5 5-> 5×5×5×5×5×5->15625

C #: Kayan nokta üsleri

Tamam, bu çözüm oldukça kırılgandır. Ona 6 gibi gülünç büyük sayılar atarak kolayca kırabilirsiniz. Ancak bu gibi şeyler için güzel çalışır DoublePower(1.5, 3.4)ve özyineleme kullanmaz!

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

Bazı şablon meta programlarına ne dersiniz? Ne gibi küçük kurallar olduğunu büküyor, ama denemeye değer:

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

piton

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

Tamsayı olmayan güçler için çalışmaz.

Haskell - 25 karakter

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

Marinus'un APL sürümünü takip ederek:

f x y = product $ take y $ repeat x

Mniip'in yorumu ve boşluk kaldırıldığında 27 karakter:

f x y=product$replicate y x

piton

Eğer yolumlu bir tam sayıdır

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)

Kullanımı:

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

Açıklama:

Yukarıdaki işlev, x yçarpı ve ardından değerlendirilen bir ifade oluşturur .

Hiç kimsenin Y Combinator ile bir çözüm yazmadığını görmek beni şaşırttı ...

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

Döngü yok, vektör / liste işlemi yok ve (açık) özyineleme yok!

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

C #: 45

Yalnızca tamsayılar için çalışır:

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

bash ve sed

Sayı yok, döngü yok, sadece utanç verici derecede tehlikeli bir dünya istismarı. Güvenli olması için tercihen boş bir dizinde çalıştırın. Kabuk betiği:

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

İlk öğesi 1 olan y + 1 boyutunda bir dizi oluşturmak için normal ifadeler kullanır. Ardından, gücü hesaplamak için diziyi çarpma ile azaltın. Y = 0 olduğunda, sonuç dizinin 1 olan ilk öğesidir.

Kuşkusuz, amacım i) özyineleme kullanmak değil, ii) belirsiz yapmaktı.

Mathematica

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

Muhtemelen x ^ (1 / y) = y√x

JavaScript

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

Golfscript, 8 karakter (G / Ç dahil)

~])*{*}*

Açıklama:

TLDR: başka bir "tekrarlanan dizi ürünü" çözümü.

Beklenen girdi iki sayıdır, örn 2 5. Yığın bir öğe, dize ile başlar "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

Yakut

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

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

Örnek kullanım:

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

Bu sonuçta önceki birkaç cevapla aynıdır: her elemanı x olan bir y uzunluğu dizisi oluşturur, ardından ürünü alır. Yasak **operatörü kullanıyor gibi görünmesini sağlamak için sadece şaşkın bir şekilde şaşırttı .

C, kareleme ile üs alma

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 baytta golf edilmiş versiyon (teşekkürler ugoren!)

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

Şimdiye kadar diğer özyinelemeli cevaplardan daha hızlı olmalıdır

45 baytta biraz daha yavaş sürüm

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

Zaten daha kısa bir Haskell girişi var, ancak fixtanımlandığı gibi işlevden yararlanan bir tane yazmanın ilginç olacağını düşündüm Data.Function. Aşağıdaki gibi kullanılır (kolaylık için Repl'de):

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

S

9 karakter. yÖrnekleri ile dizi oluşturur xve ürünü alır.

{prd y#x}

İnt / long x verildiğinde daha geniş bir aralık için açıkça yüzer hale gelebilir:

{prd y#9h$x}

PHP ile aynı mantık:

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

php file.php 5 35 ^ 3 almak için ile çalıştırın

Bunu için bekleyebilirsiniz kaç upvotes emin değilim, ama biraz tuhaf bulundu aslında çok fonksiyonlu bugün yazma gerekiyordu. Ve ben eminim bu herhangi .se sitesi görür ilk kez bu dili (Web sitesi çok yararlı atm görünmüyor).

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

Negatif üsler ve rasyonel bazlar için çalışır.

Java sözdiziminde vurguladım, çünkü şu anda bu dille çalışırken yaptığım şey bu. İyi görünüyor.

paskal

Zorluk x ve y türünü veya aralığını belirtmedi, bu nedenle aşağıdaki Pascal işlevinin verilen tüm kuralları izlediğini anlıyorum:

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

Döngü yok, yerleşik güç veya üs alma işlevi yok, özyineleme veya aritmetik bile değil!

J - 5 veya 4 bayt

Marinus'un APL cevabı ile tamamen aynı .

Şunun için x^y:

*/@$~

Şunun için y^x:

*/@$

Örneğin:

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

x $~ yxtekrarlanan yzamanların bir listesini oluşturur (y $ x

*/ xürün işlevi, */ 1 2 3->1 * 2 * 3

piton

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

Kuyruk özyineleme ile, ypozitif bir tam sayı ise çalışır

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

darbe

Herkes bilir bashwhizzy harita azaltmak türü şeyler ;-)

#!/bin/bash

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

Sizin için çok sepetiniz varsa, o zaman bu var:

#!/bin/bash

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

C

Yine, C'deki cevabı kare yaparak başka bir özyinelemeli üs alma, ancak farklıdırlar (bu, bölünme yerine bir vardiya kullanır, biraz daha kısadır ve diğerinden bir kez daha geri çekilir):

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

Mathematica

Bu tamsayılar için geçerlidir.

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

Misal

f[5,3]

125

Nasıl çalışır

Tabley x'nin bir listesini yapar . Timeshepsinin ürününü alıyor.

Aynı sonuca ulaşmanın başka bir yolu :

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

Misal

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

125

Windows Toplu İş

Buradaki diğer cevapların çoğu gibi, özyineleme kullanır.

@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, ortam değişkeninde saklanır z.

perl

İşte bir kuyruk özyinelemeli perl girişi. Kullanım yankı $ X, $ Y | foo.pl:

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

Veya daha işlevsel bir yaklaşım için, aşağıdakilere ne dersiniz:

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

piton

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

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

answer =125

Bunun gerekliliklere aykırı olup olmadığından emin değilim, ama burada değilse benim girişimim.