Aufgabe - Der Titel bringt es auf den Punkt: Erhöhe eine ganze Zahl x , um x zu setzen , wo 0<x.

Beschränkungen:

• Verwenden von Potenzierung exp(), ln()und alle anderen Kräfte bezogene Sprache Einbauten, wie pow(), x^x, x**xist verboten.
• Sie können davon ausgehen, dass die angegebene Ganzzahl den Grenzen der Programmiersprache Ihrer Wahl entspricht.

Testfälle:

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

Das ist Code-Golf , also gewinnt das kürzeste Programm in Bytes.

APL (Dyalog) , 4 Bytes

Für x ^x wird x als linkes Argument und x als rechtes Argument verwendet.

×/⍴⍨

Probieren Sie alle Fälle online aus!

×/ Produkt von

⍴⍨ arg kopiert arg

Und hier ist eine, die auch negative ganze Zahlen behandelt:

×/|⍴|*×

Versuche alle Fälle!

×/ das Produkt von

| Absolutwert

⍴ r epetitions von

| der absolute Wert

* hoch

× das signum

Das eingebaute Power-Grundelement ist:

x*y

Python , 25 Bytes

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

Probieren Sie es online!

Mathematica, 16 Bytes

Bei dieser Anzahl von Bytes habe ich zwei Lösungen:

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

Hier #~Table~#wird eine Liste von nKopien von erstellt n. Dann wird der ListKopf ersetzt, 1##&wodurch alle Argumente miteinander multipliziert werden.

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

Dieser speichert einfach die Eingabe in nund dann vervielfacht 1durch n, nmal.

JavaScript (ES6), 33 28 25 24 Byte

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

Versuch es

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>

Geschichte

25 Bytes

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

28 Bytes

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

33 Bytes

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

Pure Bash, 43

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

Probieren Sie es online aus .

Ich bin mir nicht sicher, ob dies die Regeln zu sehr verbiegt - ich verwende keines der aufgelisteten verbotenen Buildins, aber ich verwende die Basiskonvertierung.

• printf 1%0$1dgibt a 1gefolgt von n 0s aus
• $[b#a]ist eine arithmetische Erweiterung, die aals Basiszahl zu behandeln ist und bdas erforderliche Ergebnis liefert. Leider funktioniert base <2 nicht, daher behandeln die zusätzlichen ?:Bits den Eingang n = 1.

Die maximale Eingabe beträgt 15, da in der Bash vorzeichenbehaftete 64-Bit-Ganzzahlen (bis zu 2 ³¹ -1) verwendet werden.

Alice , 13 Bytes

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

Probieren Sie es online!

Erläuterung

/o
\i@/...

Dies ist ein Framework für Programme, die Dezimalzahlen lesen und schreiben und vollständig im Kardinalmodus arbeiten (also Programme für die meisten arithmetischen Probleme).

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

Standard ML , 42 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Gelee , 3 Bytes

ẋ⁸P

Probieren Sie es online!

Wie?

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

Probieren Sie es online!

Schritt für Schritt

Erweitert sich auf einen Würfel mit Seitenlänge 2

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

• I:1 Nimmt die Eingabe, dupliziert sie und drückt 1. Dies richtet den Stapel mit einem Zähler, Multiplikator und Ergebnis ein.
• *s; Multipliziert die TOS, tauscht das Ergebnis mit der vorherigen und entfernt die vorherige.
• puBring das Gegenstück zum TOS. Wende. Dies war früher ein Spurwechsel, musste aber ein Byte rasieren.
• |($Dies wurde durchgeführt, um ein Byte zu speichern. Bei einem Treffer wird die Dekrementierung übersprungen. reflektiert, dekrementiert den Zähler und überspringt den No-Op-Wrapping um den Würfel.
• !vqWTesten Sie den Zähler. Wenn dies der Fall ist, überspringen Sie die Umleitung, setzen Sie den Zähler auf BOS und wechseln Sie die Spur zurück auf den Multiplikator. Ansonsten umleiten.
• |sO@Dies ist die Endsequenz, die vom Zählertest weitergeleitet wird. Geht an der horizontalen Spiegelung vorbei, tauscht die TOS aus und bringt das Ergebnis zur TOS, Ausgabe und Halt.

R, 22 Bytes

liest xaus stdin.

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

generiert eine Liste von xKopien von xund berechnet dann das Produkt der Elemente dieser Liste. Wenn x=0, gibt das repzurück numeric(0), was ein numerischer Längenvektor ist 0, aber der prodvon diesem ist 1, also 0^0=1mit dieser Methode, die mit Rs eingebauter Exponentiation konsistent ist, ist das ziemlich ordentlich.

Probieren Sie es online!

x86_64-Maschinensprache für 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

Um es online auszuprobieren! , kompilieren Sie das folgende C-Programm und führen Sie es aus.

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 bis 18 Bytes

-2 Bytes, weil sich die Spezifikation geändert hat und ich kein Exponentenargument mehr benötige.

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

Probieren Sie es online!

Gestapelt , 10 Bytes

{!1[n*]n*}

Probieren Sie es online!

Potenzierung mit zwei Argumenten für dieselbe Größe:

{%1[x*]y*}

Beides sind Funktionen. Wiederholt eine Funktion, die mit 1der n nZeit multipliziert wird .

Scala , 32 26 Bytes

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

Probieren Sie es online! (Konvertierung zu lang im TIO hinzugefügt, damit es bei n = 10 nicht überläuft.)

05AB1E , 3 Bytes

.DP

Probieren Sie es online! oder Probieren Sie alle Beispiele aus

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

Probieren Sie es online!

• 1 Byte gespeichert, danke an Laikoni
• 2 Bytes gespart, dank nimi

Japt , 4 Bytes

ÆUÃ×

Probieren Sie es online!

Erläuterung

Æ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-Maschinencode (Linux), 18 Byte

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

Es erwartet eine C-Deklaration wie folgt extern int XpowX(int).

Zerlegt

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Erläuterung

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 $_wird zu einer Liste von $_Kopien von ausgewertet $_( $_als Argument für die anonyme Funktion) und [*]diese Liste dann durch Multiplikation reduziert.

CJam , 6 Bytes

ri_m*,

Probieren Sie es 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)}

Probieren Sie es online!

Es handelt sich um eine anonyme Funktion, deren Eingabe vom Stream stammt.

Erläuterung:

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

Funktioniert aufgrund der 32-Bit-Arithmetik nur für einstellige Eingaben.

Brainf * ck , 148 Bytes

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

Probieren Sie es online!

Keine eingebauten;)

Wie es funktioniert

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

Kurz gesagt, dies funktioniert durch Multiplizieren x(der Eingabe) mit sich selbst x. (auch bekannt als iterating iterated addition). Das Nettoergebnis ist x ^ x.

I / O

Das Programm nimmt eine einzelne ASCII-Eingabe und verarbeitet sie als ASCII-Index minus 48 . Das Minus 48 dient zum Normalisieren der Eingaben von tatsächlichen Zahlen ( 4wird zu 52-> 52-48-> 4). Verwenden Sie zur Eingabe einer höheren Zahl als 9 das nächste entsprechende ASCII-Zeichen ( :-> 58-48-> 10). Das Programm wird auf ähnliche Weise ausgegeben.

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!