Square pyramidal numbers

Question

A000330 - OEIS

Task

Your task is simple, generate a sequence that, given index i, the value on that position is the sum of squares from 0 upto i where i >= 0.

Example:

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)

Specification:

• You may take no input and output the sequence indefinitely;
• You may take input N and output the Nth element of the sequence;
• You may take input N and output the first N elements of the sequence.

Answer 1

Python 2, 22 bytes

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

Try it online!

This uses the closed-form formula n * (n+1) * (2*n+1) / 6. The code performs the following operations:

• Multiplies n by (n*):

  • The bitwise complement of n (~n), which essentially means -1-n.
  • And by the bitwise complement of 2n (*~(n*2)), which means -1-2n.

• Divides by 6 (/6).

Python 2, 27 bytes

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

Try it online!

_{Saved 1 byte thanks to Rod and 1 thanks to G B.}

Answer 2

JavaScript (ES6), 16 bytes

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

Demo

let f =

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

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

How?

The expression n+++n is parsed as n++ + n ⁽¹⁾. Not that it really matters because n + ++n would also work in this case.

Therefore:

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

which evaluates to sum(k=0...n)(k²).

---

_{(1) This can be verified by doing n='2';console.log(n+++n) which gives the integer 5, whereas n + ++n would give the string '23'.}

Answer 3

MATL, 3 bytes

:Us

... or them?

Try it online!

Explanation

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

Answer 4

05AB1E, 3 bytes

ÝnO

Try it online!

Explanation

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

Answer 5

Brain-Flak, 36 bytes

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

Try it online!

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

Answer 6

Brain-Flak, 34 bytes

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

Try it online!

How does it work?

Initially I had the same idea as Riley¹ but it felt wrong to use a zeroer. I then realized that

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

Calculates n² - n.

Why? Well we know

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

Calculates n² and loops n times. That means if we switch the order of the two pushes we go from increasing the sum by n + (n-1) each time to increasing the sum by (n-1) + (n-1) each time. This will decrease the result by one per loop, thus making our result n² - n. At the top level this -n cancels with the n generated by the push that we were zeroing alleviating the need for a zeroer and saving us two bytes.

Brain-Flak, 36 bytes

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

Try it online!

Here is another solution, its not as golfy but it's pretty strange so I thought I would leave it as a challenge to figure out how it works.

If you are not into Brain-Flak but you still want the challenge here it is as a summation.

---

^{1: I came up with my solution before I looked at the answers here. So no plagiarism here.}

Answer 7

Jelly, 3 bytes

R²S

Try it online!

FGITW

Explanation

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

Answer 8

Husk, 3 bytes

ṁ□ḣ

Try it online!

Answer 9

Hexagony, 23 bytes

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

Try it online!

Explanation

Unfolded:

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

This is really just a linear program with the / used for some redirection. The linear code is:

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

Which computes n (n+1) (2n+1) / 6. It uses the following memory edges:

Where the memory point (MP) starts on the edge labelled n, pointing north.

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

In theory it might be possible to fit this program into side-length 3, because the / aren't needed for the computation, the : can be reused to terminate the program, and some of the '"=+*{ might be reusable as well, bringing the number of required commands below 19 (the maximum for side-length 3). I doubt it's possible to find such a solution by hand though, if one exists at all.

Answer 10

Ohm v2, 3 bytes

#²Σ

Try it online!

Explanation

#    Range
 ²   Square
  Σ  Sum

Answer 11

Japt, 3 bytes

ô²x

Try it here.

-1 thanks to Shaggy.

Explanation:

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

Answer 12

Brain-Flak, 46 bytes

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

Try it online!

Answer 13

CJam, 10 bytes

ri),{_*+}*

Try it online!

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

Answer 14

Wolfram Language (Mathematica), 14 bytes

Tr[Range@#^2]&

Try it online!

Answer 15

Brachylog, 5 bytes

⟦^₂ᵐ+

Try it online!

Explanation

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

Answer 16

Actually, 3 bytes

R;*

Try it online!

Takes N as input, and outputs the Nth element in the sequence.

Explanation:

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

Answer 17

APL (Dyalog), 7 5 bytes

2 bytes saved thanks to @Mego

+.×⍨⍳

Try it online!

How?

⍳ - range

+.× - dot product

⍨ - with itself

Answer 18

R, 17 bytes

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

Pretty straightforward, it takes advantage from the fact that ^ (exponentiation) is vectorized in R.

Answer 19

CJam, 9 bytes

ri),_.*:+

Try it online!

Explanation

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.

Alternatively:

ri),2f#:+

This squares each element by mapping 2# instead of using pairwise products. And just for fun another alternative which gets inaccurate for large inputs because it uses floating-point arithmetic:

ri),:mh2#

Answer 20

Julia, 16 14 bytes

2 bytes saved thanks to @MartinEnder

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

Try it online!

How?

(x=1:n) creates a range of 1 to n and assign to x, ⋅ dot product with x.

Answer 21

Labyrinth, 11 bytes

:!\
+ :
*:#

Try it online!

Prints the sequence indefinitely.

Explanation

The instruction pointer just keeps running around the square of code over and over:

:!\    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.

Answer 22

Cubix, 15 bytes

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

Try it online!

My code is a bit sad ):

Computes 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

Answer 23

Befunge, 16 bytes

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

Using the closed-form formula n*(n+1)*(2n+1)/6.

Try it online!

Befunge, 38 bytes

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

Using a loop.

Try it online!

Answer 24

Haskell, 20 bytes

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

Try it online!

Answer 25

Excel, 19 bytes

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

Answer 26

><>, 15 13 11 bytes

Saved 2 bytes thanks to Not a tree

0:n:l1-:*+!

Try it online!

Outputs the sequence indefinitely.

Answer 27

Pyth, 7 5 bytes thanks to Steven H

s^R2h

Explanation:

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

---

My first solution

sm*ddUh

Try it online!

Explanation:

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

Answer 28

J, 10 9 bytes

4%~3!2*>:

Try it online!

Saved 1 byte using an explicit formula, thanks to miles!

---

J, 10 bytes

1#.]*:@-i.

J has a range function, but this gives us number from 0 to N-1. To remedy this, we can just take the argument and subtract the range from it, giving us a range from N to 1. This is done with ] -i.. The rest of the code simply square this list argument (*:@) and then sums it (1#.).

Other contenders

11 bytes: 1#.*:@i.@>:

13 bytes: 1#.[:,@:*/~i.

Answer 29

Thunno 2 S, 2 bytes

R²

Attempt This Online!

Explanation

R²  # Implicit input
R   # Range of input
 ²  # Square each
    # Sum the list
    # Implicit output

Answer 30

Nekomata, 3 bytes

R:∙

Attempt This Online!

R:∙
R     Range
 :    Duplicate
  ∙   Dot product

Because there isn't a square built-in yet.