Centered Square Numbers in Java

In this section, we will learn what is a centered square number and also create Java programs to check if the given number is a centered square number or not. The centered square number program is frequently asked in Java coding interviews and academics.

Centered Square Numbers

Centered Square numbers are the figurate numbers that are recursively defined as:

Thus,

For n = 1

Q(1) = Q(1 - 1) + 4 x (1 - 1) => Q(1) = Q(0) + 4 x 0 = 1 + 0 = 1

For n = 2

Q(2) = Q(2 - 1) + 4 x (2 - 1) => Q(2) = Q(1) + 4 x 1 = 1 + 4 = 5

For n = 3

Q(3) = Q(3 - 1) + 4 x (3 - 1) => Q(3) = Q(2) + 4 x 2 = 5 + 8 = 13

For n = 4

Q(4) = Q(4 - 1) + 4 x (4 - 1) => Q(4) = Q(3) + 4 x 3 = 13 + 12 = 25

For n = 5

Q(5) = Q(5 - 1) + 4 x (5 - 1) => Q(5) = Q(4) + 4 x 4 = 25 + 16 = 41

Recursive Approach

In this approach, we are going to write a method that will call itself (recursion) to compute the centered square number. The base case for terminating the recursion is Q(1) = 1. Observe its implementation mentioned below.

FileName: CenteredSquareNumber.java

public class CenteredSquareNumber 
{
public int findCenteredSqureNum(int num) 
{
// handling the base case
if(num == 1)
{
    return num;
}
// recursively computing the centered square number
return findCenteredSqureNum(num - 1) + 4 * (num - 1);
}
// Main method
public static void main(String[] argvs) 
{
// creating an object of the class CenteredSquareNumber
CenteredSquareNumber obj = new CenteredSquareNumber();
// computing the first 10 centered square numbers
int num = 10;
System.out.println("The first " + num + " Centered Square Number are: ");
for(int i = 1; i <= 10; i++)
{
int ans = obj.findCenteredSqureNum(i);
System.out.print(ans + " ");
}
}
}

Output:

The first 10 Centered Square Number are: 
1 5 13 25 41 61 85 113 145 181

Complexity Analysis: The time complexity of the program O(d), where d is the d^thposition of the centered square number that has to be found. The program is not consuming any extra space. Hence, the space complexity is O(1).

Approach: Using Iteration

The space complexity of the above program can be reduced further. We will use an array to store the result of the previously computed centered square numbers. Thus, it is not required to compute the previously computed solution again and again. Observe its implementation mentioned below.

FileName: CenteredSquareNumber1.java

public class CenteredSquareNumber1 
{
// Main method
public static void main(String[] argvs) 
{
// computing the first 10 centered square numbers
int num = 10;
// creating an array that stores the computed centered square number
int ans[] = new int[num + 1];
System.out.println("The first " + num + " Centered Square Number are: ");
for(int i = 1; i <= 10; i++)
{
// handling the base case
if(i == 1)
{
    ans[i] = 1;
}
else
{
    ans[i] = ans[i - 1] + 4 * (i - 1);
}
// printing the output
System.out.print(ans[i] + " ");
}
}
}

Output:

The first 10 Centered Square Number are: 
1 5 13 25 41 61 85 113 145 181

Complexity Analysis: The time complexity of the program is O(1). The program uses an array to store the result. Therefore, the space complexity of the program is O(n), where n is the total number centered square numbers that have to be computed.

We can still do optimization in terms of space complexity. If we observe the above recursive formula, we find that the n^thcentered square number is only dependent on the (n - 1)^th centered square number. Thus, there is no need to store all of the previously computed centered square numbers. Simply storing the last computed centered square number will do the job. The following program shows the same.

FileName: CenteredSquareNumber2.java

public class CenteredSquareNumber2 
{
// Main method
public static void main(String[] argvs) 
{
// computing the first 10 centered square numbers
int num = 10;
// a variable that stores only the last computed centered square number
int lastCenSqrNum = 0;
System.out.println("The first " + num + " Centered Square Number are: ");
for(int i = 1; i <= 10; i++)
{
// handling the base case
if(i == 1)
{
    lastCenSqrNum = 1;
}
else
{
    lastCenSqrNum = lastCenSqrNum + 4 * (i - 1);
}
// printing the output
System.out.print(lastCenSqrNum + " ");
}
}
}

Output:

The first 10 Centered Square Number are: 
1 5 13 25 41 61 85 113 145 181

Complexity Analysis: The time complexity of the program is O(1). The program is not using an array to store the result. Therefore, the space complexity of the program is also O(1).

Approach: Using Mathematical Formula

The mathematical formula for computing the centered square numbers is

Q(n) = n² + (n - 1)², where n >= 1

Thus,

For n = 1

Q(1) = 1² + (1 - 1)² => Q(1) = 1 + 0² = 1 + 0 = 1

For n = 2

Q(2) = 2² + (2 - 1)² => Q(2) = 4 + 1² = 4 + 1 = 5

For n = 3

Q(3) = 3² + (3 - 1)² => Q(3) = 9 + 2² = 9 + 4 = 13

For n = 4

Q(4) = 4² + (4 - 1)² => Q(4) = 16 + 3² = 16 + 9 = 25

For n = 5

Q(5) = 5² + (5 - 1)² => Q(5) = 25 + 4² = 25 + 16 = 41

The implementation of the mentioned mathematical formula is quite straight forward.

FileName: CenteredSquareNumber3.java

public class CenteredSquareNumber3
{
// Main method
public static void main(String[] argvs) 
{
// computing the first 10 centered square numbers
int num = 10;
System.out.println("The first " + num + " Centered Square Number are: ");
for(int i = 1; i <= 10; i++)
{
int ans = (i * i) + ((i - 1) * (i - 1));
// printing the output
System.out.print(ans + " ");
}
}
}

Output:

The first 10 Centered Square Number are: 
1 5 13 25 41 61 85 113 145 181

Complexity Analysis: The time as well as space complexity of the program is the same as the previous program.

Check for the Centered Square Numbers

Till now, we have always been computing the centered square numbers. Now, we will see how to validate whether the given number is a centered square number or not.

Approach

The approach is to compute the centered square number till the input number or greater than the input number (inputNum in our case). We can do the same with the help of the triangular numbers. Observe the following steps.

Step 1: First, we need to compute the triangular number.

Step 2: Then, multiply the computed triangular number with the number 4.

Step 3: After that add 1 to the result. The number we get is the centered square number.

Step 4: If the computed number found in the previous step matches with the inputNum, then inputNum is the centered square number. Else, compute the next greater triangular number and repeat from step 2. If the computed centered becomes greater than the inputNum, then it means inputNum is not a centered square number.

Note: Triangular Number is T(n) = (n x (n + 1)) / 2, where n >= 1

FileName: CenteredSquareNumber4.java

public class CenteredSquareNumber4
{
// a method that check whether the input number a 
// is a centered square number or not
public boolean isCenteredSqrNum(int inputNum)
{
// 1 is a centered square number
if(inputNum == 1)
{
return true;
}
int n = 1;
while(true)
{
// computing the triangular number for the number n
int triangularNum = (n * (n + 1)) / 2;
// computing the centered square number
// which the multiplication of triangular number
// with the number 4 + 1.
int ans = 4 * triangularNum;
ans = ans + 1;
if(ans == inputNum)
{
return true;
}
else if(ans > inputNum)
{
return false;
}
// look for the next triangular number
// hence, increment n by 1
n = n + 1;
}
}
// Main method
public static void main(String[] argvs) 
{
// creating an object of the class CenteredSquareNumber4
CenteredSquareNumber4 obj = new CenteredSquareNumber4();
// input array
int inputArr[] = {4, 5, 8, 13, 15, 25, 40, 41};
// size of the input array
int size = inputArr.length;
for(int i = 0; i < size; i++)
{
if(obj.isCenteredSqrNum(inputArr[i]))
{
System.out.println(inputArr[i] + " is a centered square number.");
}
else
{
System.out.println(inputArr[i] + " is not a centered square number.");
}
}
}
}

Output:

4 is not a centered square number.
5 is a centered square number.
8 is not a centered square number.
13 is a centered square number.
15 is not a centered square number.
25 is a centered square number.
40 is not a centered square number.
41 is a centered square number.

Complexity Analysis: The time complexity of the program is O(N), where N is the value of the centered square number that has to be validated. The space complexity of the program is constant, i.e., O(1).

Next TopicProcessBuilder in Java

← prev next →