[Question]
  [
**Task -** The title pretty much sums it up: raise an integer *x* to power *x*, where `0<x`.
**Restrictions:**
* Use of exponentiation, `exp()`, `ln()`, and any other powers-related language built-ins, like `pow()`, `x^x`, `x**x` is forbidden.
* You can assume that the given integer fits the limits of the programming language of your choice.
**Test cases:**
```
Input | Output
---------------
2     | 4
3     | 27
5     | 3125
6     | 46656
10    | 10000000000
```
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest program in bytes wins.
  
[Answer]
# [Python](https://docs.python.org/2/), 25 bytes
```
lambda n:eval('1'+'*n'*n)
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqiQZ5ValpijoW6orq2ulQdEmv/T8osUMhUy8xSKEvPSUzUMDTStuDgLijLzShQyddI0MjX/AwA "Python 2 ‚Äì TIO Nexus")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 4 bytes
For *xx*, takes *x* as left argument and *x* as right argument.
```
√ó/‚ç¥‚ç®
```
[Try all cases online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/wPyy1OLgKzD0/Uf9W551LviP0RIwYgLQhtDaVMobQalDQ0A "APL (Dyalog Unicode) ‚Äì TIO Nexus")
`√ó/`‚ÄÉproduct of
`‚ç¥‚ç®`‚ÄÉarg copies arg
And here here is one that handles negative integers too:
```
√ó/|‚ç¥|√∑1‚åä|√ó‚ä¢
```
[Try all cases!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkGXEBWQACQZfQ/IL88tQjIOjxdv@ZR75aaw9sNH/V01Rye/qhr0X@I7KEVBnWPelccWm9ooP2od7ORIQA "APL (Dyalog Unicode) ‚Äì TIO Nexus")
`√ó/`‚ÄÉthe product of
`|`‚ÄÉabsolute value
`‚ç¥`‚ÄÉ**r**epetitions of
`|`‚ÄÉthe absolute value
`√∑`‚ÄÉdivided by
`1‚åä` the **L**esser of 1 and
`|`‚ÄÉthe absolute value
`√ó`‚ÄÉtimes
`‚ä¢`‚ÄÉthe argument
The built-in Power primitive is:
```
x*y
```
[Answer]
## Mathematica, 16 bytes
I've got two solutions at this byte count:
```
1##&@@#~Table~#&
```
Here, `#~Table~#` creates a list of `n` copies of `n`. Then the `List` head is replaced by `1##&` which multiplies all its arguments together.
```
Nest[n#&,1,n=#]&
```
This simply stores the input in `n` and then multiplies `1` by `n`, `n` times.
[Answer]
# 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!](https://tio.run/nexus/r#@19QlJ@iUZRaoFFho1ucnJinoalToan53/Q/AA)
[Answer]
# JavaScript (ES6), ~~33~~ ~~28~~ ~~25~~ 24 bytes
```
n=>g=(x=n)=>--x?n*g(x):n
```
---
## Try It
```
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>
```
---
[Answer]
# Regex `üêá` (ECMAScript+`(?^*)`[RME](https://github.com/Davidebyzero/RegexMathEngine)), 13 bytes
```
^(x(?^*x+))*$
```
Takes its input in unary, as a string of `x` characters whose length represents the number. Returns its output as the number of ways the regex can match. (The rabbit emoji indicates this output method. It can yield outputs bigger than the input, and is really good at multiplying.)
[Try it on replit.com](https://replit.com/@Davidebyzero/regex-Raise-integer-x-to-power-x-with-lookinto)
This version uses molecular lookinto, a new feature in [RegexMathEngine](https://github.com/Davidebyzero/RegexMathEngine). The basic form `(?^*`...`)` matches the expression inside it against the entire input string. (With a parameter, it evaluates it against the contents of a backreference, e.g. `(?^5*`...`)` to look into `\5`.)
On every iteration of the outer loop, there are \$n\$ possible matching states of the inner loop, and at the end of \$n\$ iterations, the match is complete. In a complete match, each iteration can independently be at any one of \$n\$ states, so there are \$n^n\$ total possible matches.
Changing the `*` at the end to `+` would make it give a result of \$0\$ for \$n=0\$.
```
^           # tail = N = input number
(
    x       # tail -= 1
    (?^*    # Non-atomic lookinto - starts with tail = N
        x+  # Create a choice between N possibilities
    )
)*$         # Loop as many times as possible, minimum 0. This will loop N times,
            # because it subtracts 1 from tail on each iteration. The minimum of
            # 0 iterations gives a correct result of 1 for N==0.
```
The constant-power \$n^k\$ version of this can be seen in [Quartic Summation](https://codegolf.stackexchange.com/questions/156100/quartic-summation/250206#250206), for which there is also a method that doesn't require non-atomic lookaround. It might be impossible to implement \$n^n\$ without non-atomic lookaround, due to it being impossible to create \$m\$ number of choices (with the value \$m\$ being accessed via a backreference) without the guarantee of having \$O(m)\$ avaiable space.
The constant-base \$k^n\$ version of this would be e.g. `^((.+)*)+` or `^(x(||))*$` for \$3^n\$.
# Regex `üêá` (PCRE2 v10.35+), 26 bytes
```
^(x((?<*(?*^x+|(?2)).)))*$
```
[Attempt This Online!](https://ato.pxeger.com/run?1=hVbNbttGED4W0FOMmdbapShXctDUEEULrizABhI7UGQ0jaIQNLmUiFBLglzGP62vfYBeeylQ9JgX6Ju0x75GL539kURbAkpY1P7MfPP3zci_fg7ztCrlx5-H4eep1U7zsGCH7SNr9tf4WcTihDN4PRyPDv3h5enIv7o4n_jfn59OzuCo8SzhYVpFDPpK6WBx3AgXQQF-Pp2BB2Pru5ubj9fPqx_u7t5OFi9uFuSPSsTtoz8_kFtCBn2bDOwPt62fyOCQ0gNKqf2lFvj7i3_pU13LATv3_LzVdWuGS1EkfC4tb86SDE9ZsDzekjtuJFxAjkvhs6LIChJmvBSgvLaXrCyDOaPwYymiXi9ECej3wRzLpTpnPEpdKJioCg5d92ELU-7DLGIOXGdZCpkXB2kpYZUZAzc9_ObFzG0APkkMRCXQnzOD4RsponGIrsDV8OxkfGRTc-lAmdyzLCZrx79endTkMa3KinxIBgMdRJhVAnqwDpTK8CylBsqDHlhPglfKloVa1ntu0XU-YmTPQkeyTkrjoVHxMplzFkGa8bl-Bby8YYWrEra888MgTdENE7vZ-ddpFn4EO3TgU5ZEYEeBCDB3MklyCZ4HRN7YdH-DQQ12q7WuTMdUZhkknCCAcjCfIhFSxklO292Z13F1CJodkIeeRQY9y8VVy8v1l0XJYIifPYrnFSI-P_QFFhV1JfwcFwq6DpTwvBJSXQWGJQS7YKv9MhDhwlex2Ju1RitYWaXC0SVwTeO9OX83UidxXDK8xHgxhLlYPBKws08sFKhlKoENuLK_zJOUEUOKN68nY5qHB6GPzhLqGIx3o_GlPxmNX51fnExGp6vj0dvJ6OJU7veVT-bbeNKhGwbvFUhAk_t6N6i3kauF7m1lw8d9IJgfF9nSzwMhWMFJgSy_uHr50gDUdbB1BbsVmMTVytt1b2DJFgpGsKbgCsKp8dLZxbOnANpUmiyTOki7S92aUMRy8b9CBQurokwyvlNQmY2zAtR0uV8zFydGiiOa6EZOuKO5R90V41V5UIV3MD2ByBKiBFblx_rzrgN5VuK1vsGRH5Fmu2mMyod3ZW5RZs-r87zX4_JwsAMXWkq-BV2KA4N3Nlh61kpznN3o3ZR3W92Zi8NmiZkgpQPN26Z0DBNU4uXMq-mvk5B4XPZg3-NdF1qtpB7xipT3FNApaYQ033MMCVOH0oqfMbG-iuCfn38B_GlJ8EqPEHSsZk33kmzKx-xSxKx3FDqdYEOovw2ncW3KSN0t5zRuvwP7-8bGnme6bjy-HPsXl69OJsMz-khR0a_WXquJIYqKPbHB8FdnS3cz_XF-m4h3THL5PDQ2712NFReMkU182w2tBdZ7Wp-I-hJnxnpg60jwp0P_D_Db7532t3r5Hw "C++ (GCC) - Attempt This Online")
This solution uses non-atomic recursion, lookahead, and lookbehind to emulate non-atomic variable-length lookbehind. The algorithm used is the same as that of the 13 byte version.
```
^                           # tail = N = input number
(
    x                       # tail -= 1
    (                       # Define subroutine (?2)
        (?<*                # Non-atomic lookbehind
            (?*             # Non-atomic lookahead
                ^           # If we've reached tail==0, then:
                x+          # create a choice between N possibilities.
            |
                (?2)        # Otherwise, recursively call (?2).
            )
            .               # tail += 1 (Go back 1 character at a time)
        )
    )
)*$                         # Loop as many times as possible, minimum 0. This
                            # will loop N times, because it subtracts 1 from
                            # tail on each iteration. The minimum of 0 iterations
                            # gives a correct result of 1 for N==0.
```
The equivalent in a hypothetical engine with real (not emulated) non-atomic variable-length lookbehind would be `^(x(?<*^x+.*))*$` (**16 bytes**).
## Regex `üêá` (PCRE2 v10.35+ without lookbehind), 59 bytes
```
^(?=(x*)\1(x?))(((?*x+(?!\1)()?|\2+$))x(?(?=\2\1)(?4)))*\1$
```
[Attempt This Online!](https://ato.pxeger.com/run?1=hVbNbttGED4W0FOsmdTeJalUVNrUEE0Lji3ABhI7UGQ0jaUSNLmUFqGWBLmMZSe-9gF67aVA0WMeKD32NXrp7I8k2hJQwpL2Z-abv2-G_v1LXGR1JT_hNI6_XFntrIhL2m3vW5OvwycJTRmn6M3xcNANjy9OBuHl-dko_OnsZHSK9ltPGI-zOqHoQCk9mx224llUorC4mqAADa2XNzcfrp_XP9_evhvNXtzM8F-1SNv7X_1fcD_AC5uMPbzoE4Ix7tsLB_d3xh7BpP953HWeErLAfZAbd-Vh_3tCiD32nmqIv7_5lzxGt1xkF0FYOJ7fcK0SJeNT6dv6jOVwSqP54YbcYYtxgQpYipCWZV7iOOeVQCoue06rKppSgj5VIun1YpBABwfIHMulOqc8yXxUUlGXHHn-_Qam3Md5Ql10necZyoM0yioJq8wYuKvuDy8mfgvBw1KEVYrDKTUYoZHCGgfrGl0enx4N921iLl1UsTuap3jl-HfLk4Y8JFZZkQ_OUV8HEee1QD20CpTI8CylhpQHPWQ9Cl4pWxZoWWNukVU-UuDXTEeySkrrvlXzik05TVCW86n-inh1Q0tfJWx-G8ZRloEbJnazC6-zPP6A7NhFH3OWIDuJRAS5k0mSSxQECMsbm-yuMYjBdpxVZTqmMvOIcQwAysHiCoiQUY4L0vYmQcfXIWh2oCIOLNzvWT6snKDQPxaw8xg-OwTOa0B83g0FFBV0JfwUFgq6CcR4UQuprgKDEiK7pMv9PBLxLFSx2Ou1RitpVWfC1SXwTWu-PXs_UCdpWlG4hHghhKmYPRCw8480FqBlKgEturQ_L1hGsSHF2zejISniZ3EIzmLiGoz3g-FFOBoMX5-dH40GJ8vjwbvR4PxE7neVT-bXeNIhawbvlEBAk_tmN6hvI9cIPdjIRgj7SNAwLfN5WERC0JLjElh-fvnqlQFo6kDrCroQkMTlKth2b2DxBgpEsKLgEsJt8NLdxrPHANpUxuasCdL2iN8QSmgh_leopHFdViznWwWV2TQvkZoudyvmwsTIYIhj3ciMu5p7xF8yXpUHVHgH0hOJnGElsCw_1J97LiryCq71DbwUErzX3jNG5cM9mVuQ2QmaPO_1uDzsb8FFjpJ3kEdgYPDOGkvPWmmO0xu9u-Ke4018GDZzyASuXLS32JOOQYIquJwEDf1VEljAZQ8eBNzzkeOwZsRLUt4RBE5JI3hvzCEkSB1IK36m2Po2Qf_8-huCVwuDKz1CwLGGNd1LsikfsksRs9lR4DSDhlB_a07D2pSR-BvOadyDDtrdNTZ2AtN1w-HFMDy_eH00Oj4lDxQV_RrttZwYoqzpIxsU3jobuuvpD_PbRLxlksvnvrX-3tZYaUkpXse32dBaYLUnzYmoL2FmrAa2jgReHfp_gD_-7LR_1Mv_AA "C++ (GCC) - Attempt This Online")
This demonstrates this to be possible without the use of lookbehind or recursion. It works by emulating operation on \$n\$ within the space of \$n/2\$, using one of those halves as a counter for the outer loop, and the other half for the inner loop.
(I wrote this version on July 29, and am finally posting it now.)
```
^                         # Anchor to start; tail = N = input number
(?=(x*)\1(x?))            # \1 = floor(N / 2); \2 = N % 2
(
    (                     # Define subroutine (?4):
        (?*
            x+(?!\1)      # Add \1 to possibility count
            ()?           # Double the possibility count of the above
        |
            \2+$          # If \2==1, add 1 to possibility count
        )
    )
    x                     # tail -= 1
    (?(?=\2\1)            # If tail ‚â• \2 + \1:
        (?4)              # Call subroutine (?4), to multiply its possibility
                          # count with the above
    )
)*                        # For every possible iteration count, from 0 to the
                          # maximum, add the above to the possibility count
\1$                       # Assert tail == \1
```
## Regex `üêá` (ECMAScript+`(?*)`[RME](https://github.com/Davidebyzero/RegexMathEngine) / PCRE2 v10.35+), 81 bytes
```
^(?=(x*)\1(x?))((?*x+(?!\1)(|)|\2+$)x((?=\2\1)(?*x+(?!\1)(|)|\2+$)|(?!\2\1)))*\1$
```
[Try it on replit.com](https://replit.com/@Davidebyzero/regex-Raise-integer-x-to-power-x) - RegexMathEngine  
[Attempt This Online!](https://ato.pxeger.com/run?1=hVbLbttGFF0W0FeMmdSeIalUVNDUEE0Lri3ABhI7VWQ0jaUSNDmUBqGGBDmMZdfe9gO67aZA0WU-KF32N7rpnYck2hJQwpJm7uPc96V__xwXWV3JTziN489XVjsr4pJ22_vW5MvwWUJTxil6ezwcdMPji5NBeHl-Ngp_PDsZnaL91jPG46xOKDpQSi9mh614FpUoLK4mKEBD6_ubm4_XL-ufbm_fj2avbmb4r1qk7f0vP_yM-wFe2GTs4UWfEIz79sLB_Z2xR_A9uR93nedkAdRg3JWkLdx7eZdMQuyx91wD__3Vv-SpTctFdhGEheP5DYcrUTI-lR6vaSwHKo3mhxtyhy3GBSrgKEJalnmJ45xXAqlo7TmtqmhKCfqlEkmvF4MEOjhAhiyPik55kvmopKIuOfL8hw1MeY_zhLroOs8zlAdplFUSVpkxcFfdb19N_BaCh6UIq8SHU2owQiOFNQ7Wlbs8Pj0a7tvEMF1UsTuap3jl-DdLSkMeEqusyAfnqK-DiPNaoB5aBUpkeJZSQ8qDHrKeBK-ULQu0rDG3yCofKXTdTEeySkrroVXzik05TVCW86n-inh1Q0tfJWx-G8ZRloEbJnZzC6-zPP6I7NhFn3KWIDuJRAS5k0mSRxQECEuOTXbXGMRgO86qMh1TmXnEOAYA5WBxBY2QUY4L0vYmQcfXIejuQEUcWLjfs3w4OUGhfyxo22P47BCg14D4shsKKCroSvgpHBR0E4jxohZSXQUGJUR2SZf3eSTiWahisddnjVbSqs6Eq0vgm4F9d_ZhoChpWlFgQrwQwlTMHgnY-ScaC9AylYDBXdqfFyyj2DTFu7ejISniF3EIzmLiGowPg-FFOBoM35ydH40GJ0vy4P1ocH4i77vKJ_NrPOmQdQfvlNCAJvfNaVDfRq4RerCRjRDukaBhWubzsIiEoCXHJXT5-eXr1wagqQOjK-hCQBKXp2Ab38DiDRSIYNWCSwi30Zfutj57CqBNZWzOmiBtj_gNoYQW4n-FShrXZcVyvlVQmU3zEqntcrfqXNgYGax2rAeZcVf3HvGXHa_KAyq8A-mJRM6wEliWH-rPPRcVeQVszYFXRYL32nvGqHy4J3MLMjtBs897PS6J_S24yFHyDvIILAzeWWPpXSvNcXqjb1fcc7yJD8tmDpnAlYv2FnvSMUhQBcxJ0NBfJYEFXM7gQcA9HzkOa0a8bMo7gsApaQTvjTmEBKkDadWfKba-TtA_v_6G4NXCgKVXCDjWsKZnSQ7l4-5SjdmcKHCawUCov3VPw9mUkfgbzmncgw7a3TU2dgIzdcPhxTA8v3hzNDo-JY8UVfs1xmu5MURZ0yc2KLx1NnTX2x_2t4l4yyaXz0Nr_b1tsNKSUryOb3OgtcDqTpobUTNhZ6wWto4EXh36f4A__uy0v9PH_wA "C++ (GCC) - Attempt This Online") - PCRE2 v10.40+
This is a port of the 59 byte version. Basic ECMAScript lacks not only lookbehind, but subroutine calls and conditionals as well. The only feature added to basic ECMAScript is `(?*`...`)`, molecular lookahead (a.k.a. non-atomic lookahead). Note that `(|)` must be used instead of `()?` due to ECMAScript's [no-empty-optional](https://github.com/Davidebyzero/RegexMathEngine/issues/1) rule.
(I wrote this version on July 29, and am finally posting it now.)
```
^                         # Anchor to start; tail = N = input number
(?=(x*)\1(x?))            # \1 = floor(N / 2); \2 = N % 2
(
    (?*                   # Define "subroutine":
        x+(?!\1)          # Add \1 to possibility count
        (|)               # Double the possibility count of the above
    |
        \2+$              # If \2==1, add 1 to possibility count
    )
    x                     # tail -= 1
    # Multiply the above possibility count with the following:
    (                     # Emulated conditional, upon whether tail ‚â• \2 + \1
        (?=\2\1)          # If yes:
        # Call "subroutine" (duplicates it, since this regex flavor lacks
        # subroutine calls) to multiply with the above possibility count
        (?*
            x+(?!\1)
            (|)
        |
            \2+$
        )
    |
        (?!\2\1)          # If no: Use possibility multiplier of 1
    )
)*                        # For every possible iteration count, from 0 to the
                          # maximum, add the above to the possibility count
\1$                       # Assert tail == \1
```
[Answer]
# Pure bash, 43
```
echo $[$1<2?1:$[$1<2?2:$1]#`printf 1%0$1d`]
```
[Try it online](https://tio.run/nexus/bash#S8svUihJLS5JTixOVcjMU6g21NMzNK21VkjJ51IAgoKizLySNAUl1RQFXTsFJQUVmGKwbHFqiYKuLkLwf2pyRr6CSrSKoY2RvaEVlGFkpWIYq5wANcpQ1UDFMCUh9n9Kfl7qfwA).
Not sure if this is bending the rules too much - I'm not using any of the listed banned builtins, but I am using base conversion.
* `printf 1%0$1d` outputs a `1` followed by n `0`s
* `$[b#a]` is an arithmetic expansion to treat `a` as a base `b` number, which gives the required result. Unfortunately base <2 does not work, so the extra `?:` bits handle input n=1.
Maximum input is 15, because bash uses signed 64-bit integers (up to 231-1).
[Answer]
# [Standard ML](http://sml-family.org/), 42 bytes
```
fn x=>foldl op*1(List.tabulate(x,fn y=>x))
```
[Try it online!](https://tio.run/nexus/sml-mlton#K0vMUSjIL08tUrD9n5anUGFrl5afk5KjkF@gZajhk1lcoleSmFSak1iSqlGhA1RQaWtXoan531qhoCgzr0RBwzMPqCI/uATIS1fQgJhkpqlp/R8A "Standard ML (MLton) ‚Äì TIO Nexus")
Explanation:
```
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 *)    
```
[Answer]
## [Alice](https://github.com/m-ender/alice), 13 bytes
```
/o
\i@/.&.t&*
```
[Try it online!](https://tio.run/nexus/alice#@6@fzxWT6aCvp6ZXoqb1/78ZAA "Alice ‚Äì TIO Nexus")
### Explanation
```
/o
\i@/...
```
This is a framework for programs that read and write decimal integers and operate entirely in Cardinal mode (so programs for most arithmetic problems).
```
.    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.
```
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), ~~3~~ 2.5 bytes (~~6~~ 5 nibbles)
```
`*^$_
```
[Attempt This Online!](https://staging.ato.pxeger.com/run?1=m708LzMpKSe1eMGCpaUlaboWSxO04lTiIWyo0IKFxhAGAA "Nibbles - Attempt This Online")
Returns the correct answer of \$1\$ for an input of \$0\$, as it is generally accepted that \$0^0=1\$ (even though this challenge doesn't require it, and several of the other answers take advantage of this and return \$0\$, or loop infinitely, for an input of \$0\$).
The ASCII representation uses `^`, but in this context it's a Replicate operator, not exponentiation.
Explanation, shown with example input of 7:
```
`*^$_
    _     # Input coerced to a list: [7]
   $      # Input: 7
  ^       # Replicate: [7, 7, 7, 7, 7, 7, 7]
`*        # Product (returns 1 for an empty list): 823543
```
The builtin is just **0.5 bytes (1 nibble)**:
```
^
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708LzMpKSe1eMGCpaUlaboWC-MgNJS7YKE5hAEA "Nibbles - Attempt This Online")
[Answer]
# [Uiua](https://uiua.org), 4 [bytes](https://www.uiua.org/pad?src=U0JDUyDihpAgK0BcMOKKlwpEZWNvZGUg4oaQIOKHjOKKjy0x4pa9wrEu4o2Y4ouv4oav4oqCwq8x4qe74ouv4qe7LOKHjOKItSjihpjCrzHii68rMjU2KSAtQFwwKzEKJnAg4oqCIjggYml0IGVuY29kaW5nOlx0IiBTQkNTICLih4ziio8tMeKWvcKxLuKNmOKLr-KGr-KKgsKvMeKnu-KLr-Knuyzih4ziiLUo4oaYwq8x4ouvKzI1NikiIOKKgitAXDDih6ExMjkiLiziiLY74oiYwqzCscKv4oy14oia4peL4oyK4oyI4oGFPeKJoDziiaQ-4omlKy3Dl8O34pe_4oG_4oKZ4oan4oal4oig4qe74paz4oeh4oqi4oeM4pmt4ouv4o2J4o2P4o2W4oqa4oqb4oqd4pah4oqU4omF4oqf4oqC4oqP4oqh4oav4oaZ4oaY4oa74per4pa94oyV4oiK4oqXL-KIp1xc4oi14omh4oi64oqe4oqg4o2l4oqV4oqc4oip4oqT4oqD4oqZ4ouF4o2Y4o2c4o2a4qyaJz_ijaPijaQh4o6L4oas4pqCzrfPgM-E4oiefl9bXXt9KCnCr0AkXCLihpB8IyIKJnAg4oqCImRlY29kZWQ6XHQiIERlY29kZSAiwqPCsS0xwrjChy7DjMKlwrPCsMKIMcKfwqXCnyzCo8K_KMK1wogxwqUrMjU2KSIg4oqCK0BcMOKHoTEyOSIuLOKItjviiJjCrMKxwq_ijLXiiJril4vijIrijIjigYU94omgPOKJpD7iiaUrLcOXw7fil7_igb_igpnihqfihqXiiKDip7vilrPih6HiiqLih4zima3ii6_ijYnijY_ijZbiipriipviip3ilqHiipTiiYXiip_iioLiio_iiqHihq_ihpnihpjihrvil6vilr3ijJXiiIriipcv4oinXFziiLXiiaHiiLriip7iiqDijaXiipXiipziiKniipPiioPiipnii4XijZjijZzijZrirJonP-KNo-KNpCHijovihqzimoLOt8-Az4TiiJ5-X1tde30oKcKvQCRcIuKGkHwjIg==)
```
/√ó‚ñΩ.
```
[Try it!](https://uiua.org/pad?src=f%20%E2%86%90%20%2F%C3%97%E2%96%BD.%0A%0Af%203%0Af%204%0Af%205%0Af%206)
```
  ‚ñΩ.  # list of N Ns
/√ó    # product
```
Note: can also do /√ó‚ÜØ.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
·∫ã‚Å∏P
```
**[Try it online!](https://tio.run/nexus/jelly#@/9wV/ejxh0B////NwUA "Jelly ‚Äì TIO Nexus")**
### 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
```
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 19 bytes
```
..@OI:1*s;pu!vqW|($
```
[Try it online!](https://tio.run/nexus/cubix#@6@n5@DvaWWoVWxdUKpYVhheo6Hy/7@hAQA "Cubix ‚Äì TIO Nexus")
[Step by Step](https://ethproductions.github.io/cubix/?code=ICAgIC4gLgogICAgQCBPCkkgOiAxICogcyA7IHAgdQohIHYgcSBXIHwgKCAkIC4KICAgIC4gLgogICAgLiAuCg==&input=Mwo=&speed=20)
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.
[Answer]
# 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!](https://tio.run/nexus/ruby#S7ON@a9rV1GdWpaYoxBdEatVoWWvVfu/oLSkWCEtOj21pFivJD8@M/a/CQA "Ruby ‚Äì TIO Nexus")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 3 bytes
```
.DP
```
[Try it online!](https://tio.run/nexus/05ab1e#@6/nEvD/vxkA "05AB1E ‚Äì TIO Nexus") or [Try all examples](https://tio.run/nexus/05ab1e#K6us/K/nEvBf53@0kY6xjqmOmY6hQSwA "05AB1E ‚Äì TIO Nexus")
```
.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
```
[Answer]
# 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!](https://tio.run/##FYrNDoIwEITvfYpJE5JdwQP@YpAncT2Q1UoPFoMcmhievZbDl28yM7p9qaakY/jO0KGfMNzunZV46qWWeGwkNheJbuUs8ekyu5xVou5ta4wPM969D8Q/A7hxIqyVR4e6zbrikFWWYKwH4DPl3RFs8UDxkGAr@ApEuaUNE/PA5Bnc5vdiFpPSHw "C (gcc) ‚Äì 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) );
  }
}
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 2 bytes
```
·∫ãŒ†
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLhuovOoCIsIiIsIjYiXQ==)
[Answer]
# [Desmos](https://www.desmos.com), ~~19~~ 17 bytes
```
f(x)=‚àè_{n=1}^xx
```
[Try it on Desmos!](https://www.desmos.com/calculator/qqjpk4olhz)
The `^` is not used for exponentation in this case.  
-2 bytes thanks to [Aiden Chow](https://codegolf.stackexchange.com/users/96039/aiden-chow).
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 10 bytes
```
{!1[n*]n*}
```
[Try it online!](https://tio.run/nexus/stacked#@1@taBidpxWbp1X7X4lLw0jBWMFUwUzB0ECTK0ZBUSG/tOQ/AA "Stacked ‚Äì TIO Nexus")
Two-argument exponentiation for the same size:
```
{%1[x*]y*}
```
Both are functions. Repeats a function that multiplies `1` by `n` `n` times.
[Answer]
# [Scala](http://www.scala-lang.org/), ~~32~~ 26 bytes
```
n=>List.fill(n)(n).product
```
[Try it online!](https://tio.run/nexus/scala#HYxBCsIwEEWvMstkM@hWacGlUFceQGI60ZE4E5KpCOLZa@3y8977en1QNDgFFqC3kYwNDqXAB14hQ9rBUQy6HgaVG3QwS9cP3AwT5@zEO0HTP/NYqo5TtHm/ls4vNiuedaqRsNnIgjeygYUaPkNxl6Vczv06kseklUK8u1JZLIuH77zd/AA "Scala ‚Äì TIO Nexus") (Added conversion to long in the TIO so it wouldn't overflow on n=10.)
[Answer]
# [Haskell](https://www.haskell.org/), ~~24~~ ~~23~~ 21 bytes
```
f y=product$y<$[1..y]
```
[Try it online!](https://tio.run/nexus/haskell#y03MzFOwVcjMK0ktSkwuUVBRKM7IL1fQU8hNLFBIA9JFqYkp/9MUKm0LivJTSpNLVCptVKIN9fQqY///jzbUMdIx1jHRMdUx0zE0iAUA "Haskell ‚Äì TIO Nexus")
* Saved 1 byte, thanks to [Laikoni](https://codegolf.stackexchange.com/users/56433/laikoni)
* Saved 2 bytes, thanks to [nimi](https://codegolf.stackexchange.com/users/34531/nimi)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 4 bytes
```
√ÜU√É√ó
```
[Try it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=xlXD1w==&input=Ng==)
## 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
```
[Answer]
# 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
```
[Answer]
# [Flurry](https://github.com/Reconcyl/flurry), 16 bytes
```
<>{{}}<<>()>{}{}
```
### Run example
```
$ ./flurry -nin -c "<>{{}}<<>()>{}{}" 4
256
$ ./flurry -nin -c "<>{{}}<<>()>{}{}" 5
3125
```
Multiply `n` `n` times to 1. The lambda expression is `n (\x. \y. n (x y)) I` where `\y. n (x y)` or `n ‚àò x` is the product of Church numeral of `n` and `x`, and its SKIB-transformation is as follows:
```
n (\x. \y. n (x y)) I
S I (\n. \x. \y. n (x y)) n I
S I (\n. \x. S (K n) x) n I
S I (\n. S (K n)) n I
S I (S ‚àò K) n I
```
So the direct translation of this expression into Flurry gives the code above.
Expanding the `S` in front gives `n ((S ‚àò K) n) I`, which does not change bytes:
```
({})[<<>()>{}]{}
```
If direct exponentiation is allowed, it is **6 bytes**: `({}){}` (pop n, push n, pop n; evaluates to `n n`), because `n m` evaluates to `m^n` when `n` and `m` are Church numerals.
[Answer]
# [Arn](https://github.com/ZippyMagician/Arn), [8 bytes](https://github.com/ZippyMagician/Arn/wiki/Carn)
```
x√µP√ë_=>$
```
# Explained
Unpacked: `*v{_}\1=>`
```
    \        Fold...
*            ...with multiplication after...
v{           ...mapping with key of v...
  _          ...by replacing with input
}            End map
      1      Literal one
        =>   inclusive range to...
          _  ...input, implied
```
[Answer]
# [Rust](https://www.rust-lang.org/), 37 bytes
```
|x|(|mut y|{for _ in 1..x{y*=x}y})(x)
```
[Try it online](https://tio.run/##Xc3BDoIwDIDh@56icuqMEgaBGFSOvIbxwCKJDDNGHNn27HO7LIZbmy/9K9dFeS5geo4CKRgCoIZFobfaop1WBZs1fJbwgFEAy3NttuNdu81R1NQD0CtxhIRCPLv1HfIWekq@r0EOIdaHTeDKyguFcwdxIPHJR45CvcUBs7IF47ITcCxpiP1TlajaU52o3lOTqNkTK5KxIqLzPw)
This might be able to be shortened once [bindings\_after\_at](https://github.com/rust-lang/rust/issues/65490) stabilizes by using `|mut y@x|` instead.
[Answer]
# [Perl 5](https://www.perl.org/) + `-p`, 17 bytes
```
$_=eval"$_*"x$_.1
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3ja1LDFHSSVeS6lCJV7P8P9/Iy5jLlMuMy5Dg3/5BSWZ@XnF/3ULcgA "Perl 5 ‚Äì Try It Online")
[Answer]
# [1+](https://esolangs.org/wiki/1%2B), ~~29~~ ~~27~~ ~~25~~ 24 bytes
```
1."1##/"\*\1+\"/^"/<1+#:
```
This was already shockingly short, given how messy it is to create a halting loop... I did a poor job on stack manipulation, so it can probably be improved.
## Special notes on 25 -> 24
> 
> **Remember that you're programming in brainfuck.** It's tempting to avoid confusion and tedium by thinking in terms of higher-level abstractions as much as possible, rather than thinking in brainfuck. This can buy enough control to make a working program, usually at the cost of such inefficiencies as:
> -excessive pointer movement, sometimes as simple as ">+<->" and sometimes less apparent; often a result of doing things in an intuitively appealing order. -- Daniel B. Cristofani
> 
> 
> 
This applies to 1+ as well. I designed this program with pseudo-code, which results in two consecutive `/`s - cuz there are only three elements on the stack, replacing it with `\` saves one byte.
[Answer]
# [Thunno](https://github.com/Thunno/Thunno) `D`, \$5\log\_{256}(96)\approx\$ 4.12 bytes
```
ZOA*P
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_abSSi1LsgqWlJWm6Fkuj_B21AiBsqNCChaYQBgA)
Note: the built-in solution would have been just one character: `^` or `@` (either would work).
#### Explanation
```
ZOA*P # Implicit input
ZO    # Wrap the input in a list
  A*  # Repeat it input times
    P # Take the product of this list
      # Implicit output 
```
[Answer]
# [Fortran (GFortran)](https://gcc.gnu.org/fortran/), 73 bytes
```
integer(selected_int_kind(32))::n
read*,n;print*,product([(n,j=1,n)]);end
```
[Try it online!](https://tio.run/##LYpLDkBAEAX3bmHXIyPx2REnERHRbfzySBvnHxJ2laqaDvU6IHXTByEs8OJE6ZJdRi/cv6LfFjCVhTFVhUhl4MSiPvVNiT314Hv01BLs2uQWpjO1gEP8D/PthPC5PHsA "Fortran (GFortran) ‚Äì Try It Online").
Uses a larger integer type because the implicit integer type overflows doing `10**10`. This solution can compute results up to `170141183460469231731687303715884105727`.  
We make an inline anonymous array of `n`s : `[(n,j=1,n)]`, take the `product()`, and `print` the result.
]