Görev - Başlık hemen hemen o özetliyor: zam bir tamsayı x güç için x , 0<x.

Kısıtlamalar:

• Üs alma kullanın exp(), ln()ve diğer güçler alakalı dil yerleşik ins gibi pow(), x^x, x**xyasaktır.
• Verilen tamsayının seçtiğiniz programlama dilinin sınırlarına uyduğunu varsayabilirsiniz.

Test senaryoları:

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

Bu kod golf , bu nedenle bayttaki en kısa program kazanır.

APL (Dyalog) , 4 bayt

İçin x ^x , sürer x sol argüman olarak ve x sağ argüman olarak.

×/⍴⍨

Tüm vakaları çevrimiçi deneyin!

×/ ürünü

⍴⍨ arg kopyaları arg

Ve işte burada negatif tamsayıları da işleyen:

×/|⍴|*×

Tüm vakaları deneyin!

×/ ürünü

| mutlak değer

⍴ r tekrarları

| mutlak değer

* gücüne

× imza

Dahili Güç ilkel:

x*y

Python , 25 bayt

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

Çevrimiçi deneyin!

Mathematica, 16 bayt

Bu bayt sayımında iki çözümüm var:

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

Burada, kopyalarının #~Table~#bir listesini oluşturur . Daha sonra kafa, tüm argümanlarını bir araya getiren ikame ile değiştirilir .nnList1##&

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

Bu basitçe girişi saklar nve daha sonra çarpma 1tarafından n, nbazen.

JavaScript (ES6), 33 28 25 24 bayt

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

Dene

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>

Tarih

25 bayt

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

28 bayt

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

33 bayt

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

Saf bash, 43

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

Çevrimiçi deneyin .

Bu kuralların çok fazla bükülüp bükülmediğinden emin değilim - Listelenen yasaklanmış yapıların hiçbirini kullanmıyorum, ancak taban dönüşümünü kullanıyorum.

• printf 1%0$1dçıktıları ve 1ardından n 0s
• $[b#a]gerekli sonucu veren abaz bsayı olarak işlem görecek aritmetik bir genişlemedir . Maalesef <2 tabanı çalışmıyor, bu nedenle ekstra ?:bitler n = 1 girişini işliyor.

Maksimum giriş 15'tir, çünkü bash imzalı 64 bitlik tamsayılar kullanır (2 ³¹ -1'e kadar).

Alice , 13 bayt

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

Çevrimiçi deneyin!

açıklama

/o
\i@/...

Bu, ondalık tam sayıları okuyan ve yazan ve tamamen Kardinal modda çalışan programlar için bir çerçevedir (bu nedenle çoğu aritmetik problem için programlar).

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

Standart ML , 42 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Jöle , 3 bayt

ẋ⁸P

Çevrimiçi deneyin!

Nasıl?

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

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

Çevrimiçi deneyin!

Adım adım

Kenar uzunluğu 2 olan bir küpün üzerine genişler

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

• I:1 Girişi alır, çoğaltır ve 1'i iter. Bu, yığını bir sayaç, çarpan ve sonuçla ayarlar.
• *s; Hizmet Şartını çarpar, sonucu öncekiyle değiştirir ve öncekini kaldırır.
• puSayaç öğesini Hizmet Şartları'na getirin. Senin sıran. Bu şerit değiştirmek için kullanılır, ancak bir bayt tıraş etmek gerekiyordu.
• |($Bu bir baytı kurtarmak için yapıldı. Vurulduğunda azalmayı atlar. yansıtır, sayacı azaltır ve küpün etrafına sarılmamış op atlamayı atlar.
• !vqWSayacı test edin. Eğer doğruluk, yönlendirmeyi atlarsa, sayacı BOS'a koyun, şeridi çarpan üzerine geri değiştirin. Aksi takdirde yeniden yönlendirin.
• |sO@bu sayaç testinden yönlendirilen son dizidir. Yatay yansıtmanın ötesine geçer, TOS'u sonuç veren TOS, çıkış ve durma ile değiştirir.

R, 22 bayt

xstdin'den okur .

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

bir xkopyalar listesi oluşturur x, ardından bu listedeki öğelerin ürününü hesaplar. Ne zaman x=0, sayısal bir uzunluk vektörü olan , ama bunun 1 olduğu repdöndürmeler numeric(0), bu nedenle R'nin yerleşik üsleri ile tutarlı olan bu yöntemle, bu oldukça düzgün.0prod0^0=1

Çevrimiçi deneyin!

Linux için x86_64 makine dili, 14 11 10 bayt

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

İçin çevrimiçi deneyin! , derleyin ve aşağıdaki C programını çalıştırın.

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

Yakut, 20 18 bayt

-2 byte çünkü spec değişti ve artık bir üs argümanına ihtiyacım yok.

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

Çevrimiçi deneyin!

Yığılmış , 10 bayt

{!1[n*]n*}

Çevrimiçi deneyin!

Aynı boyutta iki argüman üs alma:

{%1[x*]y*}

Her ikisi de işlevlerdir. Bir fonksiyonu olduğunu çarpar yineler 1tarafından n nzamanlarda.

Scala , 32 26 bayt

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

Çevrimiçi deneyin! (N = 10'da taşmaması için TIO'da uzun süre dönüşüm eklendi.)

05AB1E , 3 bayt

.DP

Çevrimiçi deneyin! veya Tüm örnekleri deneyin

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

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

Çevrimiçi deneyin!

• Laikoni sayesinde 1 bayt kaydedildi
• Nimi sayesinde 2 bayt kaydedildi

Japt , 4 bayt

ÆUÃ×

Çevrimiçi deneyin!

açıklama

Æ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 makine kodu (Linux), 18 bayt

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

Aşağıdaki gibi bir C beyanı bekler extern int XpowX(int) .

Demonte

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 bayt

g;?j₎×

Çevrimiçi deneyin!

açıklama

          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 bayt

ri_a*:*

Çevrimiçi deneyin!

açıklama

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 bayt

{[*] $_ xx$_}

$_ xx $_$_kopyalarının listesine göre değerlendirir $_($_ anonim işlevin bağımsız değişkeni) ve sonra [*]bu listeyi çarpma ile azaltır.

CJam , 6 bayt

ri_m*,

Çevrimiçi deneyin!

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 bayt

{product([_]*_1)}

Çevrimiçi deneyin!

Akıştan girdi alan anonim bir işlevdir.

Açıklama:

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

Bu benim dc'de özyinelemeli bir makro yazma ilk denemem. Eminim ki çok geliştirilebilecek en uygun çözümdür.

dsr1+[lrr1-d1<F*]dsFxp

Çevrimiçi deneyin!

Düzenleme: Teşekkürler eush77 ! -4 bayt.

Toplu, 58 bayt

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

Sadece 32 bit aritmetik nedeniyle tek haneli girişler için çalışır.

brainf * ck , 148 bayt

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

Çevrimiçi deneyin!

Yerleşik yok;)

Nasıl çalışır

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

Özetle, bu, x(girdi) ile çarpı çarparak çalışır x. (yinelenen ek olarak yineleme). Net sonuç x ^ x şeklindedir.

I / O

Program tek bir ASCII girişi alır ve ASCII dizini eksi 48 olarak işler . Eksi 48 gerçek sayılar girişlerini normalleştirmektir ( 4olur 52-> 52-48-> 4). 9'dan daha büyük bir sayı girmek için, bir sonraki uygun ASCII karakterini kullanın ( :-> 58-48->10 ) kullanın. Program benzer bir şekilde çıkar.

Test G / Ç

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

3 girişinden sonra yazdırılabilir ASCII karakterleri bulunmadığından, yalnızca teoride sayıları yazdırabilir . Gerçi, tüm girişler gibi grafikerliği üzerinde aslında çalışmalarında yapmak kontrol edebilirsiniz bu .

MATLAB / Oktav, 23 bayt

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

Python, 32 bayt

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

Çevrimiçi deneyin!

Ortak Lisp , 59 42 40 bayt

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

Çevrimiçi deneyin!