Zadanie - tytuł właściwie podsumowuje: podnieś liczbę całkowitą x do potęgi x , gdzie 0<x.

Ograniczenia:

• Korzystanie z potęgowania, exp(), ln(), oraz wszelkie inne powiązane uprawnienia-językowe Zabudowy, jak pow(), x^x, x**xjest zabronione.
• Możesz założyć, że podana liczba całkowita mieści się w granicach wybranego języka programowania.

Przypadki testowe:

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

To jest golf golfowy , więc wygrywa najkrótszy program w bajtach.

APL (Dyalog) , 4 bajty

Dla x ^x przyjmuje x jako lewy argument i x jako prawy argument.

×/⍴⍨

Wypróbuj wszystkie skrzynki online!

×/ Produkt

⍴⍨ arg kopie arg

A tutaj jest taki, który obsługuje również ujemne liczby całkowite:

×/|⍴|*×

Wypróbuj wszystkie skrzynki!

×/ produkt z

| całkowita wartość

⍴ R ePetitions z

| wartość bezwzględna

* do potęgi

× podpis

Wbudowana operacja podstawowa Power to:

x*y

Python , 25 bajtów

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

Wypróbuj online!

Mathematica, 16 bajtów

Mam dwa rozwiązania w tej liczbie bajtów:

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

Tutaj #~Table~#tworzy listę nkopii n. Następnie Listgłowa zostaje zastąpiona tym, 1##&co zwielokrotnia wszystkie jej argumenty.

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

To po prostu przechowuje dane wejściowe, na następnie mnoży 1przez n, nrazy.

JavaScript (ES6), 33 28 25 24 bajtów

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

Spróbuj

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 bajtów

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

28 bajtów

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

33 bajty

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

Pure Bash, 43

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

Wypróbuj online .

Nie jestem pewien, czy to zbyt mocno nagina reguły - nie używam żadnego z wymienionych zakazanych wbudowań, ale używam konwersji bazowej.

• printf 1%0$1dwyprowadza 1następnie n 0y
• $[b#a]jest rozszerzeniem arytmetycznym, które należy traktować ajako bliczbę podstawową , co daje wymagany wynik. Niestety baza <2 nie działa, więc dodatkowe ?:bity obsługują wejście n = 1.

Maksymalna wartość wejściowa to 15, ponieważ bash używa 64-bitowych liczb całkowitych ze znakiem (do 2 ³¹ -1).

Alice , 13 bajtów

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

Wypróbuj online!

Wyjaśnienie

/o
\i@/...

Jest to struktura dla programów, które odczytują i zapisują liczby całkowite dziesiętne i działają całkowicie w trybie kardynalnym (czyli programy dla większości problemów arytmetycznych).

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

Standardowy ML , 42 bajty

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

Wypróbuj online!

Wyjaśnienie:

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

Galaretka , 3 bajty

ẋ⁸P

Wypróbuj online!

W jaki sposób?

ẋ⁸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 bajtów

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

Wypróbuj online!

Krok po kroku

Rozciąga się na sześcian o długości boku 2

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

• I:1 Pobiera dane wejściowe, powiela je i przesuwa 1. Ustawia stos z licznikiem, mnożnikiem i wynikiem.
• *s; Mnoży TOS, zamienia wynik z poprzednim i usuwa poprzedni.
• puPrzynieś licznik do TOS. Zawracanie To była zmiana linii, ale musiała ogolić bajt.
• |($Dokonano tego, aby zapisać bajt. Po trafieniu pomija zmniejszenie. odbija, zmniejsza licznik i pomija owijanie bez op wokół kostki.
• !vqWPrzetestuj licznik. Jeśli naprawdę pominiesz przekierowanie, umieść licznik na BOS, zmień linię z powrotem na mnożnik. W przeciwnym razie przekierowanie.
• |sO@jest to sekwencja końcowa przekierowana z licznika testu. Przechodzi obok odbicia poziomego, zamienia TOS przynosząc wynik do TOS, wyjścia i zatrzymania.

R, 22 bajty

czyta xze standardowego.

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

generuje listę xkopii x, a następnie oblicza iloczyn elementów tej listy. W przypadku x=0, gdy reppowraca numeric(0), co jest numeryczny wektor o długości 0, ale prodw to 1, więc0^0=1 tym sposobem, który jest zgodny z wbudowanym potęgowania R, więc to całkiem zgrabny.

Wypróbuj online!

język maszynowy x86_64 dla systemu Linux, 14 11 10 bajtów

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

Aby Spróbuj online! , skompiluj i uruchom następujący program 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) );
  }
}

Rubin, 20 18 bajtów

-2 bajty, ponieważ specyfikacja uległa zmianie i nie potrzebuję już argumentu wykładniczego.

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

Wypróbuj online!

Ułożone , 10 bajtów

{!1[n*]n*}

Wypróbuj online!

Dwuskładnikowe potęgowanie dla tego samego rozmiaru:

{%1[x*]y*}

Obie są funkcjami. Powtarza funkcję, która mnoży się 1przez n nczasy.

Scala , 32 26 bajtów

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

Wypróbuj online! (Dodano konwersję do długiej w TIO, aby nie przepełniała się n = 10).

05AB1E , 3 bajty

.DP

Wypróbuj online! lub Wypróbuj wszystkie przykłady

.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 bajtów

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

Wypróbuj online!

• Zaoszczędzono 1 bajt, dzięki Laikoni
• Zapisane 2 bajty, dzięki Nimi

Japt , 4 bajty

ÆUÃ×

Wypróbuj online!

Wyjaśnienie

Æ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

kod maszynowy x86 (Linux), 18 bajtów

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

Oczekuje deklaracji C w następujący sposób extern int XpowX(int).

Zdemontowane

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

Brachylog , 6 bajtów

g;?j₎×

Wypróbuj online!

Wyjaśnienie

          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 bajtów

ri_a*:*

Wypróbuj online!

Wyjaśnienie

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 bajtów

{[*] $_ xx$_}

$_ xx $_analizuje listę $_kopii $_( $_będącą argumentem funkcji anonimowej), a następnie [*]zmniejsza tę listę przez pomnożenie.

CJam , 6 bajtów

ri_m*,

Wypróbuj 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)}

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

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.

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.

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.

MATLAB/Octave, 23 bytes

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

Python, 32 bytes

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

Try it online!

Common Lisp, 59 42 40 bytes

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

Try it online!