Skip to content
Related Articles

Related Articles

Improve Article

Find the coordinate that does not belong to any square

  • Last Updated : 30 Jul, 2021
Geek Week

Given an array arr[] consisting of (4 * N + 1) pairs of coordinates representing the coordinates of the corners of any N squares such that only one coordinate doesn’t belong to any square, the task is to find that coordinate that doesn’t belong to any square.

Examples:

Input: N = 2, arr[] = { {0, 0}, {0, 1}, {0, 2}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2} }
Output: 1 1
Explanation:
The square has four sides: x = 0, x = 2, y = 0, y = 2, now all the points belong to the square except one point (1, 1).

Input: N = 2, arr[] = { {0, 0}, {0, 1}, {0, 2}, {1, 0}, {0, 3}, {1, 2}, {2, 0}, {2, 1}, {2, 2} }
Output: 0 3

Approach: The given problem can be solved based on the following observations:



  • The coordinates of the sides of the square will appear at least two times because N ≥ 2. Therefore, since there is only one point not on the boundary, the maximum between x-coordinates which appear at least twice will give us the x-coordinate of the right side of the square.
  • The other three sides can be obtained similarly with different combinations of maximum/minimum and x-/ycoordinates.
  • After knowing the sides of the square, it is easy to identify the point not on the boundary.

Follow the steps below to solve the problem :

  • Iterate over a range [0, N] using the variable i and perform the following steps:
    • Initialize the variables x1, y1 with 2e9 and x2, y2 with -2e9 to store the points of the upper and lower boundary of the square.
    • Iterate over a range [0, N] using the variable j and perform the following steps:
      • If i is not equal to j, then, perform the following steps:
        • Set x1 to the minimum of x1 or p[j].first.
        • Set x2 to the maximum of x2 or p[j].first.
        • Set y1 to the minimum of y1  or p[j].second.
        • Set y2 to the minimum of y2 or p[j].second.
    • Initialize a variable, say ok to true and variables cnt1, cnt2, cnt3, cnt4 as 0 to store the count of points with maximum and minimum as x1, x2, y1, y2.
    • Iterate over a range [0, N] using the variable j and perform the following steps:
      • If i is not equal to j, then, perform the following steps:
        • If p[j].first is equal to x1, then, increase the value of cnt1 by 1.
        • If p[j].first is equal to x2, then, increase the value of cnt2 by 1.
        • If p[j].second is equal to y1, then, increase the value of cnt3 by 1.
        • If p[j].second is equal to y2, then, increase the value of cnt4 by 1.
      • Else, set the value of ok to false.
    • If the value of ok is true and the values of cnt1, cnt2, cnt3, cnt4 are greater than equal to N, and x2 – x2 is equal to y2 – y1, then, p[i] is the required point. Print the answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
typedef long long ll;
#define fi first
#define se second
 
// Function to find the point that is
// not a part of the side of a square
void findPoint(int n,
               vector<pair<int, int> > p)
{
    // Traverse each pair of coordinates
    for (int i = 0; i < n * 4 + 1; ++i) {
 
        int x1 = 2e9, x2 = -2e9;
        int y1 = 2e9, y2 = -2e9;
 
        for (int j = 0; j < n * 4 + 1; ++j)
            if (i != j) {
 
                // Minimize x-coordinate
                // in all the points
                // except current point
                x1 = min(x1, p[j].fi);
 
                // Maximize x-coordinate in
                // all the points except
                // the current point
                x2 = max(x2, p[j].fi);
 
                // Minimize y-coordinate
                // in all the points
                // except current point
                y1 = min(y1, p[j].se);
 
                // Maximize y-coordinate
                // in all the points
                // except current point
                y2 = max(y2, p[j].se);
            }
 
        bool ok = 1;
 
        int c1 = 0, c2 = 0;
        int c3 = 0, c4 = 0;
 
        for (int j = 1; j <= n * 4 + 1; ++j)
            if (i != j) {
 
                // If x-coordinate matches
                // with other same line
                if ((p[j].fi == x1
                     || p[j].fi == x2)
                    || ((p[j].se == y1
                         || p[j].se == y2))) {
 
                    if (p[j].fi == x1)
                        ++c1;
 
                    if (p[j].fi == x2)
                        ++c2;
 
                    // If y coordinate matches
                    // with other same line
                    if (p[j].se == y1)
                        ++c3;
 
                    if (p[j].se == y2)
                        ++c4;
                }
                else
                    ok = 0;
            }
 
        // Check if the condition
        // for square exists or not
        if (ok && c1 >= n && c2 >= n
            && c3 >= n && c4 >= n
            && x2 - x1 == y2 - y1) {
 
            // Print the output
            cout << p[i].fi << " "
                 << p[i].se << "\n";
        }
    }
}
 
// Driver Code
int main()
{
    int N = 2;
    vector<pair<int, int> > arr
        = { { 0, 0 }, { 0, 1 }, { 0, 2 },
            { 1, 0 }, { 1, 1 }, { 1, 2 },
            { 2, 0 }, { 2, 1 }, { 2, 2 } };
 
    findPoint(N, arr);
 
    return 0;
}

Java




import java.util.ArrayList;
 
//Java program for above approach
class GFG{
    static class pair<T, V>{
        T fi;
        V se;
        pair(T a, V b){
            this.fi = a;
            this.se = b;
        }
    }
 
    // Function to find the point that is
    // not a part of the side of a square
    static void findPoint(int n,
                   ArrayList<pair<Integer, Integer> > p)
    {
        // Traverse each pair of coordinates
        for (int i = 0; i < n * 4 + 1; ++i) {
 
            int x1 = (int) 2e9, x2 = (int) -2e9;
            int y1 = (int) 2e9, y2 = (int) -2e9;
 
            for (int j = 0; j < n * 4 + 1; ++j)
                if (i != j) {
 
                    // Minimize x-coordinate
                    // in all the points
                    // except current point
                    x1 = Math.min(x1, p.get(j).fi);
 
                    // Maximize x-coordinate in
                    // all the points except
                    // the current point
                    x2 = Math.max(x2, p.get(j).fi);
 
                    // Minimize y-coordinate
                    // in all the points
                    // except current point
                    y1 = Math.min(y1, p.get(j).se);
 
                    // Maximize y-coordinate
                    // in all the points
                    // except current point
                    y2 = Math.max(y2, p.get(j).se);
                }
 
            boolean ok = true;
 
            int c1 = 0, c2 = 0;
            int c3 = 0, c4 = 0;
 
            for (int j = 1; j < n * 4 + 1; ++j)
                if (i != j) {
 
                    // If x-coordinate matches
                    // with other same line
                    if ((p.get(j).fi == x1
                            || p.get(j).fi == x2)
                            || ((p.get(j).se == y1
                            || p.get(j).se == y2))) {
 
                        if (p.get(j).fi == x1)
                            ++c1;
 
                        if (p.get(j).fi == x2)
                            ++c2;
 
                        // If y coordinate matches
                        // with other same line
                        if (p.get(j).se == y1)
                            ++c3;
 
                        if (p.get(j).se == y2)
                            ++c4;
                    }
                    else
                        ok = false;
                }
 
            // Check if the condition
            // for square exists or not
            if (ok && c1 >= n && c2 >= n
                    && c3 >= n && c4 >= n
                    && x2 - x1 == y2 - y1) {
 
                // Print the output
                System.out.println(p.get(i).fi + " " + p.get(i).se);
 
            }
        }
    }
 
    //Driver Code
    public static void main(String[] args) {
        int N = 2;
        ArrayList<pair<Integer, Integer> > arr = new ArrayList<>();
        arr.add(new pair<Integer, Integer>(0,0));
        arr.add(new pair<Integer, Integer>(0,1));
        arr.add(new pair<Integer, Integer>(0,2));
        arr.add(new pair<Integer, Integer>(1,0));
        arr.add(new pair<Integer, Integer>(1,1));
        arr.add(new pair<Integer, Integer>(1,2));
        arr.add(new pair<Integer, Integer>(2,0));
        arr.add(new pair<Integer, Integer>(2,1));
        arr.add(new pair<Integer, Integer>(2,2));
        findPoint(N, arr);
 
    }
}
 
// This code is contributed by hritikrommie.

Python3




# Python 3 program for the above approach
 
# Function to find the point that is
# not a part of the side of a square
def findPoint(n, p):
    # Traverse each pair of coordinates
    for i in range(n * 4 + 1):
        x1 = 2e9
        x2 = -2e9
        y1 = 2e9
        y2 = -2e9
 
        for j in range(n * 4 + 1):
            if (i != j):
 
                # Minimize x-coordinate
                # in all the points
                # except current point
                x1 = min(x1, p[j][0])
 
                # Maximize x-coordinate in
                # all the points except
                # the current point
                x2 = max(x2, p[j][0])
 
                # Minimize y-coordinate
                # in all the points
                # except current point
                y1 = min(y1, p[j][1])
 
                # Maximize y-coordinate
                # in all the points
                # except current point
                y2 = max(y2, p[j][1])
 
        ok = 1
 
        c1 = 0
        c2 = 0
        c3 = 0
        c4 = 0
 
        for j in range(1,n * 4 + 1,1):
            if (i != j):
 
                # If x-coordinate matches
                # with other same line
                if ((p[j][0] == x1 or p[j][0] == x2) or (p[j][1] == y1 or p[j][1] == y2)):
                    if (p[j][0] == x1):
                        c1 += 1
 
                    if (p[j][0] == x2):
                        c2 += 1
 
                    # If y coordinate matches
                    # with other same line
                    if (p[j][1] == y1):
                        c3 += 1
 
                    if (p[j][1] == y2):
                        c4 += 1
                else:
                    ok = 0
 
        # Check if the condition
        # for square exists or not
        if (ok and c1 >= n and c2 >= n and c3 >= n and c4 >= n and x2 - x1 == y2 - y1):
 
            # Print the output
            print(p[i][0],p[i][1])
         
# Driver Code
if __name__ == '__main__':
    N = 2
    arr =  [[0, 0],[0, 1],[0, 2],[1, 0],[1, 1],[1, 2],[2, 0],[2, 1],[2, 2]]
 
    findPoint(N, arr)
     
    # This code is contributed by ipg2016107.

 
 

Output: 
1 1

 

 

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

 

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :