Tarefa - O título resume muito bem: aumente um número inteiro x ao poder x , onde 0<x.

Restrições:

• Use de exponenciação, exp(), ln(), língua e quaisquer outros poderes-relacionados built-ins, como pow(), x^x, x**xé proibido.
• Você pode supor que o número inteiro ajustado se enquadre nos limites da linguagem de programação de sua escolha.

Casos de teste:

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

Isso é código-golfe , então o programa mais curto em bytes vence.

APL (Dyalog) , 4 bytes

Para x ^x , leva x como argumento esquerda e x como argumento direita.

×/⍴⍨

Experimente todos os casos online!

×/ produto de

⍴⍨ arg copia arg

E aqui está um que também lida com números inteiros negativos:

×/|⍴|*×

Experimente todos os casos!

×/ o produto de

| valor absoluto

⍴ r epetições de

| o valor absoluto

* ao poder de

× o signum

A primitiva Power integrada é:

x*y

Python , 25 bytes

lambda n:eval('1'+'*n'*n)

Experimente online!

Mathematica, 16 bytes

Eu tenho duas soluções nessa contagem de bytes:

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

Aqui, #~Table~#cria uma lista de ncópias de n. Em seguida, a Listcabeça é substituída pela 1##&que multiplica todos os seus argumentos.

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

Isto simplesmente armazena a entrada em ne se multiplica então 1por n, nvezes.

JavaScript (ES6), 33 28 25 24 bytes

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

Tente

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>

História

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

Pure bash, 43

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

Experimente online .

Não tenho certeza se isso está dobrando muito as regras - não estou usando nenhum dos builtins proibidos listados, mas estou usando a conversão de base.

• printf 1%0$1dgera a 1seguido de n0 s
• $[b#a]é uma expansão aritmética a ser tratada acomo um bnúmero base , que fornece o resultado necessário. Infelizmente, a base <2 não funciona, então o extra?: bits manipulam a entrada n = 1.

A entrada máxima é 15, porque o bash usa números inteiros assinados de 64 bits (até 2 ³¹ -1).

Alice , 13 bytes

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

Experimente online!

Explicação

/o
\i@/...

Essa é uma estrutura para programas que lêem e escrevem números inteiros decimais e operam inteiramente no modo Cardinal (portanto, programas para a maioria dos 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.

ML padrão , 42 bytes

fn x=>foldl op*1(List.tabulate(x,fn y=>x))

Experimente online!

Explicação:

fn y => x                 (* An anonymous function that always returns the inputted value *)
List.tabulate(x, fn y=>x) (* Create a list of size x where each item is x *)
foldl op* 1               (* Compute the product of the entire list *)    

Gelatina , 3 bytes

ẋ⁸P

Experimente online!

Quão?

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

Cubix , 19 bytes

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

Experimente online!

Passo a passo

Expande para um cubo com comprimento lateral 2

    . .
    @ O
I : 1 * s ; p u
! v q W | ( $ .
    . .
    . .

• I:1 Pega a entrada, duplica e pressiona 1. Isso configura a pilha com um contador, multiplicador e resultado.
• *s; Multiplica os TOS, troca o resultado por anterior e remove anterior.
• puTraga o item do contador para os Termos de Serviço. Sua vez. Isso costumava ser uma alteração de faixa, mas precisava raspar um byte.
• |($Isso foi feito para salvar um byte. Quando atingido, pula o decremento. reflete, diminui o contador e ignora o invólucro sem operação ao redor do cubo.
• !vqWTeste o contador. Se realmente pular o redirecionamento, coloque o contador no BOS e mude a faixa novamente para o multiplicador. Caso contrário, redirecione.
• |sO@essa é a sequência final redirecionada para o contra-teste. Vai além da reflexão horizontal, troca os TOS, trazendo o resultado para os TOS, saída e parada.

R, 22 bytes

lê xde stdin.

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

gera uma lista de xcópias de xe calcula o produto dos elementos dessa lista. Quando x=0, o repretorno numeric(0), que é um vetor numérico de comprimento 0, mas o valor prodé 1, é 0^0=1por esse método, que é consistente com a exponenciação interna de R, então é bem legal.

Experimente online!

linguagem 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 experimentá-lo online! , compile e execute o seguinte programa 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) );
  }
}

Rubi, 20 18 bytes

-2 bytes porque a especificação mudou e eu não preciso mais de um argumento de expoente.

->x{eval [x]*x*?*}

Experimente online!

Empilhados , 10 bytes

{!1[n*]n*}

Experimente online!

Exponenciação de dois argumentos para o mesmo tamanho:

{%1[x*]y*}

Ambos são funções. Repete uma função que se multiplica 1por n nvezes.

Scala , 32 26 bytes

n=>List.fill(n)(n).product

Experimente online! (Adicionada conversão para long no TIO para não exceder em n = 10.)

05AB1E , 3 bytes

.DP

Experimente online! ou Experimente todos os exemplos

.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

Haskell , 24 23 21 bytes

f y=product$y<$[1..y]

Experimente online!

• Guardado 1 byte, graças a Laikoni
• Economizou 2 bytes, graças a nimi

Japt , 4 bytes

ÆUÃ×

Experimente online!

Explicação

Æ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

código de máquina x86 (Linux), 18 bytes

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

Ele espera uma declaração C da seguinte maneira extern int XpowX(int).

Desmontado

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

Braquilog , 6 bytes

g;?j₎×

Experimente online!

Explicação

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

CJam , 7 bytes

ri_a*:*

Experimente online!

Explicação

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

Perl 6 , 13 bytes

{[*] $_ xx$_}

$_ xx $_avalia para uma lista de $_cópias de $_( $_sendo o argumento para a função anônima) e [*]reduz a lista com multiplicação.

CJam , 6 bytes

ri_m*,

Experimente 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

Clojure, 22

#(apply *(repeat % %))

:)

Röda , 17 bytes

{product([_]*_1)}

Experimente online!

É uma função anônima que recebe sua entrada do fluxo.

Explicação:

{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 */

dc , 24 23 26 22 bytes

Esta é minha primeira tentativa de escrever uma macro recursiva em dc. Estou certo de que é uma solução subótima que pode ser melhorada bastante.

dsr1+[lrr1-d1<F*]dsFxp

Experimente online!

Edit: Obrigado eush77 ! -4 bytes.

Lote, 58 bytes

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

Funciona apenas para entradas de um dígito devido à aritmética de 32 bits.

brainf * ck , 148 bytes

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

Experimente online!

Sem built-ins;)

Como funciona

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

Em poucas palavras, isso funciona multiplicando x(a entrada) por si próprio xvezes. (aka iterando adição iterada). O resultado líquido é x ^ x.

I / O

O programa pega uma única entrada ASCII e a processa como seu índice ASCII menos 48 . O menos 48 é para normalizar as entradas dos números reais ( 4torna 52- se -> 52-48-> 4). Para inserir um número maior que 9, use o próximo caractere ASCII de corrosão ( :-> 58-48-> 10). O programa sai de maneira semelhante.

E / S de teste

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

Como não há caracteres ASCII imprimíveis após uma entrada de 3, ele só pode imprimir números em teoria . No entanto, você pode verificar se todas as entradas funcionam de fato em visualizadores como esse .

MATLAB / oitava, 23 bytes

@(n)(prod(n*ones(n,1)))

Python, 32 bytes

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

Experimente online!

Lisp comum , 59 42 40 bytes

(lambda(x)(apply'*(fill(make-list x)x)))

Experimente online!