Per coloro che non lo sapevano, Sigma è una lettera greca che viene pesantemente usata in matematica come segno di sommatoria. Data una stringa che rappresenta un'espressione dipendente da che indicheremo , calcola la somma dei risultati per , per ogni . In breve, dovresti trovare tale che:E ( k ) E ( k ) k ∈ { 1 , 2 , 3 , 4 , 5 } $k$$E(k)$$E(k)$$k\in\{1,2,3,4,5\}$$S$

Un esempio di espressione:$E(k)=\frac k 2 + k^2$

Specifiche

• Sei garantito:
  • che l'espressione è valida, quindi non contiene errori e dipende dalla sintassi scelta (es: se si supporta solo 2*k, non ci sarà 2k)
  • solo hanno definito valori tra i tuoi risultati, quindi nessun valore piace 1/0, info nanappariranno
• Puoi supporre che l'espressione sopra sia adatta ai limiti del linguaggio di programmazione di tua scelta, quindi non si tradurrà in overflow o altri errori relativi ai limiti
• È kpossibile scegliere qualsiasi altro carattere ASCII non di spazi bianchi anziché
• Il programma deve supportare le seguenti operazioni:
  • Inoltre ( +, plus(), add(), sum())
  • sottrazione ( -, minus(), subtract())
  • elevamento a potenza ( **, ^, pow()o altri, occorre precisare), con il supporto di basi negativi ed esponenti
  • radice quadrata in forma di sqrt(k), k^0.5, k**0.5, o comunque altra cosa che si desidera
  • moltiplicazione e divisione
• L'invio può essere un programma completo o una funzione, menzionandone l'utilizzo
• È consentito qualsiasi spazio bianco finale / iniziale durante l'output
• Precisione minima: 2 decimali

Casi di prova (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           |
+---------------+--------------+

Il punteggio sarà il numero di byte (dei flag sorgente + compilatore). Vince l'invio valido con il punteggio più basso, tenendo presente che queste scappatoie sono severamente vietate. Ecco uno pseudo-codice Python, per rendere le cose più chiare.

Gelatina , 5 byte

vЀ5S

Provalo online!

Inserisci una catena monadica Jelly valida (le ho giocate a golf nel mio link).

Come funziona

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 byte

Grazie a Ian Miller per aver salvato 3 byte.

Grazie a LegionMammal978 per aver salvato 1 byte.

#~NSum~{k,5}&

L'input deve essere un'espressione effettiva contenente k, ad esempio:

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

Python 3 , 40 37 byte

3 byte grazie ad Arnauld.

Trucchi di portata eval \ o /

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

Provalo online!

Utilizza k**0.5invece di sqrt(k).

JavaScript (ES7), 31 30 byte

Utilizza k**0.5per 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"))

Provalo online!

05AB1E , 8 7 6 byte

6G¹.VO

Provalo online!

L'ingresso è in notazione postfix, e utilizza la variabile N . 05AB1E è un linguaggio basato su stack, quindi funziona solo la notazione postfix.

Formato di E(N): scrivere i numeri con cui si desidera eseguire l'operazione, quindi scrivere il segno dell'operazione. Ad esempio, 3+4sarebbe 3 4+, 3*4+2*3sarebbe 3 4* 2 3* +. Si noti inoltre che questo utilizza tinvece di sqrte minvece di **, così sqrt(N)sarebbe Nt.

Spiegazione:

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

Ottava , 50 46 31 29 byte

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

Provalo online!

L'esponenziazione è indicata con il cursore .^e la moltiplicazione è indicata con .*.

Questo dichiara una funzione anonima che prende in considerazione d. Imposta kper essere uguale all'intervallo 1:5e somma il valutato de lo restituisce.

Japt , 10 byte

6ÆK=XOxUÃx

La stringa di input deve avere una variabile maiuscola K. sqrt(K)dovrebbe essere inserito come K**0.5.

Provalo online!

Spiegazione

evalla portata non ha funzionato a mio favore; ha dovuto ridefinire la variabile di conteggio Xcome 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

Ottava, 25 23 byte

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

Provalo online!

L'esponenziazione è indicata come .^

APL (Dyalog) , 9 byte

+/⍎⎕⊣k←⍳5

Provalo online!

L'aggiunta è +, la sottrazione è -, la moltiplicazione è ×, la divisione è ÷esponenziazione *e l'esecuzione è da destra a sinistra, quindi usare ()per raggruppare le espressioni.

L'input è in termini di k.

Spiegazione

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)

Ed ecco una soluzione che prende come input i treni (come la risposta Jelly): +/(⍎⎕)¨⍳5.

Lisp comune, 55 byte

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

Provalo online

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

versione diversa, più lunga (58 byte) - inizia ad accorciarsi se si sommano da 1 a 7.

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

ancora un altro metodo più lungo ( 65 64 byte) - non definisce la funzione - inserisce semplicemente la tua espressione in un ciclo. Dovrebbe accorciarsi per somme maggiori.

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

Rapido, 202 184 byte

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

Per qualche motivo questo funzionerà solo localmente :(.

Ecco una spiegazione di ciò che sto facendo:

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

Grazie a @Mr. Xcoder per salvare 15 byte!

TI-Basic, 12 byte

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

Chiama con "string":prgmNAME, dove si stringtrova qualsiasi espressione TI-Basic valida di K.

Impilato , 16 byte

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

Provalo online!

5~>è un intervallo compreso tra 1 e 5. 2/crea una funzione dinamica, "è una coppia e !viene eseguita. Ciò mappa quindi l'intervallo [1, 5]con l'input, che viene quindi valutato dopo aver definito il membro dell'intervallo da essere k. Quindi, i risultati vengono sommati.

dc , 31 24 byte

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

L'input deve essere dato in notazione polacca inversa (nota anche come notazione postfix) e racchiusa tra parentesi quadre ( []) con:

• Ksostituendo kcome parametro;
• + che rappresenta l'addizione;
• -che rappresenta la sottrazione e _seguito da qualsiasi numero che rappresenta un numero negativo;
• * che rappresenta la moltiplicazione;
• / rappresentare la divisione;
• ^ rappresentante esponenziale;
• v che rappresenta la radice quadrata.

Ad esempio, -2*k+k+3*k**2+k**0.5-k/2verrebbe inserito come [_2K*K+K2^3*+Kv+K2/-]. Ciò sfrutta il fatto che si Ktratta di un dccomando che restituisce la precisione corrente (inizialmente impostata su 1). Pertanto, alla fine, questo restituisce l'output con una precisione di 6.

Provalo online!

R , 35 byte

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

Provalo online!

Il collegamento TIO include anche una soluzione funzionale (38 byte)

Tcl , 58 byte

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

Provalo online!

Se funzionasse solo con numeri interi, avrei potuto giocare a golf di più!