Puzzle | Program to find number of squares in a chessboard

Try it on GfG Practice

You are provided with a chessboard and are asked to find the total number of squares in it. A chessboard is a board with 8 x 8 grids in it, as represented below. 

Examples: 

Input: n = 2
Output: 5 (4 squares of 1 unit + 1 square of 2 units)
Explanation: Total number of square = 5 (4 squares with side of 1 unit + 1 square with side of 2 units)

Input: n = 3
Output: 14
Explanation: Total number of square = 14 ( 9 squares with side of 1 unit , 4 square with side of 2 units, 1 square with side of 3 units )

Looking closely at the chessboard we can see that in addition to the 1 x 1 square, there can be a combination of 2 x 2, 3 x 3, 4 x 4, 5 x 5, 6 x 6, 7 x 7, and 8 x 8 squares too. To get the total number of squares we need to find all the squares formed. 

No of 1 x 1 Square : 8 * 8 = 64 squares.
No of 2 x 2 Square : 7 * 7 = 49 squares.
No of 3 x 3 Square : 6 * 6 = 36 squares.
No of 4 x 4 Square : 5 * 5 = 25 squares.
No of 5 x 5 Square : 4 * 4 = 16 squares.
No of 6 x 6 Square : 3 * 3 = 9 squares.
No of 7 x 7 Square : 2 * 2 = 4 squares.
No of 8 x 8 Square : 1 * 1 = 1 square.

Therefore, we have in all = 64 + 49 + 36 + 25 + 16 + 9 + 4 + 1 = 204 squares in a chessboard.

By using the above observation the total number of squares formed in a grid of size n*n are: 

1^2 + 2^2 + 3^2 + ... + n^2 = n(n+1)(2n+1) / 6

Since the value of n*(n+1)*(2n+1) can cause overflow for large values of n, below are some interesting tricks used in the program. 

1. long int is used in return.
2. n * (n + 1) / 2 is evaluated first as the value n*(n+1) will always be a multiple of 2.

#include <bits/stdc++.h>
using namespace std;

long long int countSquares(int n)
{
  return (n * (n + 1) / 2) * (2 * n + 1) / 3;
}

int main()
{

  int n = 4;
  cout << countSquares(n);
  return 0;
}  

class GfG 
{
    static int countSquares(int n)
    {
       
        return (n * (n + 1) / 2) * (2 * n + 1) / 3;
    }
    

    public static void main (String[] args)
    {
        int n = 3;
        System.out.println(countSquares(n));
    }
}

def countSquares(n):
    
    # better way to write
    # n*(n+1)*(2n+1)/6
    return ((n * (n + 1) / 2) 
           * (2 * n + 1) / 3)

n = 4
print(countSquares(n))

using System;

public class GFG {
    
    static int countSquares(int n)
    {
        // A better way to write 
        // n*(n+1)*(2n+1)/6
        return (n * (n + 1) / 2) 
                * (2 * n + 1) / 3;
    }
    

    public static void Main ()
    {
        int n = 4;
        Console.WriteLine(countSquares(n));
    }
}

function countSquares( n)
{
    // A better way to write n*(n+1)*(2n+1)/6
    return (n * (n + 1) / 2) * (2*n + 1) / 3;
}


let n = 4;
console.log(countSquares(n));

30

Time Complexity: O(1)
Auxiliary Space: O(1)