Nhiệm vụ - Tiêu đề tổng hợp khá nhiều: nâng một số nguyên x thành lũy thừa x , ở đâu 0<x.

Những hạn chế:

• Sử dụng các lũy thừa, exp(), ln(), ngôn ngữ và bất kỳ quyền hạn liên quan đến khác được xây dựng-in, như pow(), x^x, x**xbị cấm.
• Bạn có thể giả sử rằng số nguyên đã cho phù hợp với giới hạn của ngôn ngữ lập trình bạn chọn.

Các trường hợp thử nghiệm:

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

Đây là môn đánh gôn , vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng.

APL (Dyalog) , 4 byte

Đối với x ^x , lấy x làm đối số bên trái và x làm đối số bên phải.

×/⍴⍨

Hãy thử tất cả các trường hợp trực tuyến!

×/ sản phẩm của

⍴⍨ bản sao arg

Và đây là một trong những xử lý số nguyên âm quá:

×/|⍴|*×

Hãy thử tất cả các trường hợp!

×/ sản phẩm của

| giá trị tuyệt đối

⍴ r epetitions của

| giá trị tuyệt đối

* với sức mạnh của

× dấu hiệu

Nguyên thủy Power tích hợp là:

x*y

Python , 25 byte

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

Hãy thử trực tuyến!

Toán học, 16 byte

Tôi đã có hai giải pháp tại số byte này:

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

Ở đây, #~Table~#tạo một danh sách các nbản sao của n. Sau đó, cái Listđầu được thay thế bằng cách 1##&nhân tất cả các đối số của nó với nhau.

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

Điều này đơn giản lưu trữ các đầu vào trong nvà nhân lên sau đó 1bởi n, nlần.

JavaScript (ES6), 33 28 25 24 byte

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

Thử 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>

Lịch sử

25 byte

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

28 byte

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

33 byte

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

Bash tinh khiết, 43

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

Hãy thử trực tuyến .

Không chắc chắn nếu điều này làm bẻ cong quy tắc quá nhiều - Tôi không sử dụng bất kỳ nội dung bị cấm nào được liệt kê, nhưng tôi đang sử dụng chuyển đổi cơ sở.

• printf 1%0$1dxuất ra một 1tiếp theo bởi n 0s
• $[b#a]là một mở rộng số học để coi anhư một bsố cơ sở , cho kết quả cần thiết. Thật không may, cơ sở <2 không hoạt động, vì vậy các ?:bit bổ sung xử lý đầu vào n = 1.

Đầu vào tối đa là 15, vì bash sử dụng số nguyên 64 bit đã ký (tối đa 2 ³¹ -1).

Alice , 13 byte

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

Hãy thử trực tuyến!

Giải trình

/o
\i@/...

Đây là khung cho các chương trình đọc và ghi số nguyên thập phân và hoạt động hoàn toàn ở chế độ Cardinal (vì vậy các chương trình cho hầu hết các vấn đề số học).

.    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 chuẩn , 42 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Thạch , 3 byte

ẋ⁸P

Hãy thử trực tuyến!

Làm sao?

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

Khối , 19 byte

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

Hãy thử trực tuyến!

Từng bước một

Mở rộng ra một khối có chiều dài 2

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

• I:1 Lấy đầu vào, nhân đôi nó và đẩy 1. Điều này thiết lập ngăn xếp với bộ đếm, số nhân và kết quả.
• *s; Nhân nhiều ĐKDV, hoán đổi kết quả với trước đó và xóa trước đó.
• puMang vật phẩm đến quầy. Đến lượt bạn. Điều này được sử dụng để thay đổi làn đường, nhưng cần thiết để cạo một byte.
• |($Điều này đã được thực hiện để tiết kiệm một byte. Khi đánh nó bỏ qua sự giảm dần. phản ánh, làm giảm bộ đếm và bỏ qua không có op bao quanh khối.
• !vqWKiểm tra quầy. Nếu trung thực bỏ qua chuyển hướng, đặt bộ đếm trên BOS, đổi làn đường trở lại vào hệ số nhân. Nếu không thì chuyển hướng.
• |sO@đây là chuỗi kết thúc được chuyển hướng đến từ kiểm tra truy cập. Đi qua phản xạ ngang, hoán đổi kết quả của ĐKDV đối với ĐKDV, thông số và tạm dừng.

R, 22 byte

đọc xtừ stdin.

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

tạo một danh sách các xbản sao của x, sau đó tính toán sản phẩm của các yếu tố của danh sách đó. Khi x=0, reptrả về numeric(0), là một vectơ số có độ dài 0, nhưng giá prodtrị đó là 1, do đó, 0^0=1theo phương pháp này, phù hợp với phép lũy thừa dựng sẵn của R, vì vậy điều đó khá gọn gàng.

Hãy thử trực tuyến!

x86_64 ngôn ngữ máy cho Linux, 14 11 10 byte

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

Để thử trực tuyến! , biên dịch và chạy chương trình C sau.

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

Ruby, 20 18 byte

-2 byte vì thông số kỹ thuật thay đổi và tôi không còn cần một đối số lũy thừa.

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

Hãy thử trực tuyến!

Xếp chồng lên nhau , 10 byte

{!1[n*]n*}

Hãy thử trực tuyến!

Số mũ hai đối số cho cùng kích thước:

{%1[x*]y*}

Cả hai đều là chức năng. Lặp lại một chức năng mà nhân lên 1bởi n nlần.

Scala , 32 26 byte

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

Hãy thử trực tuyến! (Đã thêm chuyển đổi thành dài trong TIO để nó không tràn vào n = 10.)

05AB1E , 3 byte

.DP

Hãy thử trực tuyến! hoặc Thử tất cả các ví dụ

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

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

Hãy thử trực tuyến!

• Đã lưu 1 byte, nhờ Laikoni
• Đã lưu 2 byte, nhờ nimi

Japt , 4 byte

ÆUÃ×

Hãy thử trực tuyến!

Giải trình

Æ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

Mã máy x86 (Linux), 18 byte

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

Nó mong đợi một tuyên bố C như sau extern int XpowX(int).

Tháo rời

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 byte

g;?j₎×

Hãy thử trực tuyến!

Giải trình

          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 byte

ri_a*:*

Hãy thử trực tuyến!

Giải trình

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 byte

{[*] $_ xx$_}

$_ xx $_ước tính thành một danh sách các $_bản sao của $_( $_là đối số của hàm ẩn danh), sau đó [*]giảm danh sách đó với phép nhân.

CJam , 6 byte

ri_m*,

Hãy thử trực tuyến!

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 byte

{product([_]*_1)}

Hãy thử trực tuyến!

Đây là một chức năng ẩn danh lấy đầu vào từ luồng.

Giải trình:

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

Đây là nỗ lực đầu tiên của tôi khi viết một macro đệ quy bằng dc. Tôi chắc chắn đó là một giải pháp tối ưu phụ có thể được cải thiện rất nhiều.

dsr1+[lrr1-d1<F*]dsFxp

Hãy thử trực tuyến!

Chỉnh sửa: Cảm ơn eush77 ! -4 byte.

Mẻ, 58 byte

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

Chỉ hoạt động cho các đầu vào một chữ số do số học 32 bit.

brainf * ck , 148 byte

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

Hãy thử trực tuyến!

Không tích hợp sẵn;)

Làm thế nào nó hoạt động

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

Tóm lại, điều này hoạt động bằng cách nhân x(đầu vào) với xthời gian của chính nó . (còn gọi là phép lặp lặp bổ sung). Kết quả ròng là x ^ x.

Tôi / O

Chương trình lấy một đầu vào ASCII duy nhất và xử lý nó như là chỉ số ASCII trừ 48 . Điểm trừ 48 là bình thường hóa đầu vào của các số thực tế ( 4trở thành 52-> 52-48-> 4). Để nhập số cao hơn 9, hãy sử dụng ký tự ASCII ăn mòn tiếp theo ( :-> 58-48-> 10). Chương trình xuất hiện theo cách tương tự.

Kiểm tra I / O

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

Vì không có ký tự ASCII có thể in sau đầu vào 3, nên nó chỉ có thể in số theo lý thuyết . Mặc dù vậy, bạn có thể kiểm tra tất cả các yếu tố đầu vào thực tế hoạt động trên các trình hiển thị như thế này .

MATLAB / Octave, 23 byte

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

Python, 32 byte

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

Hãy thử trực tuyến!

Lisp thường gặp , 59 42 40 byte

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

Hãy thử trực tuyến!