# Square pyramidal number (Sum of Squares)

A Square Pyramidal Number means the Sum of the Square of Natural Numbers. Natural Numbers include all the numbers from 1 to infinity. For example, the first 4 Square pyramidal numbers are 1, 5, 14, 30.

For better perception, consider the fact: If we take spheres of numbers equal to the square pyramidal numbers, starting from one, and stack them in descending order, they create a pyramid.

## Problem Statement

Given a number Sum. If Sum is the sum of the squares of first “n” natural numbers, return n, otherwise return false.

### Example 1

Input = 30
Output = 4


Explanation = 30 is the sum of squares of the first 4 natural numbers.

1*1 + 2*2 + 3*3 +4*4 = 30.


Hence, the output should be 4.

### Example 2

Input = 54
Output = -1


Explanation = No sum of squares of n natural numbers gives 54. Hence, the output should be -1.

### Solution of Problem Statement

There are 2 solutions to the problem.

## Approach 1: Brute Force Approach

Brute force approach is to start from n= 1. Create a variable ‘total’ and add the square of the next natural number to the previous value of total. If total becomes equal to the Sum return n and, else if, total becomes greater than the Sum, return false.

### Pseudocode

start
n =1
While (total < sum ):
Total += n*n
n=n+1
if(total == sum) :
Return n
Else:
Return false
end


### Example

Below is a C++ program to check if a given number is total of squares of natural numbers.

#include <iostream>
using namespace std;
// This function returns n if the sum of squares of first
// n natural numbers is equal to the given sum
// Else it returns -1
int square_pyramidal_number(int sum) {
// initialize total
int total = 0;
// Return -1 if Sum is <= 0
if(sum <= 0){
return -1;
}

// Adding squares of the numbers starting from 1
int n = 0;
while ( total < sum){
n++;
total += n * n;
}

// If total becomes equal to sum return n
if (total == sum)
return n;

return -1;
}
int main(){
int S = 30;
int n = square_pyramidal_number(S);
cout<< "Number of Square Pyramidal Numbers whose sum is 30: "<< endl;
(n) ? cout << n : cout << "-1";
return 0;
}


### Output

Number of Square Pyramidal Numbers whose sum is 30:
4


Time Complexity - O(sum), where sum is the given input.

Space Complexity - O(1) : No extra space used.

## Approach 2: Using Newton Raphson Method

Another approach is Newton Raphson Method. Newton Raphson Method is used to find the root of a given function f(x) and an initial guess for a root.

sum of squares of first n natural numbers = n * (n + 1) * (2*n + 1) / 6,

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

k * (k + 1) * (2*k + 1) – 6*sum = 0


So n is the root of this cubic equation, which can be calculated using Newton Raphson Method which involves Starting from initial guess x0, the Newton Raphson method uses the below formula to find the next value of x, i.e., xn+1 from previous value xn.

$$\mathrm{x_{1}=x_{0}-\frac{f(x_{0})}{f^{'}(x_{0})}}$$

### Pseudocode

Start
calculate func(x) and derivativeFunction(x) for given initial x
Compute h: h = func(x) / derivFunc(x)
While h is greater than allowed error ε
h = func(x) / derivFunc(x)
x = x – h
If (x is an integer):
return x
Else:
return -1;
end


### Example

Below is a C++ Program to check if a given number is a total of squares of natural numbers.

#include<bits/stdc++.h>
#define EPSILON 0.001
using namespace std;
// According to Newton Raphson Method The function is
// k * (k + 1) * (2*k + 1) – 6*sum or 2*k*k*k + 3*k*k + k - 6*sum
double func(double k, int sum){
return 2*k*k*k + 3*k*k + k - 6*sum;
}
// Derivative of the above function is 6*k*k + 6*k + 1
double derivativeFunction(double k){
return 6*k*k + 6*k + 1;
}
// Function to check if double is an integer or not
bool isInteger(double N){
int X = N;
double temp2 = N - X;
if (temp2*10 >=1 ) {
return false;
}
return true;
}
// Function that finds the root of k * (k + 1) * (2*k + 1) – 6*sum
int newtonRaphson(double k, int sum){
double h = func(k, sum) / derivativeFunction(k);
while (abs(h) >= EPSILON){
h = func(k, sum)/derivativeFunction(k);
// k(i+1) = k(i) - f(k) / f'(k)
k = k - h;
}
if (isInteger(k)) {
return (int)k;
}
else {
return -1;
}
}
// Driver program
int main(){
double x0 = 1; // Initial values assumed
int sum = 91;
int n = newtonRaphson(x0,sum);
cout<< "Number of Square Pyramidal Numbers whose sum is 91: "<< endl;
(n) ? cout << n : cout << "-1";
return 0;
}


### Output

Number of Square Pyramidal Numbers whose sum is 91:
6


Time Complexity - O((log n) F(n)) where F(n) is the cost of calculating f(x)/f'(x), with n-digit precision.

Space Complexity - O(1) : No extra space used.

## Conclusion

This article solved the problem of finding Square pyramidal number for a given sum. We saw two approaches: a brute force approach, and an efficient one. C++ programs are provided for both of the approaches.