Tugas - Judul ini merangkum cukup banyak: naikkan integer x ke power x , di mana 0<x.

Pembatasan:

• Gunakan exponentiation, exp(), ln(), dan setiap kekuatan-lain yang terkait bahasa built-in, seperti pow(), x^x, x**xdilarang.
• Anda dapat mengasumsikan bahwa bilangan bulat yang diberikan sesuai dengan batas bahasa pemrograman pilihan Anda.

Kasus uji:

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

Ini adalah kode-golf , jadi program terpendek dalam byte menang.

APL (Dyalog) , 4 byte

Untuk x ^x , ambil x sebagai argumen kiri dan x sebagai argumen kanan.

×/⍴⍨

Coba semua kasing online!

×/ produk dari

⍴⍨ salinan salinan arg

Dan di sini di sini ada yang menangani bilangan bulat negatif juga:

×/|⍴|*×

Coba semua kasing!

×/ produk dari

| nilai mutlak

⍴ r epetisi dari

| nilai absolut

* untuk kekuatan

× signum

Primitif Daya bawaan adalah:

x*y

Python , 25 byte

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

Cobalah online!

Mathematica, 16 byte

Saya punya dua solusi pada hitungan byte ini:

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

Di sini, #~Table~#buat daftar nsalinan n. Kemudian Listkepala diganti dengan 1##&yang mengalikan semua argumennya.

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

Ini hanya menyimpan input ndan kemudian dikalikan 1dengan n, nkali.

JavaScript (ES6), 33 28 25 24 byte

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

Cobalah

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>

Sejarah

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

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

Cobalah online .

Tidak yakin apakah ini terlalu banyak membengkokkan aturan - saya tidak menggunakan salah satu builtin terlarang yang terdaftar, tapi saya menggunakan konversi basis.

• printf 1%0$1doutput a 1diikuti oleh n 0s
• $[b#a]adalah ekspansi aritmatika untuk diperlakukan asebagai angka dasar b, yang memberikan hasil yang diperlukan. Sayangnya basis <2 tidak berfungsi, sehingga ?:bit ekstra menangani input n = 1.

Input maksimum adalah 15, karena bash menggunakan integer 64-bit yang telah ditandatangani (hingga 2 ³¹ -1).

Alice , 13 byte

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

Cobalah online!

Penjelasan

/o
\i@/...

Ini adalah kerangka kerja untuk program yang membaca dan menulis bilangan bulat desimal dan beroperasi sepenuhnya dalam mode Kardinal (jadi program untuk sebagian besar masalah aritmatika).

.    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 standar , 42 byte

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

Cobalah online!

Penjelasan:

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 byte

ẋ⁸P

Cobalah online!

Bagaimana?

ẋ⁸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 byte

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

Cobalah online!

Selangkah demi selangkah

Mengembang ke kubus dengan panjang sisi 2

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

• I:1 Mengambil input, menduplikat dan mendorong 1. Ini mengatur tumpukan dengan penghitung, pengganda, dan hasil.
• *s; Lipat gandakan TOS, tukar hasil dengan sebelumnya dan hapus sebelumnya.
• puBawa item counter ke TOS. Putar balik. Ini digunakan untuk menjadi perubahan jalur, tetapi harus mencukur byte.
• |($Ini dilakukan untuk menghemat satu byte. Saat dipukul, lompatan decrement. mencerminkan, mengurangi konter dan melompati no op yang membungkus kubus.
• !vqWUji penghitungnya. Jika benar-benar melewati pengalihan, letakkan penghitung di BOS, ubah jalur kembali ke pengganda. Kalau tidak redirect.
• |sO@ini adalah urutan akhir yang diarahkan ke dari uji tandingan. Melewati pantulan horizontal, menukar TOS yang membawa hasil ke TOS, ouput dan berhenti.

R, 22 byte

dibaca xdari stdin.

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

menghasilkan daftar xsalinan x, kemudian menghitung produk dari elemen daftar itu. Kapanx=0 , reppengembalian numeric(0), yang merupakan vektor numerik panjang 0, tetapi prodyang adalah 1, jadi 0^0=1dengan metode ini, yang konsisten dengan eksponensial builtin R, jadi itu cukup rapi.

Cobalah online!

bahasa mesin x86_64 untuk 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

Untuk Mencoba secara online! , kompilasi dan jalankan program C berikut.

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 karena spek berubah dan saya tidak lagi membutuhkan argumen eksponen.

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

Cobalah online!

Ditumpuk , 10 byte

{!1[n*]n*}

Cobalah online!

Eksponen dua argumen untuk ukuran yang sama:

{%1[x*]y*}

Keduanya adalah fungsi. Mengulangi fungsi yang dikalikan 1dengan n nwaktu.

Scala , 32 26 byte

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

Cobalah online! (Menambahkan konversi menjadi panjang di TIO sehingga tidak akan meluap pada n = 10.)

05AB1E , 3 byte

.DP

Cobalah online! atau Coba semua contoh

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

Cobalah online!

• Disimpan 1 byte, terima kasih kepada Laikoni
• Disimpan 2 byte, terima kasih kepada nimi

Japt , 4 byte

ÆUÃ×

Cobalah online!

Penjelasan

Æ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

kode mesin x86 (Linux), 18 byte

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

Diharapkan deklarasi C sebagai berikut extern int XpowX(int).

Dibongkar

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₎×

Cobalah online!

Penjelasan

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

Cobalah online!

Penjelasan

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 $_mengevaluasi ke daftar $_salinan $_( $_menjadi argumen untuk fungsi anonim), dan kemudian [*]mengurangi daftar itu dengan multiplikasi.

CJam , 6 byte

ri_m*,

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

{product([_]*_1)}

Cobalah online!

Ini adalah fungsi anonim yang mengambil input dari aliran.

Penjelasan:

{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

Ini adalah upaya pertama saya menulis makro rekursif di dc. Saya yakin itu adalah solusi sub-optimal yang dapat ditingkatkan banyak.

dsr1+[lrr1-d1<F*]dsFxp

Cobalah online!

Sunting: Terima kasih eush77 ! -4 byte.

Batch, 58 byte

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

Hanya berfungsi untuk input satu digit karena aritmatika 32-bit.

brainf * ck , 148 byte

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

Cobalah online!

Tidak ada bawaan;)

Bagaimana itu bekerja

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

Singkatnya, ini bekerja dengan mengalikan x(input) dengan sendirinya xkali. (alias tambahan iterasi berulang). Hasil akhirnya adalah x ^ x.

I / O

Program ini mengambil input ASCII tunggal, dan memprosesnya dengan indeks ASCII minus 48 . Yang minus 48 adalah untuk menormalkan input dari angka aktual ( 4menjadi 52-> 52-48-> 4). Untuk memasukkan angka yang lebih tinggi dari 9, gunakan karakter ASCII yang berkaitan dengan waktu yang tepat ( :-> 58-48-> 10). Program ini berjalan dengan cara yang sama.

Tes I / O

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

Karena tidak ada karakter ASCII yang dapat dicetak setelah input 3, maka hanya dapat mencetak angka secara teori . Padahal, Anda dapat memeriksa semua input yang benar-benar berfungsi pada visualisator seperti ini .

MATLAB / Oktaf, 23 byte

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

Python, 32 byte

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

Cobalah online!

Common Lisp , 59 42 40 byte

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

Cobalah online!