งาน -จำนวนเงินที่ชื่อมันสวยมากขึ้น: เพิ่มเป็นจำนวนเต็มxสู่อำนาจx0<xที่

ข้อ จำกัด:

• ใช้การยกกำลัง, exp(), ln()และอื่น ๆ ภาษาอำนาจที่เกี่ยวข้องกับการสร้างอินเช่นpow(), x^x, x**xเป็นสิ่งต้องห้าม
• คุณสามารถสมมติได้ว่าจำนวนเต็มที่กำหนดนั้นตรงกับขีด จำกัด ของภาษาการเขียนโปรแกรมที่คุณเลือก

กรณีทดสอบ:

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

นี่คือโค้ดกอล์ฟดังนั้นโปรแกรมที่สั้นที่สุดในหน่วยไบต์ชนะ

APL (Dyalog) 4 ไบต์

สำหรับx ^xให้ใช้xเป็นอาร์กิวเมนต์ซ้ายและxเป็นอาร์กิวเมนต์ที่ถูกต้อง

×/⍴⍨

ลองทุกกรณีทางออนไลน์!

×/ ผลิตภัณฑ์ของ

⍴⍨ หาเรื่องคัดลอกหาเรื่อง

และนี่คือสิ่งที่จัดการกับจำนวนเต็มลบเช่นกัน:

×/|⍴|*×

ลองทุกกรณี!

×/ ผลิตภัณฑ์ของ

| ค่าสัมบูรณ์

⍴ r epetitions ของ

| ค่าสัมบูรณ์

* ถึงพลังของ

× signum

Primitive Power ในตัวคือ:

x*y

Pythonขนาด 25 ไบต์

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

ลองออนไลน์!

Mathematica ขนาด 16 ไบต์

ฉันมีสองวิธีในการนับไบต์นี้:

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

ที่นี่#~Table~#สร้างรายชื่อของสำเนาของn nจากนั้นListหัวจะถูกแทนที่ด้วย1##&ซึ่งจะเพิ่มการขัดแย้งทั้งหมดเข้าด้วยกัน

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

นี้ก็เก็บที่ป้อนเข้าในnแล้วคูณ1โดยn, nครั้ง

JavaScript (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เอาท์พุท a 1ตามด้วย n 0s
• $[b#a]เป็นการขยายเลขคณิตเพื่อใช้aเป็นbเลขฐานซึ่งให้ผลลัพธ์ที่ต้องการ น่าเสียดายฐาน <2 ไม่ทำงานดังนั้น?:บิตพิเศษจึงจัดการอินพุต n = 1

อินพุตสูงสุดคือ 15 เนื่องจาก bash ใช้จำนวนเต็ม 64- บิตที่มีลายเซ็น (สูงสุด 2 ³¹ -1)

อลิซ 13 ไบต์

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

ลองออนไลน์!

คำอธิบาย

/o
\i@/...

นี่เป็นเฟรมเวิร์กสำหรับโปรแกรมที่อ่านและเขียนเลขจำนวนเต็มฐานสิบและทำงานในโหมด Cardinal (ดังนั้นโปรแกรมสำหรับปัญหาทางคณิตศาสตร์ส่วนใหญ่)

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

Jelly, 3 bytes

ẋ⁸P

Try it online!

How?

ẋ⁸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|($

Try it online!

Step by Step

Expands out onto a cube with side length 2

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

• I:1 Takes the input, duplicates it and pushs 1. This sets up the stack with a counter, multiplier and result.
• *s; Multiples the TOS, swaps the result with previous and remove previous.
• pu Bring the counter item to the TOS. U-turn. This use to be a lane change, but needed to shave a byte.
• |($ This was done to save a byte. When hit it skips the decrement. reflects, decrements the counter and skips the no op wrapping around the cube.
• !vqW Test the counter. If truthy skip the redirect, put the counter on BOS, change lane back onto the multiplier. Otherwise redirect.
• |sO@ this is the end sequence redirected to from counter test. Goes past the horizontal reflect, swaps the TOS bringing result to the TOS, ouput and halt.

R, 22 bytes

reads x from stdin.

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

generates a list of x copies of x, then computes the product of the elements of that list. When x=0, the rep returns numeric(0), which is a numeric vector of length 0, but the prod of that is 1, so 0^0=1 by this method, which is consistent with R's builtin exponentiation, so that's pretty neat.

Try it online!

x86_64 machine language for 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

To Try it online!, compile and run the following C program.

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 bytes

-2 bytes because the spec changed and I no longer need an exponent argument.

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

Try it online!

Stacked, 10 bytes

{!1[n*]n*}

Try it online!

Two-argument exponentiation for the same size:

{%1[x*]y*}

Both are functions. Repeats a function that multiplies 1 by n n times.

Scala, 32 26 bytes

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

Try it online! (Added conversion to long in the TIO so it wouldn't overflow on n=10.)

05AB1E, 3 bytes

.DP

Try it online! or Try all examples

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

Try it online!

• Saved 1 byte, thanks to Laikoni
• Saved 2 bytes, thanks to nimi

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

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!