Task - The title pretty much sums it up: raise an integer x to power x, where 0<x.
Restrictions:
exp(), ln(), and any other powers-related language built-ins, like pow(), x^x, x**x is forbidden.Test cases:
Input | Output
---------------
2 | 4
3 | 27
5 | 3125
6 | 46656
10 | 10000000000
This is code-golf, so the shortest program in bytes wins.
For xx, takes x as left argument and x as right argument.
×/⍴⍨
×/ product of
⍴⍨ arg copies arg
And here here is one that handles negative integers too:
×/|⍴|÷1⌊|×⊢
×/ the product of
| absolute value
⍴ repetitions of
| the absolute value
÷ divided by
1⌊ the Lesser of 1 and
| the absolute value
× times
⊢ the argument
The built-in Power primitive is:
x*y
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.
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.
n=>g=(x=n)=>--x?n*g(x):n
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>f=(n,x=n)=>--x?n*f(n,x):n
n=>eval(1+("*"+n).repeat(n))
n=>eval(Array(n).fill(n).join`*`)
🐇 (ECMAScript+(?^*)RME), 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.)
This version uses molecular lookinto, a new feature in 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, 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\$.
🐇 (PCRE2 v10.35+), 26 bytes^(x((?<*(?*^x+|(?2)).)))*$
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).
🐇 (PCRE2 v10.35+ without lookbehind), 59 bytes^(?=(x*)\1(x?))(((?*x+(?!\1)()?|\2+$))x(?(?=\2\1)(?4)))*\1$
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
🐇 (ECMAScript+(?*)RME / 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 - RegexMathEngine
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 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
echo $[$1<2?1:$[$1<2?2:$1]#`printf 1%0$1d`]
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 0s$[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).
fn x=>foldl op*1(List.tabulate(x,fn y=>x))
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 *)
/o
\i@/.&.t&*
/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.
`*^$_
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):
^
_ could do that until I started using p. The documentation was a bit unclear on that.)
\$\endgroup\$
ẋ⁸P
ẋ⁸P - Main link: x e.g. 4
⁸ - link's left argument, x 4
ẋ - repeat left right times [4,4,4,4]
P - product 256
F7 88 50 works as intended.
\$\endgroup\$
..@OI:1*s;pu!vqW|($
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.-2 bytes because the spec changed and I no longer need an exponent argument.
->x{eval [x]*x*?*}
.DP
Try it online! or Try all examples
.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
.D. First time I've seen it used.
\$\endgroup\$
Commented
May 11, 2017 at 19:36
.D can be и for -1 (probably a builtin that wasn't available before?)
\$\endgroup\$
Commented
Sep 25, 2020 at 14:53
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!, 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) );
}
}
f(x)=∏_{n=1}^xx
The ^ is not used for exponentation in this case.
-2 bytes thanks to Aiden Chow.
x can be removed and it will still parse fine, so f(x)=∏_{n=1}^xx.
\$\endgroup\$
Commented
Mar 27, 2023 at 5:42
{!1[n*]n*}
Two-argument exponentiation for the same size:
{%1[x*]y*}
Both are functions. Repeats a function that multiplies 1 by n n times.
n=>List.fill(n)(n).product
Try it online! (Added conversion to long in the TIO so it wouldn't overflow on n=10.)
ÆUÃ×
Æ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
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).
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
<>{{}}<<>()>{}{}
$ ./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.
xõPÑ_=>$
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
|x|(|mut y|{for _ in 1..x{y*=x}y})(x)
This might be able to be shortened once bindings_after_at stabilizes by using |mut y@x| instead.
|x|(1..x).fold(1,|a,_|a*x)
\$\endgroup\$
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.
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.
D, \$5\log_{256}(96)\approx\$ 4.12 bytesZOA*P
Note: the built-in solution would have been just one character: ^ or @ (either would work).
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
integer(selected_int_kind(32))::n
read*,n;print*,product([(n,j=1,n)]);end
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 ns : [(n,j=1,n)], take the product(), and print the result.
0and that the expected output be specified (0or1or either). Finally, having to handle negative integers would be a nice addition to the challenge. \$\endgroup\$1for0^0. However,Foundation+ Swift returns 0 \$\endgroup\$0and instead specified that0<xin the lead-in. I also removed the restriction that code shouldn't throw errors; that should go without saying. Feel free to roll back if necessary. \$\endgroup\$