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.
Input A1.
=DECIMAL(1&REPT(0,A1),A1
Is base conversion ok? If not, here's one at 26 (but it's really boring):
=PRODUCT(SEQUENCE(A1,1,A1,
s->{int i=0,t=s;for(;++i<s;t*=s);return t;}
Overflows for 10, so all ints need to be changed to long a the cost of +1. This has been done for the TIO link.
I didn't think I could beat the IntStream though!
¿(:;|:)∑*
I said I'd count Keg's victories over 1+ as victories for mawp, so it's 2-1 to mawp!
#import math
(_+)p(_+)_/$1*($1p$2)/p_\b//#input
p#input
I/O as Unary _'s.
Implements exponentiation by repeating the argument itself times. This is done by transforming, for instance ____p__ into ____*(____p_). Decrementing the right, and pulling the left out.
Finally, any instance of p_ has the p removed, as x^1==x.
-lgmp, 82 bytesUses GMP because everyone needs to be able to do 100**100.
#import<gmp.h>
f(x,a,y)int*a;{mpz_init_set_ui(a,y=x);for(;--y;)mpz_mul_ui(a,a,x);}
⁻{×
Wọp
⁻{× # Implicit input
⁻ # Decrement the input
{ # Repeat that many times:
× # Multiply TOS with input
# Implicit output
Wọp # Implicit input
W # Wrap the input in a list
ọ # Repeat it input number of times
p # Product of this list
# Implicit output
:[a|q=q*a}?q
Explanation:
: Get the integer
[a| Start a FOR loop, for x iterations
q=q*a Multiply q (starts out as 1) by our value, then store that in q
} End loop
?q Print q
,$n,$p=$args,1;1..$n|%{$p*=$n};$p
Previous version
,$n,$ofs=$args,'*';''+@($n)*$n|iex
param($a)'1'+"*$a"*$a|iex works too, more in line with the other String->eval answers, nice to see other PowerShell golfers around,
\$\endgroup\$
param($a)"$a*"*$a+1|iex.
\$\endgroup\$
Commented
May 11, 2017 at 16:48
lyX"p
Example values with input 4.
l % Push 1
% STACK: 1
y % Implicit input. Duplicate from below
% STACK: 4, 1, 4
X" % Replicate along two dimensions. Gives a row vector
% STACK: [4, 4, 4, 4]
p % Product of array. Implicitly display.
% STACK: 256
1~YI~X(Y*X~Yi^~i)Yo
Multiplies Y by the input X number of times and then outputs Y.
FYI, the standard way to do this would be
I~XPXo
Where P is the power function
def f(x,i=0):i=i or x;return x*f(x,i-1)if i>1else x
A little bit more verbose than @xnor's clever way of eval, but uses recursion
{a->r=1;a.times{r*=a};r}
readIO
x=i
readIO
a=i
b=1
lbla
a-1
b*x
if a a
printInt b
Try it online! Loops through repeated multiplication.
(({})){({}<(({}))>[()])}{}{{}({}<>)({<({}[()])><>({})<>}{}<><{}>)([][()])}{}
This is an extremely inefficient algorithm, so don't try inputs larger than 7.
Explanation:
#Duplicate the input
(({}))
#Make *n* copies of the input
{({}<(({}))>[()])}{}
#While the stack has more than one element on it,
{{}
#Multiply the top two elements
({}<>)({<({}[()])><>({})<>}{}<><{}>)
#Push stack-height minus one to keep the loop running
([][()])
#Endwhile
}
#Pop a zero off the main stack, implicitly display the number left on the stack
{}
<s></s> like everyone else.
\$\endgroup\$
Commented
May 11, 2017 at 12:11
We have quite a bit of wasted space, so I'm sure we could get rid of a few more bytes.
=|
0*v
ds<
MDL
&_d
id!L
rDM@xp
The bottom half (except for the xp) reads the input, and puts it that many times on the stack, as an integer, i.e. '3' -> [3, 3, 3]. I really need a builtin for that..
The top half calculates the product by swapping the top two elements, checking if the top element is zero, otherwise multiplying the top two elements, and so on. xp prints.
x->IntStream.range(0,x).reduce(1,(a,b)->a*x)
Notes:
This took me a while to figure out in pyth, but I finally got there:
*F*]
]Q # create one-item list (of implicit input)
* Q # repeat (implicit input) times
*F # reduce list over multiplication
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\$