Related: Calculate Power Series Coefficients
Given a positive integer \$X\$ and a max exponent (Also a positive integer too) \$N\$ calculate the result of a power series. Example:
$$X^0+X^1+X^2+\cdots +X^N$$
Test Cases
1 2 => 3
2 3 => 15
3 4 => 121
2 19 => 1048575
Standard code-golf rules apply.
ÝmO
Explanation:
Input: 4, 3
Ý [0..input] - [0, 1, 2, 3, 4]
m Vectorized exponent - [1, 3, 9, 27, 81]
O Sum - 121
The straightforward approach:
x#n=sum$map(x^)[0..n]
For the case \$ x \neq 1 \$ we alternatively could use following function with the same length:
x#n=div(x*x^n-1)$x-1
This uses the fact that
\$ 1 + x + x^2 + \ldots + x^n = \frac{x^{n+1} -1}{x-1} \forall x \neq 1.\$
x#0=1;x#n=x^n+x#(n-1).
\$\endgroup\$
Saved 1 byte thanks to @tsh
x=>g=n=>~n&&x*g(n-1)+1
Using the direct formula mentioned by @flawr:
x=>n=>~-(x**++n)/~-x||n
*ⱮS‘
\$\endgroup\$
Commented
Jul 30, 2018 at 21:09
*...)
\$\endgroup\$
Commented
Jul 30, 2018 at 21:27
lambda x,n:sum(x**k for k in range(n+1))
lambda x,n:sum(map(x.__pow__,range(n+1))) is cool too but it's 1 byte longer lol.
t⟦R&h;Rz^ᵐ+
Nothing particularly interesting, construct the range 0 to n, raise x to the power of each number in it.
And since I wanted to learn how ᵃccumulate works, here's a slightly longer version that uses that:
,1↺⟨t×{bh}⟩ᵃ⁾k+
Form array [1, x], and do this n times, accumulating the results into that array after each iteration: multiply the last element of the array, by the second element of the array (i.e. x). Since this calculates [1, x, x^2, ... x^n, x^(n+1)], knife off the last value and add the rest of them up as the output.
I~xI(ax!i^+~ai)aP
I~x - Store the input in the variable x
I( ) - Loop until the top of the stack equals the input n
a - Push a
x - Push x
!i - Increment i
^ - Calculate the value of x^i
+~a - Add x^i to a and store in a
i - Push i
aP - Print the value of a
-1 Thanks to tsh (f(x,n-1)+x**n -> f(x,n-1)*x+1)
Port of Arnauld's Javascript answer - not sure if it is the first, so do shout if you know who deserves the credit!
f=lambda x,n:~n and f(x,n-1)+x**n
A recursive function which sums the terms right-to-left, with a base case of zero when n reaches -1 (since ~(-1) is -1 - (-1) which is 0 which is falsey).
My previous 35 byter:
lambda x,n:x^1and~-x**-~n/~-x or-~n
The ^ operator is bitwise-xor, so x^1 is zero when x is one and non-zero otherwise.
In Python non-zeros are truthy, so the right of the logical and is executed when x is not one, but not executed when x is one, whereupon the right of the logical or is executed instead.
So, when x is one we execute
-~n which is equivalent to
-1 * ~n which is equivalent to
-1 * (-1 - n) which is equivalent to
1 + n...
...and when x is not one we execute
~-x**-~n/~-x which, adding parentheses to signify precedence, is
(~-(x**(-~n)))/(~-x) which is equivalent to
(-1 - -1 * (x ** (-1 * (-1 - n))))/(-1 - -x) which is equivalent to
((x ** (n + 1)) - 1)/(x - 1)
+x**n -> *x+1 save 1 byte.
\$\endgroup\$
param($x,$n)0..$n|%{$o+=[math]::pow($x,$_)};$o
Not bad for needing a .NET call for pow.
-7 bytes thanks to mazzy.
param($x,$n)$s=0;0..$n|%{$s+=[math]::pow($x,$_)};$s is shorter. I don't sure about $s=0;: this expression is needed on a second run. Perhaps, it better to append ;rv s to the end.
\$\endgroup\$
param($x,$n,$s)0..$n|%{$s+=[math]::pow($x,$_)};$s. A caller still sends 2 parameters.
\$\endgroup\$
$s if it's run as a full program (e.g., how it's done on Try It Online), so that saves a few more bytes.
\$\endgroup\$
Commented
Aug 1, 2018 at 12:33
$0;A^$
Implicit inputs: A and n
$0 Zero indexing
; Output sum of first n terms in sequence
A^$ Each term is A to the power of the current index
if x<2.
\$\endgroup\$
Commented
Jul 31, 2018 at 2:02
@(x,n)sum(x.^(0:n))
Just learnt Octave 15 minutes ago for this challenge... Hoping it is already optimized.
#.1$~>:
#.1$~>: Left argument = X, Right argument = N
1$~>: Generate a list of N+1 ones
#. Interpret as base X digits and convert to single integer
>: instead of 1+] 7 bytes
\$\endgroup\$
Commented
Jul 31, 2018 at 6:27
{sum $^a X**0..$^b}
{ } # Anonymous code block
sum # Get the sum of
X** # The cross product with the meta operator exponential
$^a # With the first parameter
0..$^b # And the range of 0 to the second parameter
l~),f#:+
Try it online! Or verify all test cases.
l e# Read a line from STDIN
~ e# Evaluate: pushes x, then n
) e# Add 1 to n
, e# Range: gives [0 1 ... n]
f# e# Map with extra parameter: gives [x^0 x^1 ... x^n]
:+ e# Fold addition over array: gives x^0 + x^1 + ... + x^n
e# Implicit display in STDOUT
r is redundant, so f=lambda x,n:n>=0and x**n+f(x,n-1) is 34, although golfing that with n>=0 -> ~n we get my port of 33 bytes.
\$\endgroup\$
Commented
Jul 30, 2018 at 22:24
x->n->x>1?~-(int)Math.pow(x,n+1)/~-x:n+1
Uses the approach mentioned by @flawr.
Explanation:
x->n-> // Method with two integer parameters and integer return-type
x>1? // If `x` is larger than 1:
~-(int)Math.pow(x,n+1) // Return `x` to the power of `n+1` - 1
/~-x // integer-divided by `x-1`
: // Else:
n+1 // Return `n+1` as result instead
Throws errors, but still works I guess.
f(_,0,1).
f(X,N,Y):-M is N-1,f(X,M,Z),Y is Z+X^N.
Your usual, everyday recursive solution.
f(b,e,t,i){for(t=1,i=e;i--;t*=b);t=e--?t+f(b,e):1;}
f(x,n,v){for(v=1;n--;v=v*x+1);x=v;}
\$\endgroup\$
f(b,e){b=e?pow(b,e--)+f(b,e):1;}
\$\endgroup\$
Commented
Jul 31, 2018 at 14:27
n*n-1rather thann. Since my vote hammers, I'll wait for others to say if this is dupe-worthy. \$\endgroup\$0to be neither positive nor negative. A couple of places (like France) don't consider positive to mean strictly positive, and treat0as both positive and negative. \$\endgroup\$