Skip to content
Related Articles

Related Articles

Improve Article
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 <bits/stdc++.h>
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[0]);
 
    int M = sizeof(Y) / sizeof(Y[0]);
 
    // 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<Integer,
            Integer> m1 = new HashMap<Integer,
                                      Integer>();
    HashMap<Integer,
            Integer> m2 = new HashMap<Integer,
                                      Integer>();
 
    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<Integer,
                  Integer> 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




<script>
 
// Javascript program for the above approach
 
// Function to count all the possible
// squares with given lines parallel
// to both the X and Y axis
function numberOfSquares(X, Y, N, M)
{
 
    // Stores the count of all possible
    // distances in X[] & Y[] respectively
    var m1 = new Map(), m2 = new Map();
    var 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++) {
 
            var dist = Math.abs(X[i] - X[j]);
 
            // Add the count to m1
            if(m1.has(dist))
                m1.set(dist, m1.get(dist)+1)
            else
                m1.set(dist, 1);
        }
    }
 
    // Find distance between all
    // pairs in the array Y[]
    for (i = 0; i < M; i++) {
        for (j = i + 1; j < M; j++) {
 
            var dist = Math.abs(Y[i] - Y[j]);
 
            // Add the count to m2
            if(m2.has(dist))
                m2.set(dist, m2.get(dist)+1)
            else
                m2.set(dist, 1);
        }
    }
 
    // Find sum of m1[i] * m2[i]
    // for same distance
    m1.forEach((value, key) => {
 
        // Find current count in m2
        if (m2.has(key)) {
 
            // Add to the total count
            ans += (value
                    * m2.get(key));
        }
    });
 
    // Return the final count
    return ans;
}
 
// Driver Code
 
// Given lines
var X = [1, 3, 7];
var Y = [2, 4, 6, 1];
var N = X.length;
var M = Y.length;
 
// Function Call
document.write( numberOfSquares(X, Y, N, M));
 
// This code is contributed by rrrtnx.
</script>
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
Recommended Articles
Page :