# Sigmafy the expression

For those who didn't know, Sigma is a Greek letter which is heavily used in mathematics as the summation sign. Given a string representing an expression depending on $k$ that we will denote $E(k)$, compute the sum of the results for $E(k)$, for each $k\in\{1,2,3,4,5\}$. Concisely, you should find $S$ such that:

$$S=\sum^5_{k=1}E(k)$$

An example of an expression: $E(k)=\frac k 2 + k^2$

### Specs

• You are guaranteed:
• that the expression is valid, so it contains no errors, and that it's dependent of the syntax chosen (e.g: if you only support 2*k, there will be no 2k)
• to only have defined values amongst your results, so no values like 1/0, inf or nan will appear
• You can assume that the expression above is fitting the limits of the programming language of your choice, so it won't result in overflows or any other limit-related errors
• Any other non-whitespace ASCII Character instead of k can be chosen
• Your program must support the following operations:
• addition (+, plus(),add(),sum())
• subtraction (-, minus(), subtract())
• exponentiation (**,^,pow() or others, should be specified), with support to negative bases and exponents
• square root in the form of sqrt(k), k^0.5, k**0.5, or however else you wish
• multiplication and division
• The submission can either be a full program or a function, while mentioning its usage
• Any trailing / leading whitespace is allowed when outputting
• Minimum precision: 2 decimal places

### Test Cases (with k)

+---------------+--------------+
|  Input = E(k) |    Output    |
|---------------+--------------|
|2*k            | 30           |
|---------------+--------------|
|sqrt(k)        | 8.38         | (* with minimum decimal precision)
|---------------+--------------|
|k+k/2+k**2     | 77.5         |
|---------------+--------------|
|k**2           | 55           |
+---------------+--------------+


The score will be the number of bytes (of the source + compiler flags). The lowest scoring valid submission wins, while taking note that these loopholes are strictly forbidden. Here is a Python pseudo-code, to make things clearer.

• Can we take plus() instead of +? (Same questions for all other operators too) – Stewie Griffin May 13 '17 at 11:08
• @StewieGriffin Yes, plus(),add(),sum() and equivalents are allowed. See the edit. – Mr. Xcoder May 13 '17 at 11:08
• No, you may only take the expression once, @ComradeSparklePony – Mr. Xcoder May 13 '17 at 11:21
• Can we use postfix notation? For example, test case 3 from the top would be something like: N N2/+N2**+. – Comrade SparklePony May 13 '17 at 11:33
• That's very strange, but it is allowed as long as you clearly state the "format" of E(x) @ComradeSparklePony – Mr. Xcoder May 13 '17 at 11:35

# Jelly, 5 bytes

vÐ€5S


Try it online!

Input a valid Jelly monadic chain (I golfed them down in my link).

## How it works

vÐ€5S
Ð€     for each of ...
5        5 (implicitly converted to [1,2,3,4,5]), ...
v           evaluate the input with the above as argument
S   and find the sum


## Mathematica, 1714 13 bytes

Thanks to Ian Miller for saving 3 bytes.

Thanks to LegionMammal978 for saving 1 byte.

#~NSum~{k,5}&


The input should be an actual expression containing k, e.g.:

#~NSum~{k,5}&[Sqrt[k]^3+4]

• I should have guessed that Mathematica had built-ins for this – Mr. Xcoder May 13 '17 at 11:11
• Mathematica always has built-ins for situations. :P – totallyhuman May 13 '17 at 13:19
• You don't need the 1, in it for Sum. – Ian Miller May 13 '17 at 13:24
• In fact it can shorten to N@#~Sum~{k,5}& – Ian Miller May 13 '17 at 13:25
• @IanMiller Oh right, of course. Thank you! – Martin Ender May 13 '17 at 13:49

# Python 3, 40 37 bytes

3 bytes thanks to Arnauld.

Eval scope tricks \o/

f=lambda s,k=5:k and eval(s)+f(s,k-1)


Try it online!

Uses k**0.5 instead of sqrt(k).

• Is it allowed to answer a question that fast? o_O – Mr. Xcoder May 13 '17 at 11:11

## JavaScript (ES7), 31 30 bytes

Uses k**0.5 for sqrt(k).

f=(e,k=6)=>--k&&f(e,k)+eval(e)

console.log(f("2*k"))
console.log(f("k**0.5"))
console.log(f("k+k/2+k**2"))
console.log(f("k**2"))

Try it online!

• Ninjaed again! Nicely done. – Shaggy May 13 '17 at 11:23

# 05AB1E, 87 6 bytes

6G¹.VO


Try it online!

Input is in postfix notation, and uses the variable N. 05AB1E is a stack-based language, so only postfix notation works.

Format of E(N): write the number(s) you want to do the operation with, and then write the sign of the operation. For example, 3+4 would be 3 4+, 3*4+2*3 would be 3 4* 2 3* +. Also note that this uses t instead of sqrt, and m instead of **, so sqrt(N) would be Nt.

Explanation:

6G¹.VO
6G     For N in range(1,6). This includes [1,2,3,4,5].
O Sum results.


# Octave, 504631 29 bytes

@(d)eval(["k=1:5;sum(" d 41])


Try it online!

Exponentiation is denoted with the caret .^ and multiplication is denoted with .*.

This declares an anonymous function that takes in argument d. It sets k to be equal to the range 1:5 and sums the evaluated d and returns it.

# Japt, 10 bytes

6ÆK=XOxUÃx


Input string should have variable as an uppercase K. sqrt(K) should be inputted as K**0.5.

Try it online!

## Explanation

eval scope didn't work in my favor; had to redefine the counting variable X as a global K.

6ÆK=XOxUÃx      // implicit: U = input string
6oXYZ{K=XOxU} x // expanded

6oXYZ{      }   // create array [0, 6) and map to function:
K=X       //   redefine the array value to global K
OxU    //   eval the input string
x // sum the resulting array

• Hmm, I wonder if transpiling Ox directly to eval( would help with that... – ETHproductions Jul 8 '17 at 11:32

# Octave, 25 23 bytes

@(f)sum(inline(f)(1:5))


Try it online!

Exponentiation is denoted as .^

# APL (Dyalog), 9 bytes

+/⍎⎕⊣k←⍳5


Try it online!

Addition is +, subtraction is -, multiplication is ×, division is ÷ exponentiation is * and execution is right to left, so use () to group expressions.

Input is in terms of k.

### Explanation

k←⍳5                    Set k to be equal to the vector 1 2 3 4 5
⊣                       The left argument:
+/                      Sum of
⍎⎕                      The evaluated input (the eval returns an array because k is an array)


And here's a solution that takes trains as input (like the Jelly answer): +/(⍎⎕)¨⍳5.

# Common Lisp, 55 bytes

(defun f(x)#.(read))(print(+(f 1)(f 2)(f 3)(f 4)(f 5)))


Try it online

Example input - output:
(* x 2) - 30
(sqrt x) - 8.382333
(+ (/ x 2) x (expt x 2)) - 155/2
(expt x 2) - 55


different, longer (58 bytes) version - starts getting shorter if you do sumation from 1 to 7.

(print #.(+,@(mapcar #'(lambda(x)#.(read))'(1 2 3 4 5))))


yet another and longer method (65 64 bytes) - doesn't define function - just inserts your expression into a loop. Should get shorter for bigger sums.

(setf a(read)b 0)(loop as x from 1 to 5 do(incf b #.a))(print b)


# Swift, 202 184 bytes

import Foundation;func s(i:String){print([1,2,3,4,5].map{NSExpression(format:i.replacingOccurrences(of:"k",with:"\($0).0")).expressionValue(with:nil,context:nil)as!Float}.reduce(0,+))}  For some reason this will only run locally :(. Here is an explanation of what I am doing: import Foundation // Import the Foundation module func s(i:String){ // Create a function that takes in a String and returns a Float print( // Print the result of the follow algorithm to strdout [1,2,3,4,5].map{ //Conduct the follow code on numbers 1 - 5 NSExpression(format: // Create an expression with the following String and return it i.replacingOccurrences(of:"k",with:"\($0).0")) // Create a string replacing all ocurrances of 'k' in i with the current Float from the map

.expressionValue(with:nil,context:nil)as!Float // Get the resulting value of the expression

}.reduce(0,+) // Add the result of all the expressions together
)
}


Thanks to @Mr. Xcoder for saving 15 bytes!

# TI-Basic, 12 bytes

Σ(expr(Ans),K,1,5


Call with "string":prgmNAME, where string is any valid TI-Basic expression of K.

• Interesting solution of the same length: Ans->u:sum(u(1,5 – lirtosiast Aug 25 '17 at 0:56

# Stacked, 16 bytes

5~>[@k#~]2/"!sum


Try it online!

5~> is a range from 1 to 5 incluive. 2/ makes a func dyadic, " is pair-wise, and ! is execute. This thus maps the range [1, 5] with the input, which is then evaluated after defining the range member to be k. Then, the results are summed.

# dc, 31 24 bytes

?sa1k[lax+Kd1+k5>p]dspxp


The input must be given in reverse-Polish notation (also known as postfix notation) and enclosed in square brackets ([]) with:

• K replacing k as the parameter;
• + representing addition;
• - representing subtraction and _ followed by any number representing a negative number;
• * representing multiplication;
• / representing division;
• ^ representing exponentiation;
• v representing the square-root.

For example, -2*k+k+3*k**2+k**0.5-k/2 would be input as [_2K*K+K2^3*+Kv+K2/-]. This takes due advantage of the fact that K is a dc command which returns the current precision (initially set to 1). Therefore, by the end, this returns the output with a precision of 6.

Try it online!

# R, 35 bytes

k=1:5;sum(eval(parse(t=scan(,""))))


Try it online!

TIO link includes a function solution as well (38 bytes)

# Tcl, 58 bytes

proc S {f s\ 0} {time {incr k
set s [expr $s+$f]} 5
set s}
`

Try it online!

If it only worked with integers, I could golf it more!