21
\$\begingroup\$

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.

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

16 Answers 16

3
\$\begingroup\$

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
\$\endgroup\$
9
\$\begingroup\$

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

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).

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

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!

\$\endgroup\$
  • \$\begingroup\$ Ninjaed again! Nicely done. \$\endgroup\$ – Shaggy May 13 '17 at 11:23
3
\$\begingroup\$

05AB1E, 8 7 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].
  ¹.V  Read and eval input.
     O Sum results.
\$\endgroup\$
3
\$\begingroup\$

Octave, 50 46 31 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.

\$\endgroup\$
3
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ Hmm, I wonder if transpiling Ox directly to eval( would help with that... \$\endgroup\$ – ETHproductions Jul 8 '17 at 11:32
2
\$\begingroup\$

Octave, 25 23 bytes

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

Try it online!

Exponentiation is denoted as .^

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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)
\$\endgroup\$
2
\$\begingroup\$

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!

\$\endgroup\$
2
\$\begingroup\$

TI-Basic, 12 bytes

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

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

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

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.

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

R, 35 bytes

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

Try it online!

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

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.