Para aquellos que no sabían, Sigma es una letra griega que se usa mucho en matemáticas como signo de suma. Dada una cadena que representa una expresión dependiendo de que denotaremos , calcule la suma de los resultados para , para cada . De manera concisa, debe encontrar tal que:E ( k ) E ( k ) k ∈ { 1 , 2 , 3 , 4 , 5 } $k$$E(k)$$E(k)$$k\in\{1,2,3,4,5\}$$S$

Un ejemplo de una expresión:$E(k)=\frac k 2 + k^2$

Especificaciones

• Estás garantizado:
  • que la expresión es válida, por lo que no contiene errores, y que depende de la sintaxis elegida (por ejemplo: si solo admite 2*k, no habrá 2k)
  • que sólo han definido los valores entre sus resultados, por lo que no hay valores como 1/0, info nanaparecerá
• Puede suponer que la expresión anterior se ajusta a los límites del lenguaje de programación de su elección, por lo que no provocará desbordamientos ni ningún otro error relacionado con el límite.
• Se kpuede elegir cualquier otro carácter ASCII que no sea un espacio en blanco en lugar de
• Su programa debe soportar las siguientes operaciones:
  • Además ( +, plus(), add(), sum())
  • resta ( -, minus(), subtract())
  • exponenciación ( **, ^, pow()o de otros, debe ser especificada), con apoyo a las bases negativas y exponentes
  • raíz cuadrada en forma de sqrt(k), k^0.5, k**0.5, o como otra cosa que desea
  • multiplicación y división
• El envío puede ser un programa completo o una función, mientras menciona su uso
• Cualquier espacio en blanco al final / al inicio está permitido al generar
• Precisión mínima: 2 decimales

Casos de prueba (con 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           |
+---------------+--------------+

La puntuación será el número de bytes (de las banderas fuente + compilador). La presentación válida con la puntuación más baja gana, mientras se toma nota de que estas lagunas están estrictamente prohibidas. Aquí hay un pseudocódigo de Python, para aclarar las cosas.

Jalea , 5 bytes

vЀ5S

Pruébalo en línea!

Ingrese una cadena monádica Jelly válida (las golfé en mi enlace).

Cómo funciona

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, 17 14 13 bytes

Gracias a Ian Miller por guardar 3 bytes.

Gracias a LegionMammal978 por guardar 1 byte.

#~NSum~{k,5}&

La entrada debe ser una expresión real que contenga k, por ejemplo:

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

Python 3 , 40 37 bytes

3 bytes gracias a Arnauld.

Evalúa trucos de alcance \ o /

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

Pruébalo en línea!

Usos en k**0.5lugar de sqrt(k).

JavaScript (ES7), 31 30 bytes

Usos k**0.5para 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"))

Pruébalo en línea!

05AB1E , 8 7 6 bytes

6G¹.VO

Pruébalo en línea!

De entrada es en notación postfix, y utiliza la variable N . 05AB1E es un lenguaje basado en pila, por lo que solo funciona la notación postfix.

Formato de E(N): escriba los números con los que desea realizar la operación y luego escriba el signo de la operación. Por ejemplo, 3+4sería 3 4+, 3*4+2*3sería 3 4* 2 3* +. También tenga en cuenta que esto usa en tlugar de sqrt, y en mlugar de **, así sqrt(N)sería Nt.

Explicación:

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

Octava , 50 46 31 29 bytes

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

Pruébalo en línea!

La exponenciación se denota con el símbolo de intercalación .^y la multiplicación se denota con .*.

Esto declara una función anónima que toma en argumento d. Establece kser igual al rango 1:5y suma lo evaluado dy lo devuelve.

Japt , 10 bytes

6ÆK=XOxUÃx

La cadena de entrada debe tener una variable en mayúscula K. sqrt(K)debe ingresarse como K**0.5.

Pruébalo en línea!

Explicación

evalel alcance no funcionó a mi favor; tuvo que redefinir la variable de conteo Xcomo 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

Octava, 25 23 bytes

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

Pruébalo en línea!

La exponenciación se denota como .^

APL (Dyalog) , 9 bytes

+/⍎⎕⊣k←⍳5

Pruébalo en línea!

La suma es +, la resta es -, la multiplicación es ×, la división es la ÷exponenciación *y la ejecución es de derecha a izquierda, así que use ()para agrupar expresiones.

La entrada es en términos de k.

Explicación

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)

Y he aquí una solución que toma como entrada los trenes (como la respuesta Jelly): +/(⍎⎕)¨⍳5.

Lisp común, 55 bytes

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

Pruébalo en línea

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

versión diferente, más larga (58 bytes): comienza a acortarse si realiza la suma de 1 a 7.

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

otro método más largo ( 65 64 bytes), no define la función, simplemente inserta su expresión en un bucle. Debería acortarse para sumas más grandes.

(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,+))}

Por alguna razón, esto solo se ejecutará localmente :(.

Aquí hay una explicación de lo que estoy haciendo:

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

Gracias a @Mr. ¡Xcoder para guardar 15 bytes!

TI-Basic, 12 bytes

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

Llame con "string":prgmNAME, donde stringes cualquier expresión válida de TI-Basic de K.

Apilado , 16 bytes

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

Pruébalo en línea!

5~>es un rango de 1 a 5 inclusive. 2/hace una función diádica, "es por pares y !se ejecuta. Esto mapea el rango [1, 5]con la entrada, que luego se evalúa después de definir el miembro del rango que será k. Luego, se resumen los resultados.

dc , 31 24 bytes

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

La entrada debe darse en notación polaca inversa (también conocida como notación postfix) y encerrada entre corchetes ( []) con:

• Kreemplazando kcomo el parámetro;
• + que representa la suma;
• -representando resta y _seguido de cualquier número que represente un número negativo;
• * representando multiplicación;
• / división representativa;
• ^ representando exponenciación;
• v representando la raíz cuadrada.

Por ejemplo, -2*k+k+3*k**2+k**0.5-k/2sería ingresado como [_2K*K+K2^3*+Kv+K2/-]. Esto aprovecha el hecho de que Kes un dccomando que devuelve la precisión actual (inicialmente establecida en 1). Por lo tanto, al final, esto devuelve la salida con una precisión de 6.

Pruébalo en línea!

R , 35 bytes

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

Pruébalo en línea!

El enlace TIO también incluye una solución de función (38 bytes)

Tcl , 58 bytes

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

Pruébalo en línea!

Si solo funcionara con enteros, ¡podría jugar más golf!