Skip to content
Related Articles
Count squares possible from M and N straight lines parallel to X and Y axis respectively
• Difficulty Level : Easy
• Last Updated : 19 May, 2021

Given two arrays X[] and Y[] consisting of N and M integers such that there are N lines parallel to the y-axis and M lines parallel to the x-axis. The task is to find the total number of squares formed by these lines on a coordinate plane.

Each integer(say a) in the array X[] denotes lines having equation x = a, parallel to y-axis
Each integer(say b) in the array Y[] denotes lines having equation y = b, parallel to x-axis

Examples:

Input: N = 3, M = 4, X[] = {1, 3, 7}, Y[] = {2, 4, 6, 1}
Output:
Explanation:
3 lines are parallel to y-axis for x = 1, x = 3 and x = 7.
4 lines are parallel to x-axis for y = 2, y = 4, y = 6 and y = 1. From the above image, below are three possible squares formed:
1) square CDEF (x = 1, x = 3, y = 2, y = 4), side = 2 units.
2) square ABDC (x = 1, x = 3, y = 4, y = 6), side = 2 units.
3) square BGHF (x = 3, x = 7, y = 2, y = 6), side = 4 units.

Input: N = 5, M = 4, X[] = {1, 9, 2, 3, 7}, Y[] = {1, 2, 4, 6}
Output: 8

Approach: Follow the steps below to solve the problem:

• Find the distance between all pairs in X[] array and store the count in a Map, say M1.
• Find the distance between all pairs in Y[] array and store the count in a Map M2.
• If the distance of pairs of M1 is present in M2, then a square can be made by using both the pairs.
• Therefore, the total count of squares can be calculated by adding all the counts of distances stored in M1 as well as in M2.
• Print the total count of squares after completing the above steps.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count all the possible``// squares with given lines parallel``// to both the X and Y axis``int` `numberOfSquares(``int` `X[], ``int` `Y[],``                    ``int` `N, ``int` `M)``{``    ``// Stores the count of all possible``    ``// distances in X[] & Y[] respectively``    ``unordered_map<``int``, ``int``> m1, m2;``    ``int` `i, j, ans = 0;` `    ``// Find distance between all``    ``// pairs in the array X[]``    ``for` `(i = 0; i < N; i++) {``        ``for` `(j = i + 1; j < N; j++) {` `            ``int` `dist = ``abs``(X[i] - X[j]);` `            ``// Add the count to m1``            ``m1[dist]++;``        ``}``    ``}` `    ``// Find distance between all``    ``// pairs in the array Y[]``    ``for` `(i = 0; i < M; i++) {``        ``for` `(j = i + 1; j < M; j++) {` `            ``int` `dist = ``abs``(Y[i] - Y[j]);` `            ``// Add the count to m2``            ``m2[dist]++;``        ``}``    ``}` `    ``// Find sum of m1[i] * m2[i]``    ``// for same distance``    ``for` `(``auto` `i = m1.begin();``         ``i != m1.end(); i++) {` `        ``// Find current count in m2``        ``if` `(m2.find(i->first)``            ``!= m2.end()) {` `            ``// Add to the total count``            ``ans += (i->second``                    ``* m2[i->first]);``        ``}``    ``}` `    ``// Return the final count``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``// Given lines``    ``int` `X[] = { 1, 3, 7 };``    ``int` `Y[] = { 2, 4, 6, 1 };` `    ``int` `N = ``sizeof``(X) / ``sizeof``(X);` `    ``int` `M = ``sizeof``(Y) / ``sizeof``(Y);` `    ``// Function Call``    ``cout << numberOfSquares(X, Y, N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{` `// Function to count all the possible``// squares with given lines parallel``// to both the X and Y axis``static` `int` `numberOfSquares(``int``[] X, ``int``[] Y, ``int` `N,``                           ``int` `M)``{``    ` `    ``// Stores the count of all possible``    ``// distances in X[] & Y[] respectively``    ``HashMap m1 = ``new` `HashMap();``    ``HashMap m2 = ``new` `HashMap();` `    ``int` `i, j, ans = ``0``;` `    ``// Find distance between all``    ``// pairs in the array X[]``    ``for``(i = ``0``; i < N; i++)``    ``{``        ``for``(j = i + ``1``; j < N; j++)``        ``{``            ``int` `dist = Math.abs(X[i] - X[j]);` `            ``// Add the count to m1``            ``m1.put(dist, m1.getOrDefault(dist, ``0``) + ``1``);``        ``}``    ``}` `    ``// Find distance between all``    ``// pairs in the array Y[]``    ``for``(i = ``0``; i < M; i++)``    ``{``        ``for``(j = i + ``1``; j < M; j++)``        ``{``            ``int` `dist = Math.abs(Y[i] - Y[j]);` `            ``// Add the count to m2``            ``m2.put(dist, m2.getOrDefault(dist, ``0``) + ``1``);``        ``}``    ``}` `    ``// Find sum of m1[i] * m2[i]``    ``// for same distance``    ``for``(Map.Entry entry : m1.entrySet())``    ``{``        ` `        ``// Find current count in m2``        ``if` `(m2.containsKey(entry.getKey()))``        ``{``            ` `            ``// Add to the total count``            ``ans += (entry.getValue() *``             ``m2.get(entry.getKey()));``        ``}``    ``}` `    ``// Return the final count``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given lines``    ``int` `X[] = { ``1``, ``3``, ``7` `};``    ``int` `Y[] = { ``2``, ``4``, ``6``, ``1` `};` `    ``int` `N = X.length;` `    ``int` `M = Y.length;` `    ``// Function call``    ``System.out.println(numberOfSquares(X, Y, N, M));``}``}` `// This code is contributed by akhilsaini`

## Python3

 `# Python3 program for the above approach` `# Function to count all the possible``# squares with given lines parallel``# to both the X and Y axis``def` `numberOfSquares(X, Y, N, M):` `    ``# Stores the count of all possible``    ``# distances in X[] & Y[] respectively``    ``m1 ``=` `{}``    ``m2 ``=` `{}``    ``ans ``=` `0` `    ``# Find distance between all``    ``# pairs in the array X[]``    ``for` `i ``in` `range``(``0``, N):``        ``for` `j ``in` `range``(i ``+` `1``, N):``            ``dist ``=` `abs``(X[i] ``-` `X[j])` `            ``# Add the count to m1``            ``if` `dist ``in` `m1:``                ``m1[dist] ``=` `m1[dist] ``+` `1``            ``else``:``                ``m1[dist] ``=` `1` `    ``# Find distance between all``    ``# pairs in the array Y[]``    ``for` `i ``in` `range``(``0``, M):``        ``for` `j ``in` `range``(i ``+` `1``, M):``            ``dist ``=` `abs``(Y[i] ``-` `Y[j])` `            ``# Add the count to m2``            ``if` `dist ``in` `m2:``                ``m2[dist] ``=` `m2[dist] ``+` `1``            ``else``:``                ``m2[dist] ``=` `1` `    ``# Find sum of m1[i] * m2[i]``    ``# for same distance``    ``for` `key ``in` `m1:``        ` `        ``# Find current count in m2``        ``if` `key ``in` `m2:``            ` `            ``# Add to the total count``            ``ans ``=` `ans ``+` `(m1[key] ``*` `m2[key])` `    ``# Return the final count``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``# Given lines``    ``X ``=` `[ ``1``, ``3``, ``7` `]``    ``Y ``=` `[ ``2``, ``4``, ``6``, ``1` `]` `    ``N ``=` `len``(X)` `    ``M ``=` `len``(Y)` `    ``# Function call``    ``print``(numberOfSquares(X, Y, N, M))` `# This code is contributed by akhilsaini`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to count all the possible``// squares with given lines parallel``// to both the X and Y axis``static` `int` `numberOfSquares(``int``[] X, ``int``[] Y, ``int` `N,``                           ``int` `M)``{``    ` `    ``// Stores the count of all possible``    ``// distances in X[] & Y[] respectively``    ``Dictionary<``int``,``               ``int``> m1 = ``new` `Dictionary<``int``,``                                        ``int``>();``      ``Dictionary<``int``,``                 ``int``> m2 = ``new` `Dictionary<``int``,``                                          ``int``>();` `    ``int` `i, j, ans = 0;` `    ``// Find distance between all``    ``// pairs in the array X[]``    ``for``(i = 0; i < N; i++)``    ``{``        ``for``(j = i + 1; j < N; j++)``        ``{``            ``int` `dist = Math.Abs(X[i] - X[j]);` `            ``// Add the count to m1``              ``if` `(m1.ContainsKey(dist))``                ``m1[dist]++;``              ``else``                ``m1.Add(dist, 1);``        ``}``    ``}` `    ``// Find distance between all``    ``// pairs in the array Y[]``    ``for``(i = 0; i < M; i++)``    ``{``        ``for``(j = i + 1; j < M; j++)``        ``{``            ``int` `dist = Math.Abs(Y[i] - Y[j]);` `            ``// Add the count to m2``            ``if` `(m2.ContainsKey(dist))``                ``m2[dist]++;``              ``else``                ``m2.Add(dist, 1);``        ``}``    ``}` `    ``// Find sum of m1[i] * m2[i]``    ``// for same distance``    ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `m1)``    ``{``        ` `        ``// Find current count in m2``        ``if` `(m2.ContainsKey(entry.Key))``        ``{``            ` `            ``// Add to the total count``            ``ans += (entry.Value *``                 ``m2[entry.Key]);``        ``}``    ``}` `    ``// Return the final count``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main()``{``    ` `    ``// Given lines``    ``int``[] X = { 1, 3, 7 };``    ``int``[] Y = { 2, 4, 6, 1 };` `    ``int` `N = X.Length;` `    ``int` `M = Y.Length;` `    ``// Function call``    ``Console.WriteLine(numberOfSquares(X, Y, N, M));``}``}` `// This code is contributed by akhilsaini`

## Javascript

 ``
Output:
`3`

Time Complexity: O(N2)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up