Tâche - Le titre résume assez bien: augmenter un entier x pour alimenter x , où 0<x.

Restrictions:

• L' utilisation de exponentiation, exp(), ln()et tout autre comme langue connexes-pouvoirs Encastrements, pow(), x^x, x**xest interdite.
• Vous pouvez supposer que l'entier donné correspond aux limites du langage de programmation de votre choix.

Cas de test:

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

Il s'agit de code-golf , donc le programme le plus court en octets l'emporte.

APL (Dyalog) , 4 octets

Pour x ^x , prend x comme argument gauche et x comme argument droit.

×/⍴⍨

Essayez tous les cas en ligne!

×/ produit de

⍴⍨ arg copies arg

Et en voici un qui gère également les entiers négatifs:

×/|⍴|*×

Essayez tous les cas!

×/ le produit de

| valeur absolue

⍴ r épétitions de

| la valeur absolue

* au pouvoir de

× le signum

La primitive Power intégrée est:

x*y

Python , 25 octets

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

Essayez-le en ligne!

Mathematica, 16 octets

J'ai deux solutions à ce nombre d'octets:

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

Ici, #~Table~#crée une liste de ncopies de n. Ensuite, la Listtête est remplacée par 1##&ce qui multiplie tous ses arguments ensemble.

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

Cela stocke simplement l'entrée npuis multiplie 1par n, nfois.

JavaScript (ES6), 33 28 25 24 octets

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

Essayez-le

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>

Histoire

25 octets

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

28 octets

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

33 octets

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

Pure bash, 43

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

Essayez-le en ligne .

Je ne sais pas si cela déforme trop les règles - je n'utilise aucun des modules internes interdits répertoriés, mais j'utilise la conversion de base.

• printf 1%0$1dsorties a 1suivi de n 0s
• $[b#a]est une expansion arithmétique à traiter acomme un bnombre de base , qui donne le résultat requis. Malheureusement, la base <2 ne fonctionne pas, donc les ?:bits supplémentaires gèrent l'entrée n = 1.

L'entrée maximale est de 15, car bash utilise des entiers signés 64 bits (jusqu'à 2 ³¹ -1).

Alice , 13 octets

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

Essayez-le en ligne!

Explication

/o
\i@/...

Il s'agit d'un cadre pour les programmes qui lisent et écrivent des entiers décimaux et fonctionnent entièrement en mode Cardinal (donc les programmes pour la plupart des problèmes arithmétiques).

.    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 standard , 42 octets

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

Essayez-le en ligne!

Explication:

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

Gelée , 3 octets

ẋ⁸P

Essayez-le en ligne!

Comment?

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

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

Essayez-le en ligne!

Pas à pas

S'étend sur un cube de longueur latérale 2

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

• I:1 Prend l'entrée, la duplique et appuie sur 1. Ceci configure la pile avec un compteur, un multiplicateur et un résultat.
• *s; Multiplie le TOS, échange le résultat avec le précédent et supprime le précédent.
• puApportez le contre-objet au TOS. Demi-tour. Il s'agissait d'un changement de voie, mais il fallait raser un octet.
• |($Cela a été fait pour enregistrer un octet. Lorsqu'il est touché, il saute le décrément. réfléchit, décrémente le compteur et ignore le pas d'opération qui entoure le cube.
• !vqWTestez le compteur. Si vous ignorez la redirection, mettez le compteur sur BOS, changez de voie sur le multiplicateur. Sinon, redirigez.
• |sO@il s'agit de la séquence de fin redirigée vers le contre-test. Dépasse le reflet horizontal, échange le TOS apportant le résultat au TOS, sortie et arrêt.

R, 22 octets

lit xde stdin.

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

génère une liste de xcopies de x, puis calcule le produit des éléments de cette liste. Quand x=0, le repretour numeric(0), qui est un vecteur numérique de longueur 0, mais prodqui est 1, donc0^0=1 par cette méthode, qui est cohérente avec l'exponentiation intégrée de R, donc c'est plutôt bien.

Essayez-le en ligne!

Langage machine x86_64 pour Linux, 14 11 10 octets

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

Pour l' essayer en ligne! , compilez et exécutez le programme C suivant.

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

Rubis, 20 18 octets

-2 octets car la spécification a changé et je n'ai plus besoin d'un argument exposant.

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

Essayez-le en ligne!

Empilé , 10 octets

{!1[n*]n*}

Essayez-le en ligne!

Exponentiation à deux arguments pour la même taille:

{%1[x*]y*}

Les deux sont des fonctions. Répète une fonction qui se multiplie 1par le n ntemps.

Scala , 32 26 octets

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

Essayez-le en ligne! (Ajout de la conversion en long dans le TIO afin qu'il ne déborde pas sur n = 10.)

05AB1E , 3 octets

.DP

Essayez-le en ligne! ou Essayez tous les exemples

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

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

Essayez-le en ligne!

• 1 octet enregistré grâce à Laikoni
• Enregistré 2 octets, grâce à nimi

Japt , 4 octets

ÆUÃ×

Essayez-le en ligne!

Explication

Æ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!