Escriba una función que tome (x, y) y devuelva x a la potencia de y SIN bucles [cerrado]


14

Este es un desafío corto realmente bueno.

Escribir una función o un procedimiento que toma dos parámetros, xy yy devuelve el resultado del SIN mediante bucles, o construido en funciones de potencia.xy

El ganador es la solución más creativa y se elegirá en función del mayor número de votos después de 3 días.


1
¿Qué tipo de desafío es este?
VisioN

22
Qué tal si exp(log(x)*y) ?
r3mainer

2
¿Es aceptable una respuesta para enteros? Ya que estas son las primeras respuestas.
mmumboss

44
Parece que las respuestas hasta ahora usan recursividad o listas de 'x' repetidas. Me estoy rompiendo el cerebro tratando de pensar de otra manera (particularmente algo que permite un no entero).
BenM

1
Desafortunadamente, la prohibición de bucles descarta soluciones matemáticas divertidas como la expansión de Taylor.
shadowtalker

Respuestas:


27

APL (7)

{×/⍵/⍺}

El argumento izquierdo es base, el argumento derecho es exponente, por ejemplo:

     5 {×/⍵/⍺} 6
15625

Explicación:

  • ⍵/⍺replica tiempos, por ejemplo 5 {⍵/⍺} 6->5 5 5 5 5 5
  • ×/toma el producto, por ejemplo ×/5 5 5 5 5 5-> 5×5×5×5×5×5->15625

2
Hm .. Esto se puede escribir en 5 caracteres en J, exactamente el mismo método. */@$~
seequ

@Sieg 4 incluso, si permite el exponente a la izquierda, la base a la derecha.
Febıʇǝɥʇuʎs

Tenía el adverbio flip porque pensé que no estaba permitido.
seequ

@Seeq 4 en Dyalog APL :×/⍴⍨
Adám

27

C #: exponentes de coma flotante

OK, esta solución es bastante frágil. Puede romperlo fácilmente arrojando números ridículamente enormes como 6 a él. ¡Pero funciona maravillosamente para cosas como DoublePower(1.5, 3.4), y no utiliza la recursividad!

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

43
"números ridículamente enormes como 6" Disfruté eso.
DavidC

Seguramente el uso de funciones enumerables depende del bucle que estaba prohibido en la pregunta o ¿está bien porque el bucle está dentro de los métodos marco?
Chris

16

C ++

¿Qué tal alguna plantilla de meta programación? Dobla las pequeñas reglas que había, pero vale la pena intentarlo:

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

1
pero esto no es una función, es un valor de tiempo de compilación, ¿no? : O
PaperBirdMaster

Bueno, un constructor es una función, y los parámetros de la plantilla son casi como argumentos de función ... ¿verdad? =)
erlc

@PaperBirdMaster Sí ... es por eso que admití algunas reglas de flexión. Pensé que iba a enviar algo además de la recursión de cola, pero acabo de enviar la recursión de cola de tiempo de compilación, jaja. Aunque lo suficientemente cerca, ¿verdad?
astephens4

@ astephens4 lo suficientemente cerca, me encanta: 3
PaperBirdMaster

15

Pitón

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

No funciona para poderes no enteros.


Me gusta este.
CodyBugstein

1
¿Por qué agrega un separador sin usar join? eval('*'.join([str(x)] * y)).
Bakuriu

1
¿Era este código trolling?
Gerrit

También me gustaría señalar que python tiene el **operador, por lo que podría haber evaluado () d eso.
Riking

3
@Riking: eso sería algo incorporado, sin embargo.
Hovercouch

10

Haskell - 25 caracteres

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

Después de la versión APL de Marinus:

f x y = product $ take y $ repeat x

Con el comentario de mniip y el espacio en blanco eliminado, 27 caracteres:

f x y=product$replicate y x

usar en replicate y xlugar detake y $ repeat x
mniip

44
Estaba convencido de que podía guardar caracteres escribiendo su segunda función sin puntos. Resulta que f=(product.).flip replicatees exactamente el mismo número de caracteres.
Kaya

@mniip No importa, esto no es código golf.
nyuszika7h

10

Pitón

Si yes un entero positivo

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

7

JavaScript (ES6), 31

// Testable in Firefox 28
f=(x,y)=>eval('x*'.repeat(y)+1)

Uso:

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

Explicación:

La función anterior crea una expresión que se multiplica por x yveces y luego la evalúa.


6

Me sorprende ver que nadie escribió una solución con el Combinador Y, sin embargo ... así:

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

¡Sin bucles, sin operaciones de vector / lista y sin recursividad (explícita)!

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

Uh, acabo de ver en este momento la solución Haskell de KChaloux que usa fix, votando a él ...
berdario

5

C #: 45

Funciona solo para enteros:

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

return --y?x:x*P(x,y);
Entrégueme

1
Pero esto no es código-golf ...
Oberon

1
Los criterios ganadores de @oberon no estaban claros cuando esto se publicó. Las cosas han seguido adelante.
Level River St

@steveverrill Lo siento.
Oberon

También en C # --y sería un int que no es lo mismo que un bool como en otros lenguajes.
Chris

5

bash & sed

Sin números, sin bucles, solo un abuso vergonzosamente peligroso. Preferentemente ejecute en un directorio vacío para estar seguro. Script de shell:

#!/bin/bash
rm -f xxxxx*
eval touch $(printf xxxxx%$2s | sed "s/ /{1..$1}/g")
ls xxxxx* | wc -l
rm -f xxxxx*

"Preferiblemente, ejecutar en un directorio vacío para estar seguro". : D
Almo

5

Javascript

function f(x,y){return ("1"+Array(y+1)).match(/[\,1]/g).reduce(function(l,c){return l*x;});}

Utiliza expresiones regulares para crear una matriz de tamaño y + 1 cuyo primer elemento es 1. Luego, reduce la matriz con la multiplicación para calcular la potencia. Cuando y = 0, el resultado es el primer elemento de la matriz, que es 1.

Es cierto que mi objetivo era i) no usar la recursión, ii) hacerlo oscuro.


5

Mathematica

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

Probablemente haciendo trampa para usar el hecho de que x ^ (1 / y) = y√x


No hacer trampa. Inteligente.
Michael Stern

Esto es brillante. Ojalá lo hubiera pensado para mi publicación de R.
shadowtalker


4

Golfscript, 8 caracteres (incluidas E / S)

~])*{*}*

Explicación:

TLDR: otra solución de "producto de matriz repetida".

La entrada esperada es dos números, por ejemplo 2 5. La pila comienza con un elemento, la cadena "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

Golfscript es siempre el camino a seguir.
Nit

3

Rubí

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

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

Uso de la muestra:

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

En última instancia, esto es lo mismo que varias respuestas anteriores: crea una matriz de longitud y cada elemento cuyo x es, luego toma el producto. Se ofusca de forma gratuita para que parezca que está utilizando el **operador prohibido .


3

C, exponenciación por cuadratura

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

versión de golf en 46 bytes (¡gracias ugoren!)

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

debería ser más rápido que todas las otras respuestas recursivas hasta ahora

versión ligeramente más lenta en 45 bytes

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

1
Por extraña b, ~-b/2 == b/2.
Ugoren

@ugoren Oh, por supuesto, tienes razón
izabera

Esta es una pregunta de entrevista popular :) "¿Cómo puedes escribir pow(n, x)mejor que O (n)?"
Jordan Scales

3

Haskell - 55

pow x y=fix(\r a i->if i>=y then a else r(a*x)(i+1))1 0

Ya hay una entrada de Haskell más corta, pero pensé que sería interesante escribir una que aproveche la fixfunción, como se define en Data.Function. Usado de la siguiente manera (en la Repl en aras de la facilidad):

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

2

Q

9 caracteres Genera matriz con yinstancias dex y toma el producto.

{prd y#x}

Puede lanzar explícitamente a flotante para un rango mayor dado int / long x:

{prd y#9h$x}

1
Hacer coincidir Golfscript en longitud es una hazaña para lograr.
Nit

2

Lógica similar a muchas otras, en PHP:

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

Ejecútalo con php file.php 5 3para obtener 5 ^ 3


2

No estoy seguro de cuántos votos positivos puedo esperar para esto, pero me pareció un tanto peculiar que en realidad tenía que escribir esa misma función hoy. Y estoy bastante seguro de que esta es la primera vez que un sitio .SE ve este idioma (el sitio web no parece ser muy útil).

abdominales

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

Trabaja para exponentes negativos y bases racionales.

Lo destaqué en la sintaxis de Java, porque eso es lo que estoy haciendo actualmente cuando estoy trabajando con este lenguaje. Se ve bien


2

Pascal

El desafío no especificó el tipo o rango de x e y, por lo tanto, creo que la siguiente función Pascal sigue todas las reglas dadas:

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

¡Sin bucle, sin potencia incorporada o función de exponenciación, ni siquiera recursividad o aritmética!


2

J - 5 o 4 bytes

Exactamente igual que la respuesta APL de marinus .

Para x^y:

*/@$~

Para y^x:

*/@$

Por ejemplo:

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

x $~ ycrea una lista de tiempos xrepetidos y(igual quey $ x

*/ xes la función del producto, */ 1 2 3->1 * 2 * 3


1

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

1
** es operador integrado imo.
Silviu Burcea

@SilviuBurcea Verdadero, edición.
Oberon

@SilviuBurcea operador de =/=la función
VisioN

@VisioN es cierto, pero la idea era sobre incorporados. No creo que el OP sepa de todos estos operadores integrados ...
Silviu Burcea

1

Javascript

Con recursión de cola, funciona si yes un entero positivo

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

1

Golpetazo

Todo el mundo sabe que bashpuede hacer cosas geniales de reducción de mapas ;-)

#!/bin/bash

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

Si eso es demasiado para ti, entonces hay esto:

#!/bin/bash

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

1

C

Otra exponenciación recursiva al cuadrar la respuesta en C, pero difieren (esto usa un cambio en lugar de división, es ligeramente más corto y se repite una vez más que la otra):

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

1

Mathematica

Esto funciona para enteros.

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

Ejemplo

f[5,3]

125


Cómo funciona

Tablehace una lista de y x's. Timestoma el producto de todos ellos.`


Otra forma de lograr el mismo fin :

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

Ejemplo

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

125


1

Lote de Windows

Como la mayoría de las otras respuestas aquí, utiliza la recursividad.

@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 se almacena en la variable de entorno z.


1

perl

Aquí hay una entrada perl recursiva de cola. El uso es echo $ X, $ Y | foo.pl:

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

O para un enfoque de tipo más funcional, ¿qué tal:

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

"a: stuff goto a if something" parece un bucle.
Glenn Randers-Pehrson

Sí, la versión goto es un bucle, pero ¿la recursión de la cola no es esencialmente un bucle?
skibrianski

1

Pitón

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

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

answer =125

No estoy seguro de si esto va en contra de los requisitos, pero si no, aquí está mi intento.


Bienvenido a PPCG! Cuando hace el encabezado del idioma, puede omitir el "idioma =" ya que, de forma personalizada, todos colocan el idioma en el encabezado para que se entienda. De hecho, es posible que se haya topado con las reglas aquí, pero dejaremos que los votantes decidan. Me alegro de tener un nuevo miembro en el club de campo.
Jonathan Van Matre
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.