Pour ceux qui ne le savaient pas, Sigma est une lettre grecque qui est largement utilisée en mathématiques comme signe de sommation. Étant donné une chaîne représentant une expression dépendant de que nous noterons , calculez la somme des résultats pour , pour chaque . En résumé, vous devriez trouver tel 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 exemple d'expression:$E(k)=\frac k 2 + k^2$

Spécifications

• Vous avez la garantie:
  • que l'expression est valide, donc elle ne contient aucune erreur, et qu'elle dépend de la syntaxe choisie (ex: si vous ne supportez que 2*k, il n'y en aura pas 2k)
  • d'avoir uniquement des valeurs définies parmi vos résultats, donc aucune valeur comme 1/0, infou nann'apparaîtra
• Vous pouvez supposer que l'expression ci-dessus correspond aux limites du langage de programmation de votre choix, de sorte qu'elle n'entraînera pas de débordements ou d'autres erreurs liées aux limites
• Tout autre caractère ASCII non blanc au lieu de kpeut être choisi
• Votre programme doit prendre en charge les opérations suivantes:
  • addition ( +, plus(), add(), sum())
  • soustraction ( -, minus(), subtract())
  • exponentiation ( **, ^, pow()ou autres, il convient de préciser), avec l' aide de bases négatives et des exposants
  • racine carrée sous la forme de sqrt(k), k^0.5, k**0.5ou cependant autre que vous souhaitez
  • Multiplication et division
• La soumission peut être soit un programme complet soit une fonction, tout en mentionnant son utilisation
• Tout espace de fin / de début est autorisé lors de la sortie
• Précision minimale: 2 décimales

Cas de test (avec 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           |
+---------------+--------------+

Le score sera le nombre d'octets (des drapeaux source + compilateur). La soumission valide ayant obtenu le score le plus bas l'emporte, tout en prenant note que ces failles sont strictement interdites. Voici un pseudo-code Python, pour rendre les choses plus claires.

Gelée , 5 octets

vЀ5S

Essayez-le en ligne!

Entrez une chaîne monadique Jelly valide (je les ai golfées dans mon lien).

Comment ça marche

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 octets

Merci à Ian Miller d'avoir économisé 3 octets.

Merci à LegionMammal978 pour avoir économisé 1 octet.

#~NSum~{k,5}&

L'entrée doit être une expression réelle contenant k, par exemple:

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

Python 3 , 40 37 octets

3 octets grâce à Arnauld.

Astuces de portée Eval \ o /

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

Essayez-le en ligne!

Utilise k**0.5au lieu de sqrt(k).

JavaScript (ES7), 31 30 octets

Utilise k**0.5pour 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"))

Essayez-le en ligne!

05AB1E , 8 7 6 octets

6G¹.VO

Essayez-le en ligne!

L' entrée est en notation postfixe, et utilise la variable N . 05AB1E est un langage basé sur la pile, donc seule la notation postfixe fonctionne.

Format de E(N): écrivez le (s) nombre (s) avec lequel vous souhaitez effectuer l'opération, puis écrivez le signe de l'opération. Par exemple, 3+4serait 3 4+, 3*4+2*3serait 3 4* 2 3* +. Notez également que cela utilise à la tplace de sqrt, et mau lieu de **, ce sqrt(N)serait le cas Nt.

Explication:

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

Octave , 50 46 31 29 octets

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

Essayez-le en ligne!

L'exponentiation est indiquée par le signe d'insertion .^et la multiplication est indiquée par .*.

Cela déclare une fonction anonyme qui prend en argument d. Il kest égal à la plage 1:5et additionne l'évaluation det la renvoie.

Japt , 10 octets

6ÆK=XOxUÃx

La chaîne d'entrée doit avoir une variable en majuscule K. sqrt(K)devrait être entré comme K**0.5.

Essayez-le en ligne!

Explication

evalla portée n'a pas fonctionné en ma faveur; a dû redéfinir la variable de comptage en Xtant que variable globale 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

Octave, 25 23 octets

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

Essayez-le en ligne!

L'exponentiation est désignée par .^

APL (Dyalog) , 9 octets

+/⍎⎕⊣k←⍳5

Essayez-le en ligne!

L'addition est +, la soustraction est -, la multiplication est ×, la division est l' ÷exponentiation est *et l'exécution est de droite à gauche, donc utilisez ()pour grouper les expressions.

L'entrée est en termes de k.

Explication

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)

Et voici une solution qui prend des trains en entrée (comme la réponse Jelly): +/(⍎⎕)¨⍳5.

Lisp commun, 55 octets

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

Essayez-le en ligne

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

version différente, plus longue (58 octets) - commence à devenir plus courte si vous faites la somme de 1 à 7.

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

encore une autre méthode plus longue ( 65 64 octets) - ne définit pas la fonction - insère simplement votre expression dans une boucle. Devrait se raccourcir pour des sommes plus importantes.

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

Swift, 202 184 octets

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

Pour une raison quelconque, cela ne fonctionnera que localement :(.

Voici une explication de ce que je fais:

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

Merci à @Mr. Xcoder pour économiser 15 octets!

TI-Basic, 12 octets

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

Appelez avec "string":prgmNAME, où stringest une expression TI-Basic valide de K.

Empilé , 16 octets

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

Essayez-le en ligne!

5~>est une plage de 1 à 5 incluive. 2/fait un func dyadique, "est par paire, et !est exécuté. Cela mappe ainsi la plage [1, 5]avec l'entrée, qui est ensuite évaluée après avoir défini le membre de la plage à être k. Ensuite, les résultats sont additionnés.

dc , 31 24 octets

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

L'entrée doit être indiquée en notation polonaise inversée (également appelée notation postfixée) et placée entre crochets ( []) avec:

• Kremplacer kcomme paramètre;
• + représentant l'addition;
• -représentant la soustraction et _suivi par tout nombre représentant un nombre négatif;
• * représentant la multiplication;
• / représentant la division;
• ^ représentant l'exponentiation;
• v représentant la racine carrée.

Par exemple, -2*k+k+3*k**2+k**0.5-k/2serait entré comme [_2K*K+K2^3*+Kv+K2/-]. Cela tire avantage du fait qu'il Ks'agit d'une dccommande qui renvoie la précision actuelle (initialement définie sur 1). Par conséquent, à la fin, cela renvoie la sortie avec une précision de 6.

Essayez-le en ligne!

R , 35 octets

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

Essayez-le en ligne!

La liaison TIO comprend également une solution fonctionnelle (38 octets)

Tcl , 58 octets

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

Essayez-le en ligne!

Si cela ne fonctionnait qu'avec des entiers, je pourrais le jouer davantage!