Eleve el entero x a la potencia x, sin incorporaciones de exponenciación


16

Tarea: el título lo resume más o menos: eleva un entero x a power x , donde 0<x.

Restricciones:

  • El uso de exponenciación, exp(), ln(), lenguaje y otros relacionados poderes empotrados, como pow(), x^x, x**xestá prohibido.
  • Puede suponer que el entero dado se ajusta a los límites del lenguaje de programación que elija.

Casos de prueba:

Input | Output
---------------
2     | 4
3     | 27
5     | 3125
6     | 46656
10    | 10000000000

Este es el , por lo que gana el programa más corto en bytes.


¿Podemos aceptar entradas como una cadena?
Shaggy

He hecho una edición para esto, con la esperanza de que se vuelva a abrir. Eliminé la regla 3 y, en cambio, dije que debería ser un programa completo, como probablemente lo pretendía el OP
Sr. Xcoder

Mucho mejor, @ Mr.Xcoder, pero sugiero eliminar (o volver a redactar) la segunda restricción. ¿"No es una función" excluye a JS de participar? También me gustaría sugerir, a los efectos del desafío, que debemos tener al mango 0y que se especificará la salida esperada ( 0o 1, o bien). Finalmente, tener que manejar enteros negativos sería una buena adición al desafío.
Shaggy

@Shaggy agregó js de nuevo en ... calculó 0 ^ 0 en la calculadora de Apple y devolvió 1. Quizás 1 debería ser el valor elegido, porque Python también devuelve 1para 0^0. Sin embargo, Foundation+ Swift devuelve 0
Mr. Xcoder

1
@ Mr.Xcoder, eliminé la "restricción" que no necesitamos manejar 0y en su lugar especifiqué eso 0<xen la entrada. También eliminé la restricción de que el código no debería arrojar errores; Eso debería ser evidente. Siéntase libre de retroceder si es necesario.
Shaggy

Respuestas:


15

APL (Dyalog) , 4 bytes

Para x x , toma x como argumento izquierdo yx como argumento derecho.

×/⍴⍨

¡Pruebe todos los casos en línea!

×/ producto de

⍴⍨ arg copias arg

Y aquí hay uno que también maneja enteros negativos:

×/|⍴|*×

¡Prueba todos los casos!

×/ el producto de

| valor absoluto

r epetitions de

| el valor absoluto

* al poder de

× el signum

La primitiva de potencia incorporada es:

x*y


9

Mathematica, 16 bytes

Tengo dos soluciones en este recuento de bytes:

1##&@@#~Table~#&

Aquí, #~Table~#crea una lista de ncopias de n. Luego, la Listcabeza se reemplaza por la 1##&que multiplica todos sus argumentos.

Nest[n#&,1,n=#]&

Esto simplemente almacena la entrada en ny se multiplica luego 1por n, nveces.


1
#~Product~{#}&
alephalpha

1
@alephalpha ah, buen punto. Puedes publicar eso como una respuesta separada.
Martin Ender

5

JavaScript (ES6), 33 28 25 24 bytes

n=>g=(x=n)=>--x?n*g(x):n

Intentalo

f=
n=>g=(x=n)=>--x?n*g(x):n
o.innerText=f(i.value=3)()
i.oninput=_=>o.innerText=f(+i.value)()
<input id=i min=1 type=number><pre id=o>


Historia

25 bytes

f=(n,x=n)=>--x?n*f(n,x):n

28 bytes

n=>eval(1+("*"+n).repeat(n))

33 bytes

n=>eval(Array(n).fill(n).join`*`)

4

Puro bash, 43

echo $[$1<2?1:$[$1<2?2:$1]#`printf 1%0$1d`]

Pruébalo en línea .

No estoy seguro de si esto está doblando demasiado las reglas: no estoy usando ninguno de los componentes prohibidos enumerados, pero estoy usando la conversión de base.

  • printf 1%0$1dproduce a 1seguido de n 0s
  • $[b#a]es una expansión aritmética para tratar acomo un bnúmero base , que da el resultado requerido. Lamentablemente, base <2 no funciona, por lo que los ?:bits adicionales manejan la entrada n = 1.

La entrada máxima es 15, porque bash usa enteros con signo de 64 bits (hasta 2 31 -1).


Mismo problema que tuve, esto no funciona para x = 1. No obstante, enfoque muy interesante.
Maxim Mikhaylov

@MaxLawnboy Gracias por señalar eso, que tristemente hinchó mi respuesta. Quizás pueda encontrar otra versión más corta ...
Digital Trauma

Cosas interesantes. Siempre quise aprender bash, pero siempre fui demasiado flojo para ello =)

4

Alice , 13 bytes

/o
\i@/.&.t&*

Pruébalo en línea!

Explicación

/o
\i@/...

Este es un marco para programas que leen y escriben enteros decimales y operan completamente en modo Cardinal (por lo tanto, programas para la mayoría de los problemas aritméticos).

.    Duplicate n.
&.   Make n copies of n.
t    Decrement the top copy to n-1.
&*   Multiply the top two values on the stack n-1 times, computing n^n.


3

Jalea , 3 bytes

ẋ⁸P

Pruébalo en línea!

¿Cómo?

ẋ⁸P - Main link: x             e.g. 4
 ⁸  - link's left argument, x       4
ẋ   - repeat left right times       [4,4,4,4]
  P - product                       256

Maldición, quería hacer esto. : P
HyperNeutrino

@ Jonathan Allan ¿son 3 bytes o 3 caracteres anchos? veamos el volcado hexadecimal del código fuente, por favor, para tomar la decisión correcta sobre el tamaño real del código. ;-) y hacer las correcciones

1
@ xakepp35 Jelly usa un SBCS y el enlace de bytes en el encabezado apunta a él. El programa con hexdump F7 88 50funciona según lo previsto.
Dennis

@ Dennis gracias por responder! nunca podría imaginar un lenguaje así =)

3

Cubix , 19 bytes

..@OI:1*s;pu!vqW|($

Pruébalo en línea!

Paso a paso

Se expande sobre un cubo con longitud lateral 2

    . .
    @ O
I : 1 * s ; p u
! v q W | ( $ .
    . .
    . .
  • I:1 Toma la entrada, la duplica y empuja 1. Esto configura la pila con un contador, multiplicador y resultado.
  • *s; Multiplica el TOS, intercambia el resultado con anterior y elimina el anterior.
  • puTraiga el artículo de mostrador a los TOS. Tu turno. Esto solía ser un cambio de carril, pero necesitaba afeitarse un byte.
  • |($Esto se hizo para guardar un byte. Cuando se golpea se salta el decremento. refleja, disminuye el contador y omite la operación no operativa alrededor del cubo.
  • !vqWPrueba el contador. Si la verdad se saltea la redirección, coloca el contador en BOS, cambia el carril nuevamente al multiplicador. De lo contrario redirigir.
  • |sO@Esta es la secuencia final redirigida desde la prueba de contador. Pasa el reflejo horizontal, intercambia los TOS y trae el resultado a los TOS, sale y se detiene.

3

R, 22 bytes

lee xde stdin.

prod(rep(x<-scan(),x))

genera una lista de xcopias de x, luego calcula el producto de los elementos de esa lista. Cuando x=0, los repretornos numeric(0), que es un vector numérico de longitud 0, pero el prodde eso es 1, entonces0^0=1 por este método, que es consistente con la exponenciación incorporada de R, es bastante claro.

Pruébalo en línea!


3

Lenguaje de máquina x86_64 para Linux, 14 11 10 bytes

0:   6a 01                   pushq  $0x1
2:   58                      pop    %rax
3:   89 f9                   mov    %edi,%ecx
5:   f7 ef                   imul   %edi
7:   e2 fc                   loop   5
9:   c3                      retq

Para probarlo en línea! , compila y ejecuta el siguiente programa en C.

const char h[]="\x6a\1\x58\x89\xf9\xf7\xef\xe2\xfc\xc3";

int main(){
  for( int i = 1; i < 4; i++ ) {
    printf( "%d %d\n", i, ((int(*)())h)(i) );
  }
}




2

05AB1E , 3 bytes

.DP

Pruébalo en línea! o Pruebe todos los ejemplos

.D  # pop a,b    push b copies of a 
    # 05AB1E implicitly takes from input if there aren't enough values on the stack
    # For input 5, this gives us the array: [5,5,5,5,5]
  P # Take the product of that array
    # Implicit print

Parece que lo disfrutaste .D. La primera vez que lo veo usado.
Urna mágica del pulpo

ah, i dont get what is happening here.. seems to be too exotic and no explanation on how that works. =(

@xakepp35 Does that help?
Riley


2

Japt, 4 bytes

ÆUÃ×

Try it online!

Explanation

ÆUÃ×       // implicit: U = input integer
Uo{U} r*1  // ungolfed

Uo{ }      // create array [0, U) and map each value to...
   U       //   the input value
      r*1  // reduce with multiplication, starting at 1          
           // implicit output of result

2

x86 machine code (Linux), 18 bytes

31 c0 ff c0 31 db 39 df 74 07 0f af c7 ff c3 eb f5 c3

It expects a C declaration as follows extern int XpowX(int).

Disassembled

XpowX:
  # edi : input register
  # ebx : counter
  # eax : result register
  xor  %eax, %eax    # result  = 0
  inc  %eax          # result += 1
  xor  %ebx, %ebx    # counter = 0
  loop:
    cmp  %ebx, %edi  # if (counter == input)
    je   done        #   return result
    imul %edi, %eax  # result  *= input
    inc        %ebx  # counter += 1
    jmp   loop
  done:
    ret

1

Brachylog, 6 bytes

g;?j₎×

Try it online!

Explanation

          Example input: 5
g         Group: [5]
 ;?       Pair with the Input: [[5], 5]
   j₎     Juxtapose [5] 5 times: [5, 5, 5, 5, 5]
     ×    Multiply

1

CJam, 7 bytes

ri_a*:*

Try it online!

Explanation

ri       e# Read an int from input
  _      e# Duplicate it
   a*    e# Put the copy in the array and repeat it that many times
     :*  e# Take the product of the array

1

Perl 6, 13 bytes

{[*] $_ xx$_}

$_ xx $_ evaluates to a list of $_ copies of $_ ($_ being the argument to the anonymous function), and then [*] reduces that list with multiplication.


1

CJam, 6 bytes

ri_m*,

Try it online!

ri       e# Read integer
  _      e# Duplicate
   m*    e# Cartesian power. The first argument is interpreted as a range
     ,   e# Number of elements. Implicitly display


1

Röda, 17 bytes

{product([_]*_1)}

Try it online!

It's an anonymous function that takes it's input from the stream.

Explanation:

{product([_]*_1)}
{               } /* An anonymous function */
         [_]      /* An array containing the input value */
            *_1   /* repeated times the input value */
 product(      )  /* Product of all values in the array */

1

dc, 24 23 26 22 bytes

This is my first attempt writing a recursive macro in dc. I am sure it is a sub-optimal solution which can be improved a lot.

dsr1+[lrr1-d1<F*]dsFxp

Try it online!

Edit: Thanks eush77! -4 bytes.


1
Does not work for x=1.
eush77

You can shave off two bytes by replacing lr sequences at the end with two ds at the beginning.
eush77

Actually, you don't need that. Just increment the top of the stack before calling for the first time. This way you will end up with x copies of x on the stack (and 1 of course), and x multiplications thereafter. So the ending can just be plain dsFxp.
eush77

@eush77 I was about to say that removing second lr wouldn't work here. It's my first time golfing in a stack-based language, so it feels very unusual. Thanks for your help!
Maxim Mikhaylov

1

Batch, 58 bytes

@set n=1
@for /l %%i in (1,1,%1)do @set/an*=%1
@echo %n%

Only works for single-digit inputs due to 32-bit arithmetic.


1

brainf*ck, 148 bytes

,[->+>+<<]>>[-<<+>>]++++++++[<------<------>>-]<[->>+>>+<<<<]>>[-<<+>>]>>-[-<<<<<[>[>+>+<<-]>>[<<+>>-]<<<-]>>[-<<+>>]>>>]<<<++++++++[-<<++++++>>]<<.

Try it online!

No built-ins ;)

How it works

,                                       - get ascii input
[->+>+<<]                               - duplicate input
>>[-<<+>>]                              - shift inputs left to start
++++++++[<------<------>>-]             - convert ascii into input numbers
<[->>+>>+<<<<]                          - get loop intervals (same as input #)
>>[-<<+>>]                              - shift input back again
>>-[-<<<<<[>[>+>+<<-]>>[<<+>>-]<<<-]>>  - iterated addition (multiplication)
[-<<+>>]>>>                             - Shift output back into input
]<<<++++++++[-<<++++++>>]<<.            - convert final output to ascii

In a nutshell, this works by multiplying x (the input) by itself x times. (a.k.a. iterating iterated addition). The net result is x^x.

I/O

The program takes a single ASCII input, and processes it as it's ASCII index minus 48. The minus 48 is to normalize inputs of actual numbers (4 becomes 52 -> 52-48 -> 4). To input a number higher than 9, use the next corrosponging ASCII character (: -> 58-48 -> 10). The program ouputs in a similar fashion.

Test I/O

INPUT > PROCESSED INPUT >> OUTPUT > TRANSLATED OUTPUT
1 > 1 >> 1 > 1
2 > 2 >> 4 > 4
3 > 3 >> K > 27

Since there are no printable ASCII characters after an input of 3, it can only print numbers in theory. Though, you can check all inputs do in fact work on visualizers such as this.



1

Python, 32 bytes

f=lambda g,z=1:z>g or g*f(g,z+1)

Try it online!


Welcome to PPCG! You don't need to count the f= part, so you can shorten your submission to 30 bytes.
Steadybox

@Steadybox The f= part does need to be counted, because it's recursive, so it relies upon the function being named f in order to work properly
musicman523

@musicman523 Yes, you are right.
Steadybox

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.