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: $k$ $E(k)$ $E(k)$ $k\in\{1,2,3,4,5\}$ $S$

S = \sum_{k = 1}^{5} E (k)

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

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.

— M. Xcoder
source

Pouvons-nous prendre plus()au lieu de +? (Même questions pour tous les autres opérateurs aussi)

— Stewie Griffin

@StewieGriffin Oui, plus(), add(), sum()et équivalents sont autorisés. Voir l'édition.

— M. Xcoder

Non, vous ne pouvez prendre l'expression qu'une seule fois, @ComradeSparklePony

— M. Xcoder

Peut-on utiliser la notation postfixée? Par exemple, le test 3 cas du haut serait quelque chose comme: N N2/+N2**+.

— Camarade SparklePony

C'est très étrange, mais cela est autorisé tant que vous indiquez clairement le "format" de E(x)@ComradeSparklePony

— M. Xcoder

3

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

— Leaky Nun
source

9

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]

— Martin Ender
source

2

J'aurais dû deviner que Mathematica avait intégré cela

— M. Xcoder

2

Mathematica a toujours intégré des situations. : P

— totalement humain

Vous n'avez pas besoin 1,dedans pour Sum.

— Ian Miller,

En fait, cela peut se raccourcir enN@#~Sum~{k,5}&

— Ian Miller

@IanMiller Oh, bien sûr. Merci!

— Martin Ender

8

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

— Leaky Nun
source

Est-il permis de répondre à une question aussi rapidement? o_O

— M. Xcoder

7

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

Développer l'extrait

Essayez-le en ligne!

— Arnauld
source

Ninjaed à nouveau! Bien fait.

— Shaggy

3

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.

— Camarade SparklePony
source

3

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.

— Kritixi Lithos
source

3

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

— Justin Mariner
source

Hmm, je me demande si le transpiling Oxdirectement eval(pourrait aider à ça ...

— ETHproductions

2

Octave, 25 23 octets

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

Essayez-le en ligne!

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

— Кирилл Малышев
source

2

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.

— Kritixi Lithos
source

2

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)

2

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!

— Caleb Kleveter
source

2

TI-Basic, 12 octets

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

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

— pizzapants184
source

Solution intéressante de même durée:Ans->u:sum(u(1,5

— lirtosiast

1

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.

— Conor O'Brien
source

1

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. Kap
source

1

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)

— JayCe
source

1

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!

— sergiol
source

Sigmafy l'expression

Spécifications

Cas de test (avec k)

Gelée , 5 octets

Comment ça marche

Mathematica, 17 14 13 octets

Python 3 , 40 37 octets

JavaScript (ES7), 31 30 octets

05AB1E , 8 7 6 octets

Octave , 50 46 31 29 octets

Japt , 10 octets

Explication

Octave, 25 23 octets

APL (Dyalog) , 9 octets

Explication

Lisp commun, 55 octets

Swift, 202 184 octets

TI-Basic, 12 octets

Empilé , 16 octets

dc , 31 24 octets

R , 35 octets

Tcl , 58 octets

Cas de test (avec `k`)