Đối với những người không biết, Sigma là một chữ cái Hy Lạp được sử dụng nhiều trong toán học như là dấu hiệu tổng kết. Cho một chuỗi biểu thị một biểu thức tùy thuộc vào mà chúng ta sẽ biểu thị , tính tổng kết quả cho , cho mỗi . Chính xác, bạn nên tìm sao cho:$k$$E(k)$$E(k)$$k\in\{1,2,3,4,5\}$$S$

Một ví dụ về biểu thức:$E(k)=\frac k 2 + k^2$

Thông số kỹ thuật

• Bạn được đảm bảo:
  • biểu thức là hợp lệ, vì vậy nó không có lỗi và nó phụ thuộc vào cú pháp được chọn (ví dụ: nếu bạn chỉ hỗ trợ 2*k, sẽ không có 2k)
  • chỉ đã xác định các giá trị giữa các kết quả của bạn, vì vậy không có giá trị như thế 1/0, infhoặc nansẽ xuất hiện
• Bạn có thể giả sử rằng biểu thức trên phù hợp với các giới hạn của ngôn ngữ lập trình bạn chọn, do đó nó sẽ không dẫn đến tràn hoặc bất kỳ lỗi nào liên quan đến giới hạn khác
• Bất kỳ ký tự ASCII không khoảng trắng nào khác thay vì kcó thể được chọn
• Chương trình của bạn phải hỗ trợ các hoạt động sau:
  • Ngoài ra ( +, plus(), add(), sum())
  • trừ ( -, minus(), subtract())
  • lũy thừa ( **, ^, pow()hoặc những người khác, nên được chỉ định), với sự hỗ trợ về căn cứ tiêu cực và số mũ
  • căn bậc hai theo hình thức sqrt(k), k^0.5, k**0.5, hoặc tuy nhiên khác mà bạn muốn
  • nhân và chia
• Việc gửi có thể là một chương trình đầy đủ hoặc một chức năng, trong khi đề cập đến việc sử dụng nó
• Bất kỳ khoảng trắng theo sau / khoảng trắng hàng đầu đều được phép khi xuất
• Độ chính xác tối thiểu: 2 chữ số thập phân

Các trường hợp thử nghiệm (với 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           |
+---------------+--------------+

Điểm sẽ là số byte (của cờ nguồn + trình biên dịch). Điểm nộp bài hợp lệ thấp nhất sẽ thắng, trong khi lưu ý rằng những sơ hở này đều bị nghiêm cấm. Đây là một mã giả Python, để làm cho mọi thứ rõ ràng hơn.

Thạch , 5 byte

vЀ5S

Hãy thử trực tuyến!

Nhập một chuỗi Jelly monadic hợp lệ (tôi đánh gôn chúng trong liên kết của tôi).

Làm thế nào nó hoạt động

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

Toán học, 17 14 13 byte

Cảm ơn Ian Miller đã lưu 3 byte.

Cảm ơn LegionMammal978 vì đã tiết kiệm 1 byte.

#~NSum~{k,5}&

Đầu vào phải là một biểu thức thực tế có chứa k, ví dụ:

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

Python 3 , 40 37 byte

3 byte nhờ Arnauld.

Thủ thuật phạm vi Eval \ o /

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

Hãy thử trực tuyến!

Sử dụng k**0.5thay vì sqrt(k).

JavaScript (ES7), 31 30 byte

Sử dụng k**0.5cho 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"))

Hãy thử trực tuyến!

05AB1E , 8 7 6 byte

6G¹.VO

Hãy thử trực tuyến!

Đầu vào là trong ký hiệu postfix, và sử dụng N biến . 05AB1E là một ngôn ngữ dựa trên ngăn xếp, vì vậy chỉ có ký hiệu hậu tố hoạt động.

Định dạng của E(N): ghi (các) số bạn muốn thực hiện thao tác và sau đó viết dấu hiệu của thao tác. Ví dụ, 3+4sẽ là 3 4+, 3*4+2*3sẽ là 3 4* 2 3* +. Cũng lưu ý rằng điều này sử dụng tthay vì sqrt, và mthay vì **, vì vậy sqrt(N)sẽ được Nt.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Lũy thừa được biểu thị bằng dấu mũ .^và phép nhân được ký hiệu là .*.

Điều này tuyên bố một hàm ẩn danh có trong đối số d. Nó đặt kbằng với phạm vi 1:5và tính tổng dvà đánh giá nó.

Japt , 10 byte

6ÆK=XOxUÃx

Chuỗi đầu vào nên có biến là chữ hoa K. sqrt(K)nên được nhập vào như K**0.5.

Hãy thử trực tuyến!

Giải trình

evalphạm vi đã không làm việc có lợi cho tôi; đã phải xác định lại biến đếm Xlà toàn cầu 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 byte

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

Hãy thử trực tuyến!

Số mũ được ký hiệu là .^

APL (Dyalog) , 9 byte

+/⍎⎕⊣k←⍳5

Hãy thử trực tuyến!

Ngoài ra +, phép trừ là -, phép nhân là ×, phép chia là ÷lũy thừa *và thực hiện là từ phải sang trái, vì vậy sử dụng ()để biểu thức nhóm.

Đầu vào là về k.

Giải trình

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)

Và đây là một giải pháp lấy tàu làm đầu vào (như câu trả lời của Jelly) : +/(⍎⎕)¨⍳5.

Lisp thông thường, 55 byte

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

Dùng thử trực tuyến

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

phiên bản khác, dài hơn (58 byte) - bắt đầu ngắn hơn nếu bạn thực hiện tổng hợp từ 1 đến 7.

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

còn một phương thức khác và dài hơn ( 65 64 byte) - không xác định hàm - chỉ chèn biểu thức của bạn vào một vòng lặp. Nên rút ngắn cho số tiền lớn hơn.

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

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

Vì một số lý do, điều này sẽ chỉ chạy cục bộ :(.

Đây là một lời giải thích về những gì tôi đang làm:

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

Cảm ơn @Mr. Xcoder để lưu 15 byte!

TI-Basic, 12 byte

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

Gọi với "string":prgmNAME, stringbất kỳ biểu thức TI-Basic hợp lệ nào của K.

Xếp chồng lên nhau , 16 byte

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

Hãy thử trực tuyến!

5~>là một phạm vi từ 1 đến 5 incluive. 2/làm cho một func dyadic, "là cặp khôn ngoan, và !được thực thi. Do đó, ánh xạ phạm vi [1, 5]với đầu vào, sau đó được đánh giá sau khi xác định thành viên phạm vi k. Sau đó, kết quả được tổng hợp.

dc , 31 24 byte

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

Đầu vào phải được cung cấp theo ký hiệu Ba Lan ngược (còn được gọi là ký hiệu hậu tố) và được đặt trong dấu ngoặc vuông ( []) với:

• Kthay thế knhư tham số;
• + đại diện cho bổ sung;
• -đại diện cho phép trừ và _theo sau là bất kỳ số nào đại diện cho một số âm;
• * đại diện cho phép nhân;
• / đại diện cho bộ phận;
• ^ đại diện cho cấp số nhân;
• v đại diện cho căn bậc hai.

Ví dụ, -2*k+k+3*k**2+k**0.5-k/2sẽ là đầu vào như [_2K*K+K2^3*+Kv+K2/-]. Điều này có lợi do thực tế Klà một dclệnh trả về độ chính xác hiện tại (ban đầu được đặt thành 1). Do đó, cuối cùng, điều này trả về đầu ra với độ chính xác là 6.

Hãy thử trực tuyến!

R , 35 byte

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

Hãy thử trực tuyến!

Liên kết TIO cũng bao gồm một giải pháp chức năng (38 byte)

Tcl , 58 byte

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

Hãy thử trực tuyến!

Nếu nó chỉ hoạt động với số nguyên, tôi có thể chơi gôn nhiều hơn!