Para quem não sabia, Sigma é uma letra grega que é muito usada em matemática como sinal de soma. Dada uma string que representa uma expressão dependendo de que designaremos , calcule a soma dos resultados para , para cada . Concisa, você deve 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$

Um exemplo de expressão:$E(k)=\frac k 2 + k^2$

Especificações

• Você está garantido:
  • que a expressão é válida, não contém erros e depende da sintaxe escolhida (por exemplo: se você apenas suportar 2*k, não haverá 2k)
  • só ter definido os valores entre os seus resultados, de modo nenhum valor gosta 1/0, infou nanaparecerá
• Você pode supor que a expressão acima está ajustando os limites da linguagem de programação de sua escolha, portanto, isso não resultará em estouros ou outros erros relacionados a limites
• Qualquer outro caractere ASCII sem espaço em branco, em vez de, kpode ser escolhido
• Seu programa deve suportar as seguintes operações:
  • Adicionalmente ( +, plus(), add(), sum())
  • subtracção ( -, minus(), subtract())
  • exponenciação ( **, ^, pow()ou outros, deve ser especificado), com apoio de bases negativas e expoentes
  • raiz quadrada na forma de sqrt(k), k^0.5, k**0.5, ou no entanto, outra coisa que você deseja
  • multiplicação e divisão
• O envio pode ser um programa completo ou uma função, enquanto menciona seu uso
• Qualquer espaço em branco à direita / à esquerda é permitido ao gerar
• Precisão mínima: 2 casas decimais

Casos de teste (com 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           |
+---------------+--------------+

A pontuação será o número de bytes (dos sinalizadores de origem + compilador). O envio válido com a pontuação mais baixa ganha, enquanto observa que essas brechas são estritamente proibidas. Aqui está um pseudo-código Python, para tornar as coisas mais claras.

Geléia , 5 bytes

vЀ5S

Experimente online!

Insira uma cadeia monádica Jelly válida (eu os joguei no meu link).

Como 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

Obrigado a Ian Miller por salvar 3 bytes.

Agradecemos a LegionMammal978 por economizar 1 byte.

#~NSum~{k,5}&

A entrada deve ser uma expressão real contendo k, por exemplo:

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

Python 3 , 40 37 bytes

3 bytes graças a Arnauld.

Truques do escopo da avaliação \ o /

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

Experimente online!

Usa em k**0.5vez de sqrt(k).

JavaScript (ES7), 31 30 bytes

Usa 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"))

Experimente online!

05AB1E , 8 7 6 bytes

6G¹.VO

Experimente online!

De entrada é em notação sufixo, e usa a N variável . 05AB1E é uma linguagem baseada em pilha, portanto, apenas a notação postfix funciona.

Formato de E(N): escreva o (s) número (s) com o qual deseja executar a operação e, em seguida, escreva o sinal da operação. Por exemplo, 3+4seria 3 4+, 3*4+2*3seria 3 4* 2 3* +. Observe também que isso usa em tvez de sqrt, e em mvez de **, sqrt(N)seria Nt.

Explicação:

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

Oitava , 50 46 31 29 bytes

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

Experimente online!

Exponenciação é denotada com o sinal de intercalação .^e multiplicação é denotada com .*.

Isso declara uma função anônima que aceita argumentos d. Ele define kcomo igual ao intervalo 1:5e soma o avaliado de o retorna.

Japonês , 10 bytes

6ÆK=XOxUÃx

A sequência de entrada deve ter variável como maiúscula K. sqrt(K)deve ser inserido como K**0.5.

Experimente online!

Explicação

evalo escopo não funcionou a meu favor; teve que redefinir a variável de contagem 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

Oitava, 25 23 bytes

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

Experimente online!

Exponenciação é denotada como .^

APL (Dyalog) , 9 bytes

+/⍎⎕⊣k←⍳5

Experimente online!

Além disso +, subtração -, multiplicação ×, divisão é ÷exponenciação *e execução da direita para a esquerda, portanto, use ()para agrupar expressões.

Entrada é em termos de k.

Explicação

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)

E aqui está uma solução que leva trens como entrada (como a resposta Jelly): +/(⍎⎕)¨⍳5.

Lisp comum, 55 bytes

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

Experimente online

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

versão diferente e mais longa (58 bytes) - começa a ficar mais curta se você fizer uma soma de 1 a 7.

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

ainda outro método mais longo ( 65 64 bytes) - não define função - apenas insere sua expressão em um loop. Deve ficar mais curto para somas maiores.

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

Rápido, 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 alguma razão, isso será executado apenas localmente :(.

Aqui está uma explicação do que estou fazendo:

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

Graças a @Mr. Xcoder para economizar 15 bytes!

TI-Basic, 12 bytes

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

Ligue com "string":prgmNAME, onde stringestá qualquer expressão TI-Basic válida de K.

Empilhados , 16 bytes

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

Experimente online!

5~>é um intervalo de 1 a 5, inclusive. 2/cria uma função diádica, "é em pares e !é executada. Dessa forma, mapeia o intervalo [1, 5]com a entrada, que é avaliada após a definição do membro do intervalo k. Em seguida, os resultados são somados.

dc , 31 24 bytes

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

A entrada deve ser fornecida em notação polonesa reversa (também conhecida como notação postfix) e entre colchetes ( []) com:

• Ksubstituindo kcomo o parâmetro;
• + representando adição;
• -representando subtração e _seguido por qualquer número representando um número negativo;
• * representando multiplicação;
• / representando divisão;
• ^ representando exponenciação;
• v representando a raiz quadrada.

Por exemplo, -2*k+k+3*k**2+k**0.5-k/2seria inserido como [_2K*K+K2^3*+Kv+K2/-]. Isso tira o devido proveito do fato de Kser um dccomando que retorna a precisão atual (inicialmente definida como 1). Portanto, no final, isso retorna a saída com uma precisão de 6.

Experimente online!

R , 35 bytes

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

Experimente online!

O link TIO também inclui uma solução de função (38 bytes)

Tcl , 58 bytes

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

Experimente online!

Se funcionasse apenas com números inteiros, eu poderia jogar mais!