 Open in App
Not now

# Count squares possible from M and N straight lines parallel to X and Y axis respectively

• Difficulty Level : Easy
• Last Updated : 28 Dec, 2022

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(M2+ N2)
Auxiliary Space: O(M2+ N2)

My Personal Notes arrow_drop_up