Questa è una sfida davvero semplice.

Scrivere una funzione o di una procedura che prende due parametri, xed ye restituisce il risultato della SENZA usando loop, o costruito in funzioni di potenza.xy

Il vincitore è la soluzione più creativa e verrà scelto in base al maggior numero di voti dopo 3 giorni.

APL (7)

{×/⍵/⍺}

L'argomento di sinistra è base, l'argomento di destra è esponente, ad esempio:

     5 {×/⍵/⍺} 6
15625

Spiegazione:

• ⍵/⍺replica i ⍺ ⍵tempi, ad es. 5 {⍵/⍺} 6->5 5 5 5 5 5
• ×/prende il prodotto, ad es. ×/5 5 5 5 5 5-> 5×5×5×5×5×5->15625

C #: esponenti in virgola mobile

OK, questa soluzione è piuttosto fragile. Puoi facilmente romperlo lanciando numeri ridicolmente enormi come 6. Ma funziona magnificamente per cose del genere DoublePower(1.5, 3.4)e non usa la ricorsione!

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

Che ne dici di qualche meta programmazione dei template? Piega quali piccole regole c'erano, ma vale la pena provare:

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

Pitone

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

Non funziona per poteri non integri.

Haskell - 25 caratteri

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

A seguito della versione APL di Marinus:

f x y = product $ take y $ repeat x

Con il commento di mniip e lo spazio vuoto rimosso, 27 caratteri:

f x y=product$replicate y x

Pitone

Se yè un numero intero positivo

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)

Uso:

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

Spiegazione:

La funzione sopra crea un'espressione che si moltiplica x yvolte quindi la valuta.

Sono sorpreso di vedere che nessuno ha scritto una soluzione con il Combinatore Y, eppure ... quindi:

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

Nessun loop, nessuna operazione vettoriale / elenco e nessuna ricorsione (esplicita)!

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

C #: 45

Funziona solo per numeri interi:

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

bash & sed

Nessun numero, nessun loop, solo un abuso globalmente imbarazzante. Preferibilmente eseguito in una directory vuota per sicurezza. Script di 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;});}

Utilizza espressioni regolari per creare un array di dimensioni y + 1 il cui primo elemento è 1. Quindi, ridurre l'array con la moltiplicazione per calcolare la potenza. Quando y = 0, il risultato è il primo elemento dell'array, che è 1.

Certo, il mio obiettivo era: non usare la ricorsione, ii) renderlo oscuro.

matematica

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

Probabilmente barare per usare il fatto che x ^ (1 / y) = y√x

JavaScript

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

Golfscript, 8 caratteri (incluso I / O)

~])*{*}*

Spiegazione:

TLDR: un'altra soluzione "prodotto di array ripetuti".

L'input previsto è di due numeri, ad es 2 5. Lo stack inizia con un oggetto, la stringa "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

Rubino

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

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

Esempio di utilizzo:

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

Questo alla fine è lo stesso di diverse risposte precedenti: crea un array di lunghezza y ogni elemento di cui è x, quindi accetta il prodotto. È solo offuscato gratuitamente per far sembrare che stia usando l' **operatore proibito .

C, esponenziazione per quadratura

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

versione da golf in golfizzata 46 byte (grazie ugoren!)

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

dovrebbe essere più veloce di tutte le altre risposte ricorsive finora oO

versione leggermente più lenta in 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'è già una voce di Haskell più corta, ma ho pensato che sarebbe interessante scriverne una che sfrutti la fixfunzione, come definito in Data.Function. Usato come segue (nel Repl per motivi di facilità):

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 caratteri. Genera array con yistanze di xe accetta il prodotto.

{prd y#x}

Può esplicitamente eseguire il cast in float per un intervallo più ampio dato int / long x:

{prd y#9h$x}

Logica simile a molte altre, in PHP:

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

Eseguilo con php file.php 5 3per ottenere 5 ^ 3

Non sono sicuro di quanti voti posso aspettarmi per questo, ma ho trovato in qualche modo strano che in realtà dovevo scrivere quella stessa funzione oggi. E ne sono abbastanza sicuro questa è la prima volta che un sito .SE vede questa lingua (il sito web non sembra molto utile).

addominali

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

Funziona con esponenti negativi e basi razionali.

L'ho evidenziato nella sintassi Java, perché è quello che sto facendo attualmente quando lavoro con questa lingua. Va bene

Pascal

La sfida non ha specificato il tipo o l'intervallo di xey, quindi immagino che la seguente funzione Pascal segua tutte le regole date:

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

Nessun loop, nessuna potenza incorporata o funzione di esponenziazione, nemmeno ricorsione o aritmetica!

J - 5 o 4 byte

Esattamente come la risposta APL di Marinus .

Per x^y:

*/@$~

Per y^x:

*/@$

Per esempio:

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

x $~ ycrea un elenco di tempi xripetuti y(uguale ay $ x

*/ xè la funzione del prodotto, */ 1 2 3->1 * 2 * 3

Pitone

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

Con la ricorsione della coda, funziona se yè un numero intero positivo

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

bash

Tutti sanno che bashpossono fare robe di tipo riduci le mappe ;-)

#!/bin/bash

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

Se questo è troppo vero per te, allora c'è questo:

#!/bin/bash

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

C

Ancora un altro esponenziale ricorsivo quadrando la risposta in C, ma differiscono (questo usa uno spostamento invece della divisione, è leggermente più corto e si ricorre una volta più dell'altra):

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

matematica

Questo funziona per numeri interi.

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

Esempio

f[5,3]

125

Come funziona

Tablefa un elenco di y x. Timesprende il prodotto di tutti loro

Un altro modo per raggiungere lo stesso fine :

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

Esempio

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

125

Windows Batch

Come la maggior parte delle altre risposte qui, utilizza la ricorsione.

@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 è memorizzato nella variabile d'ambiente z.

perl

Ecco una voce perl ricorsiva di coda. L'utilizzo è eco $ X, $ Y | foo.pl:

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

O per un approccio di tipo più funzionale, che ne dici di:

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

Pitone

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

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

answer =125

Non sono sicuro se questo è contro i requisiti, ma se non qui è il mio tentativo.