Find the coordinate that does not belong to any square

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.

C#

// C# code to implement the approach
using System;
using System.Collections.Generic;

class GFG {

  // pair class definition
  public class pair<T, V> {
    public T fi;
    public V se;

    // constructor
    public 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, List<pair<int, int> > p)
  {
    // Traverse each pair of coordinates
    for (int i = 0; i < n * 4 + 1; ++i) {
      int x1 = int.MaxValue, x2 = int.MinValue;
      int y1 = int.MaxValue, y2 = int.MinValue;

      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[j].fi);

          // Maximize x-coordinate in
          // all the points except
          // the current point
          x2 = Math.Max(x2, p[j].fi);

          // Minimize y-coordinate
          // in all the points
          // except current point
          y1 = Math.Min(y1, p[j].se);

          // Maximize y-coordinate
          // in all the points
          // except current point
          y2 = Math.Max(y2, p[j].se);
        }

      bool 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[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 = 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
        Console.WriteLine(p[i].fi + " " + p[i].se);
      }
    }
  }

  // Driver Code
  static void Main(string[] args)
  {
    int N = 2;
    List<pair<int, int> > arr
      = new List<pair<int, int> >();
    arr.Add(new pair<int, int>(0, 0));
    arr.Add(new pair<int, int>(0, 1));
    arr.Add(new pair<int, int>(0, 2));
    arr.Add(new pair<int, int>(1, 0));
    arr.Add(new pair<int, int>(1, 1));
    arr.Add(new pair<int, int>(1, 2));
    arr.Add(new pair<int, int>(2, 0));
    arr.Add(new pair<int, int>(2, 1));
    arr.Add(new pair<int, int>(2, 2));

    // Function call
    findPoint(N, arr);
  }
}

// This code is contributed by phasing17

Javascript

// JavaScript program for the above approach

// Function to find the point that is
// not a part of the side of a square
function findPoint(n, p)
{
    // Traverse each pair of coordinates
    for (let i = 0; i < n * 4 + 1; ++i) {

        let x1 = 2e9, x2 = -2e9;
        let y1 = 2e9, y2 = -2e9;

        for (let 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[j][0]);

                // Maximize x-coordinate in
                // all the points except
                // the current point
                x2 = Math.max(x2, p[j][0]);

                // Minimize y-coordinate
                // in all the points
                // except current point
                y1 = Math.min(y1, p[j][1]);

                // Maximize y-coordinate
                // in all the points
                // except current point
                y2 = Math.max(y2, p[j][1]);
            }
        }

        let ok = 1;

        let c1 = 0, c2 = 0;
        let c3 = 0, c4 = 0;

        for (let j = 1; j < n * 4 + 1; ++j){
            if (i != j) {

                // If x-coordinate matches
                // with other same line
                if ((p[j][0] == x1 || p[j][0] == x2) || (p[j][1] == y1 || p[j][1] == y2)) {

                    if (p[j][0] == x1)
                        ++c1;

                    if (p[j][0] == x2)
                        ++c2;

                    // If y coordinate matches
                    // with other same line
                    if (p[j][1] == y1)
                        ++c3;

                    if (p[j][1] == 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
            console.log(p[i][0] + " " + p[i][1]);
        }
    }
}

// Driver Code

let N = 2;
let arr =  [[0, 0], [0, 1], [0, 2],
        [1, 0], [1, 1], [1, 2 ],
        [2, 0], [2, 1], [2, 2]];

findPoint(N, arr);

// The code is contributed by Gautam goel(gautamgoel962)

Output:

1 1

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