작업 - 제목 꽤 많은 금액을 최대 : 인상 정수 X 전원에 X를 , 0<x.

제한 사항 :

• 지수의 사용 exp(), ln()및 기타 권한 관련 언어에 내장 된 기능은, 같은 pow(), x^x, x**x금지되어 있습니다.
• 주어진 정수가 선택한 프로그래밍 언어의 한계에 맞는 것으로 가정 할 수 있습니다.

테스트 사례 :

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

이것은 code-golf 이므로 바이트 단위의 가장 짧은 프로그램이 승리합니다.

APL (Dyalog) , 4 바이트

를 들어 X ^X , 소요 X 왼쪽 인수로하고 X를 오른쪽 인자로.

×/⍴⍨

모든 사례를 온라인으로 시도하십시오!

×/ 의 제품

⍴⍨ arg 사본 arg

그리고 여기에 음의 정수도 처리하는 것이 있습니다 :

×/|⍴|*×

모든 경우를 시도하십시오!

×/ 의 제품

| 절대 값

⍴ r에 의 epetitions

| 절대 값

* ~의 힘으로

× 부호

내장 전원 기본 요소는 다음과 같습니다.

x*y

파이썬 , 25 바이트

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

온라인으로 사용해보십시오!

수학, 16 바이트

이 바이트 수에는 두 가지 해결책이 있습니다.

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

여기에 #~Table~#의 n사본 목록을 만듭니다 n. 그런 다음 List머리는 1##&모든 인수를 모두 곱한 것으로 바뀝니다 .

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

이것은 단순히 입력에서 저장 n하고 곱 1함으로써 n, n회.

자바 스크립트 (ES6), 33 28 25 24 바이트

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

시도 해봐

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>

역사

25 바이트

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

28 바이트

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

33 바이트

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

순수한 배쉬, 43

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

온라인으로 사용해보십시오 .

이것이 규칙을 너무 많이 굽히고 있는지 확실하지 않습니다-나열된 금지 된 내장을 사용하지 않지만 기본 변환을 사용하고 있습니다.

• printf 1%0$1d 출력 1 n은 다음 0의
• $[b#a]a기본 b숫자 로 취급하기위한 산술 확장으로 필요한 결과를 제공합니다. 불행히도 base <2는 작동하지 않으므로 추가?: 비트는 입력 n = 1을 처리합니다.

bash는 부호있는 64 비트 정수 (최대 2 ³¹ -1) 를 사용하기 때문에 최대 입력은 15 입니다.

Alice , 13 바이트

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

온라인으로 사용해보십시오!

설명

/o
\i@/...

이것은 십진 정수를 읽고 쓰는 프로그램이며 기본적으로 카디널 모드 (대부분의 산술 문제를위한 프로그램)에서 작동하는 프로그램을위한 프레임 워크입니다.

.    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 , 42 바이트

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

온라인으로 사용해보십시오!

설명:

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

젤리 , 3 바이트

ẋ⁸P

온라인으로 사용해보십시오!

어떻게?

ẋ⁸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 바이트

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

온라인으로 사용해보십시오!

단계별

측면 길이가 2 인 큐브로 확장

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

• I:1 입력을 가져 와서 복제 한 다음 1을 누릅니다. 그러면 카운터, 승수 및 결과로 스택이 설정됩니다.
• *s; TOS를 곱하고 결과를 이전과 바꾸고 이전을 제거합니다.
• pu카운터 항목을 TOS로 가져 오십시오. 유턴. 이것은 차선 변경이지만 바이트를 면도해야했습니다.
• |($이것은 바이트를 절약하기 위해 수행되었습니다. 적중하면 감소를 건너 뜁니다. 카운터를 반영, 감소 및 감소 시키며 큐브 주위의 op 랩핑을 건너 뜁니다.
• !vqW카운터를 테스트하십시오. 진실이 리디렉션을 건너 뛰면 카운터를 BOS에 놓고 레인을 승수로 다시 변경하십시오. 그렇지 않으면 리디렉션하십시오.
• |sO@이것은 카운터 테스트에서 리디렉션 된 최종 시퀀스입니다. 수평 반사를지나 TOS를 교체하여 결과를 TOS로 가져와 출력 및 정지합니다.

R, 22 바이트

xstdin에서 읽습니다 .

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

의 x사본 목록을 생성 한 x다음 해당 목록 요소의 곱을 계산합니다. 경우 x=0의 rep반환 numeric(0)길이의 숫자 벡터이다, 0하지만 prod그 때문에, 1 0^0=1이 꽤 깔끔한 그래서, R의 내장의 지수와 일치하는이 방법에 의해.

온라인으로 사용해보십시오!

Linux 용 x86_64 기계 언어, 14 11 10 바이트

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

하려면 온라인으로보십시오! 다음 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) );
  }
}

루비, 20 18 바이트

스펙이 변경되어 더 이상 지수 인수가 필요하지 않기 때문에 -2 바이트.

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

온라인으로 사용해보십시오!

스택 형 , 10 바이트

{!1[n*]n*}

온라인으로 사용해보십시오!

같은 크기에 대한 두 개의 인수 지수 :

{%1[x*]y*}

둘 다 기능입니다. 함수 곱셈을 반복 1함으로써 n n시간.

스칼라 , 32 26 바이트

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

온라인으로 사용해보십시오! (TIO에서 long으로 변환이 추가되어 n = 10에서 오버플로되지 않습니다.)

05AB1E , 3 바이트

.DP

온라인으로 사용해보십시오! 또는 모든 예를보십시오

.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

하스켈 , 24 23 21 바이트

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

온라인으로 사용해보십시오!

• Laikoni 덕분에 1 바이트 절약
• nimi 덕분에 2 바이트 절약

Japt , 4 바이트

ÆUÃ×

온라인으로 사용해보십시오!

설명

Æ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

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

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

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

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.

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

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!