A000330 - OEIS

Bài tập

Nhiệm vụ của bạn rất đơn giản, tạo ra một chuỗi, chỉ số đã cho i, giá trị trên vị trí đó là tổng bình phương từ 0đến inơi i >= 0.

Thí dụ:

Input: 0
Output: 0           (0^2)

Input: 4
Output: 30          (0^2 + 1^2 + 2^2 + 3^2 + 4^2)

Input: 5
Output: 55          (0^2 + 1^2 + 2^2 + 3^2 + 4^2 + 5^2)

Đặc điểm kỹ thuật:

• Bạn có thể không có đầu vào và đầu ra chuỗi vô thời hạn;
• Bạn có thể lấy đầu vào Nvà đầu ra Nthphần tử của chuỗi;
• Bạn có thể lấy đầu vào Nvà đầu ra các Nphần tử đầu tiên của chuỗi.

Thạch , 3 byte

R²S

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

FGITW

Giải trình

R²S  Main Link
R    Generate Range
 ²   Square (each term)
  S  Sum

Python 2 , 22 byte

lambda n:n*~n*~(n*2)/6

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

Điều này sử dụng công thức dạng đóng n * (n + 1) * (2 * n + 1) / 6 . Mã này thực hiện các hoạt động sau:

• Bội số n bởi ( n*):

  • Phần bù bit của n ( ~n), về cơ bản có nghĩa là -1-n .
  • Và bằng cách bổ sung bitwise của 2n ( *~(n*2)), có nghĩa là -1-2n .

• Chia cho 6 ( /6).

Python 2 , 27 byte

f=lambda n:n and f(n-1)+n*n

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

_{Đã lưu 1 byte nhờ Rod và 1 nhờ GB .}

MATL , 3 byte

:Us

... Hay họ?

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

Giải trình

:    % Implicit input n. Push range [1 2 ... n]
U    % Square, element-wise
s    % Sum of array. Implicit display

JavaScript (ES6), 16 byte

n=>n*(n+++n)*n/6

Bản giới thiệu

let f =

n=>n*(n+++n)*n/6

for(n = 0; n < 10; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

Làm sao?

Biểu thức n+++nđược phân tích cú pháp là n++ + n⁽¹⁾ . Không phải là nó thực sự quan trọng bởi vì n + ++ncũng sẽ làm việc trong trường hợp này.

Vì thế:

n*(n+++n)*n/6 =
n * (n + (n + 1)) * (n + 1) / 6 =
n * (2 * n + 1) * (n + 1) / 6

mà đánh giá lại để sum (k = 0 ... n) (k²) .

_{(1) Điều này có thể được xác minh bằng cách thực hiện n='2';console.log(n+++n)cung cấp số nguyên 5, trong khi đó n + ++nsẽ cung cấp cho chuỗi '23'.}

05AB1E , 3 byte

ÝnO

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

Giải trình

  O    # sum of
 n     # squares of
Ý      # range [0 ... input]

Brain-Flak , 36 byte

({<(({}[()])())>{({})({}[()])}{}}{})

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

# Main algorithm
(                                  )  # Push the sum of:
                {({})({}[()])}{}      #   The square of:
 {                              }     #     0 to i 

# Stuff for the loop
  <(({}[()])())>                      # Push i-1, i without counting it in the sum
                                 {}   # Pop the counter (0)

Brain-Flak , 34 byte

({(({}[()])()){({}[()])({})}{}}{})

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

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

Ban đầu tôi có cùng ý tưởng với Riley ¹ nhưng cảm thấy sai khi sử dụng zeroer. Sau đó tôi nhận ra rằng

{({}[()])({})}{}

Tính n ² - n.

Tại sao? Chúng tôi biết

{({})({}[()])}{}

Tính n ² và vòng lặp n lần. Điều đó có nghĩa là nếu chúng ta chuyển đổi thứ tự của hai lần đẩy, chúng ta sẽ đi từ tăng tổng bằng n + (n-1) mỗi lần để tăng tổng theo (n-1) + (n-1) mỗi lần. Điều này sẽ làm giảm kết quả một lần trên mỗi vòng lặp, do đó làm cho kết quả của chúng tôi là ² - n. Ở cấp độ cao nhất, điều này sẽ hủy bỏ với n được tạo ra bởi cú đẩy mà chúng tôi đã làm giảm bớt sự cần thiết của một số 0 và tiết kiệm cho chúng tôi hai byte.

Brain-Flak , 36 byte

({({})(({}[()])){({})({}[()])}{}}{})

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

Đây là một giải pháp khác, nó không phải là golf nhưng nó khá lạ nên tôi nghĩ tôi sẽ để nó như một thách thức để tìm ra cách nó hoạt động.

Nếu bạn không tham gia Brain-Flak nhưng bạn vẫn muốn thử thách ở đây thì đó là tổng kết.

^{1: Tôi đã đưa ra giải pháp của mình trước khi tôi xem các câu trả lời ở đây. Vì vậy, không có đạo văn ở đây.}

Husk , 3 byte

ṁ□ḣ

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

Ohm v2 , 3 byte

#²Σ

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

Giải trình

#    Range
 ²   Square
  Σ  Sum

Japt , 3 byte

ô²x

Hãy thử nó ở đây.

-1 nhờ Shaggy .

Giải trình:

ò²x 
ô²  Map square on [0..input]
  x Sum

Brain-Flak , 46 byte

{(({})[()])}{}{({({})({}[()])}{}<>)<>}<>({{}})

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

CJam , 10 byte

ri),{_*+}*

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

ri            e# Input integer n
  )           e# Add 1
   ,          e# Range [0 1 ... n]
    {   }*    e# Fold (reduce)
     _        e# Duplicate
      *       e# Multiply
       +      e# Add

Ngôn ngữ Wolfram (Mathicala) , 14 byte

Tr[Range@#^2]&

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

Trên thực tế , 3 byte

R;*

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

Lấy Nlàm đầu vào và xuất thành Nphần tử thứ trong chuỗi.

Giải trình:

R;*
R    range(1, N+1) ([1, 2, ..., N])
 ;*  dot product with self

APL (Dyalog) , 7 5 byte

2 byte được lưu nhờ @Mego

+.×⍨⍳

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

Làm sao?

⍳ - phạm vi

+.× - chấm sản phẩm

⍨ - với chính nó

R, 17 byte

sum((0:scan())^2)

Khá đơn giản, phải mất lợi thế từ thực tế là ^(lũy thừa) là vector hóa trong R .

CJam , 9 byte

ri),_.*:+

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

Giải trình

ri        e# Read input and convert to integer N.
  ),      e# Get range [0 1 2 ... N].
    _     e# Duplicate.
     .*   e# Pairwise products, giving [0 1 4 ... N^2].
       :+ e# Sum.

Cách khác:

ri),2f#:+

Điều này bình phương mỗi phần tử bằng cách ánh xạ 2#thay vì sử dụng các sản phẩm cặp. Và chỉ để giải trí, một sự thay thế khác không chính xác cho các đầu vào lớn vì nó sử dụng số học dấu phẩy động:

ri),:mh2#

Julia , 16 14 byte

Lưu 2 byte nhờ @MartinEnder

!n=(x=1:n)⋅x

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

Làm sao?

(x=1:n)tạo ra một loạt các 1đến nvà assign để x, ⋅chấm sản phẩm với x.

Mê cung , 11 byte

:!\
+ :
*:#

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

In trình tự vô thời hạn.

Giải trình

Con trỏ lệnh chỉ tiếp tục chạy xung quanh bình phương mã nhiều lần:

:!\    Duplicate the last result (initially zero), print it and a linefeed.
:      Duplicate the result again, which increases the stack depth.
#      Push the stack depth (used as a counter variable).
:*     Square it.
+      Add it to the running total.

Khối , 15 byte

Iu):^\+*p*6u@O,

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

Mã của tôi hơi buồn ):

Tính toán n*(n+1)*(2n+1)/6

    I u
    ) :
^ \ + * p * 6 u
@ O , . . . . .
    . .
    . .

^Iu : read in input, u-turn
    : stack  n
:)\ : dup, increment, go right..oh, hey, it cheered up!
    : stack: n, n+1
+   : sum
    : stack: n, n+1, 2*n+1
*   : multiply
    : stack: n, n+1, 2*n+1, (n+1)*(2*n+1)
p   : move bottom of stack to top
    : stack: n+1, 2*n+1, (n+1)*(2*n+1), n
*   : multiply
6   : push 6
u   : right u-turn
,   : divide
O   : output
@   : terminate

Befunge , 16 byte

&::2*1+*\1+*6/.@

Sử dụng công thức dạng đóng n * (n + 1) * (2n + 1) / 6 .

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

Befunge , 38 byte

v>::*\1-:v0+_$.@
&^ <     _\:^
>:#^_.@

Sử dụng một vòng lặp.

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

Haskell, 20 byte

f 0=0
f n=n*n+f(n-1)

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

Excel, 19 byte

=A1^3/3+A1^2/2+A1/6

Lục giác , 23 byte

?'+)=:!@/*"*'6/{=+'+}/{

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

Giải trình

Mở ra:

   ? ' + )
  = : ! @ /
 * " * ' 6 /
{ = + ' + } /
 { . . . . .
  . . . . .
   . . . .

Đây thực sự chỉ là một chương trình tuyến tính với việc /sử dụng cho một số chuyển hướng. Mã tuyến tính là:

?'+){=+'+}*"*'6{=:!@

Mà tính n (n + 1) (2n + 1) / 6 . Nó sử dụng các cạnh bộ nhớ sau:

Trong đó điểm bộ nhớ (MP) bắt đầu trên cạnh có nhãn n , chỉ về hướng bắc.

?   Read input into edge labelled 'n'.
'   Move MP backwards onto edge labelled 'n+1'.
+   Copy 'n' into 'n+1'.
)   Increment the value (so that it actually stores the value n+1).
{=  Move MP forwards onto edge labelled 'temp' and turn around to face
    edges 'n' and 'n+1'.
+   Add 'n' and 'n+1' into edge 'temp', so that it stores the value 2n+1.
'   Move MP backwards onto edge labelled '2n+1'.
+   Copy the value 2n+1 into this edge.
}   Move MP forwards onto 'temp' again.
*   Multiply 'n' and 'n+1' into edge 'temp', so that it stores the value
    n(n+1).
"   Move MP backwards onto edge labelled 'product'.
*   Multiply 'temp' and '2n+1' into edge 'product', so that it stores the
    value n(n+1)(2n+1).
'   Move MP backwards onto edge labelled '6'.
6   Store an actual 6 there.
{=  Move MP forwards onto edge labelled 'result' and turn around, so that
    the MP faces edges 'product' and '6'.
:   Divide 'product' by '6' into 'result', so that it stores the value
    n(n+1)(2n+1)/6, i.e. the actual result.
!   Print the result.
@   Terminate the program.

Về lý thuyết, có thể điều chỉnh chương trình này thành chiều dài 3, vì /không cần thiết cho tính toán, nên :có thể sử dụng lại để chấm dứt chương trình và một số '"=+*{có thể được sử dụng lại, mang lại số lượng yêu cầu các lệnh dưới 19 (mức tối đa cho chiều dài phụ 3). Tôi nghi ngờ rằng có thể tìm thấy một giải pháp như vậy bằng tay, nếu một trong tất cả.

> <> , 15 13 11 byte

Đã lưu 2 byte nhờ Không phải là một cây

0:n:l1-:*+!

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

Xuất ra chuỗi vô thời hạn.

Pyth , 7 5 byte nhờ Steven H

s^R2h

Giải trình:

s^R2h       Full program - inputs from stdin and outputs to stdout
s           output the sum of
    h       range(input), with
 ^R2         each element squared

Giải pháp đầu tiên của tôi

sm*ddUh

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

Giải trình:

sm*ddUh    Full program - inputs from stdin and outputs to stdout
s          sum of
 m   Uh    each d in range(input)
  *dd      squared

Neim , 3 byte

𝐈ᛦ𝐬

Đây có thể là một thách thức để thể hiện các nội dung số đa giác của Neim, nhưng dường như không.

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

Ốc đảo , 4 byte

nk+0

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

Giải trình

   0      # a(0) = 0
nk+       # a(n) = a(n-1)+n^2

Brachylog , 5 byte

⟦^₂ᵐ+

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

Giải trình

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

Gaia , 3 byte

s¦Σ

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