We are given four segments as a pair of coordinates of their end points. We need to tell whether those four line segments make a rectangle or not.
Examples:
Input : segments[] = [(4, 2), (7, 5),
(2, 4), (4, 2),
(2, 4), (5, 7),
(5, 7), (7, 5)]
Output : Yes
Given these segment make a rectangle of length 3X2.
Input : segment[] = [(7, 0), (10, 0),
(7, 0), (7, 3),
(7, 3), (10, 2),
(10, 2), (10, 0)]
Output : Not
These segments do not make a rectangle.
Above examples are shown in below diagram.
This problem is mainly an extension of How to check if given four points form a square
We can solve this problem by using properties of a rectangle. First, we check total unique end points of segments, if count of these points is not equal to 4 then the line segment can’t make a rectangle. Then we check distances between all pair of points, there should be at most 3 different distances, one for diagonal and two for sides and at the end we will check the relation among these three distances, for line segments to make a rectangle these distance should satisfy Pythagorean relation because sides and diagonal of rectangle makes a right angle triangle. If they satisfy mentioned conditions then we will flag polygon made by line segment as rectangle otherwise not.
// C++ program to check whether it is possible
// to make a rectangle from 4 segments
#include <bits/stdc++.h>
using namespace std;
#define N 4
// structure to represent a segment
struct Segment
{
int ax, ay;
int bx, by;
};
// Utility method to return square of distance
// between two points
int getDis(pair<int, int> a, pair<int, int> b)
{
return (a.first - b.first)*(a.first - b.first) +
(a.second - b.second)*(a.second - b.second);
}
// method returns true if line Segments make
// a rectangle
bool isPossibleRectangle(Segment segments[])
{
set< pair<int, int> > st;
// putting all end points in a set to
// count total unique points
for (int i = 0; i < N; i++)
{
st.insert(make_pair(segments[i].ax, segments[i].ay));
st.insert(make_pair(segments[i].bx, segments[i].by));
}
// If total unique points are not 4, then
// they can't make a rectangle
if (st.size() != 4)
return false;
// dist will store unique 'square of distances'
set<int> dist;
// calculating distance between all pair of
// end points of line segments
for (auto it1=st.begin(); it1!=st.end(); it1++)
for (auto it2=st.begin(); it2!=st.end(); it2++)
if (*it1 != *it2)
dist.insert(getDis(*it1, *it2));
// if total unique distance are more than 3,
// then line segment can't make a rectangle
if (dist.size() > 3)
return false;
// copying distance into array. Note that set maintains
// sorted order.
int distance[3];
int i = 0;
for (auto it = dist.begin(); it != dist.end(); it++)
distance[i++] = *it;
// If line seqments form a square
if (dist.size() == 2)
return (2*distance[0] == distance[1]);
// distance of sides should satisfy pythagorean
// theorem
return (distance[0] + distance[1] == distance[2]);
}
// Driver code to test above methods
int main()
{
Segment segments[] =
{
{4, 2, 7, 5},
{2, 4, 4, 2},
{2, 4, 5, 7},
{5, 7, 7, 5}
};
(isPossibleRectangle(segments))?cout << "Yes\n":cout << "No\n";
}
/*package whatever //do not write package name here */
import java.io.*;
import java.util.*;
// java program to check whether it is possible
// to make a rectangle from 4 segments
public class Main {
static int N = 4;
// Utility method to return square of distance
// between two points
public static int getDis(String a, String b)
{
String[] a1 = a.split(",");
String[] b1 = b.split(",");
return (Integer.parseInt(a1[0]) - Integer.parseInt(b1[0]))*(Integer.parseInt(a1[0]) - Integer.parseInt(b1[0])) + (Integer.parseInt(a1[1]) - Integer.parseInt(b1[1]))*(Integer.parseInt(a1[1]) - Integer.parseInt(b1[1]));
}
// method returns true if line Segments make
// a rectangle
public static boolean isPossibleRectangle(int[][] segments)
{
HashSet<String> st = new HashSet<>();
// putting all end points in a set to
// count total unique points
for (int i = 0; i < N; i++)
{
st.add(segments[i][0] + "," + segments[i][1]);
st.add(segments[i][2] + "," + segments[i][3]);
}
// If total unique points are not 4, then
// they can't make a rectangle
if (st.size() != 4)
return false;
// dist will store unique 'square of distances'
HashSet<Integer> dist = new HashSet<>();
// calculating distance between all pair of
// end points of line segments
for(String it1 : st){
for(String it2 : st){
if(it1 != it2){
dist.add(getDis(it1, it2));
}
}
}
// if total unique distance are more than 3,
// then line segment can't make a rectangle
if (dist.size() > 3)
return false;
// copying distance into array. Note that set maintains
// sorted order.
int[] distance = new int[3];
int i = 0;
for(int it: dist){
distance[i] = it;
i = i + 1;
}
// If line seqments form a square
if (dist.size() == 2)
return (2*distance[0] == distance[1]);
// distance of sides should satisfy pythagorean
// theorem
return (distance[0] + distance[1] == distance[2]);
}
public static void main(String[] args) {
int[][] segments =
{
{4, 2, 7, 5},
{2, 4, 4, 2},
{2, 4, 5, 7},
{5, 7, 7, 5}
};
if(isPossibleRectangle(segments) == true){
System.out.println("Yes");
}
else{
System.out.println("No");
}
}
}
// The code is contributed by Nidhi goel.
# Python program to check whether it is possible
# to make a rectangle from 4 segments
N = 4
# Utility method to return square of distance
# between two points
def getDis(a, b):
return (a[0] - b[0])*(a[0] - b[0]) + (a[1] - b[1])*(a[1] - b[1])
# method returns true if line Segments make
# a rectangle
def isPossibleRectangle(segments):
st = set()
# putting all end points in a set to
# count total unique points
for i in range(N):
st.add((segments[i][0], segments[i][1]))
st.add((segments[i][2], segments[i][3]))
# If total unique points are not 4, then
# they can't make a rectangle
if len(st) != 4:
return False
# dist will store unique 'square of distances'
dist = set()
# calculating distance between all pair of
# end points of line segments
for it1 in st:
for it2 in st:
if it1 != it2:
dist.add(getDis(it1, it2))
# if total unique distance are more than 3,
# then line segment can't make a rectangle
if len(dist) > 3:
return False
# copying distance into array. Note that set maintains
# sorted order.
distance = []
for x in dist:
distance.append(x)
# Sort the distance list, as set in python, does not sort the elements by default.
distance.sort()
# If line seqments form a square
if len(dist) ==2 :
return (2*distance[0] == distance[1])
# distance of sides should satisfy pythagorean
# theorem
return (distance[0] + distance[1] == distance[2])
# Driver code to test above methods
segments = [
[4, 2, 7, 5],
[2, 4, 4, 2],
[2, 4, 5, 7],
[5, 7, 7, 5]
]
if(isPossibleRectangle(segments) == True):
print("Yes")
else:
print("No")
# The code is contributed by Nidhi goel.
// C# program to check whether it is possible
// to make a rectangle from 4 segments
using System;
using System.Collections.Generic;
class GFG {
public static int N = 4;
// Utility method to return square of distance
// between two points
public static int getDis(KeyValuePair<int,int> a, KeyValuePair<int,int> b)
{
return (a.Key - b.Key)*(a.Key - b.Key) +
(a.Value - b.Value)*(a.Value - b.Value);
}
// method returns true if line Segments make
// a rectangle
public static bool isPossibleRectangle(int[,] segments)
{
HashSet<KeyValuePair<int, int>> st = new HashSet<KeyValuePair<int, int>>();
// putting all end points in a set to
// count total unique points
for (int j = 0; j < N; j++)
{
st.Add(new KeyValuePair<int, int>(segments[j,0], segments[j,1]));
st.Add(new KeyValuePair<int, int>(segments[j,2], segments[j,3]));
}
// If total unique points are not 4, then
// they can't make a rectangle
if (st.Count != 4)
return false;
// dist will store unique 'square of distances'
HashSet<int> dist = new HashSet<int>();
// calculating distance between all pair of
// end points of line segments
foreach(var it1 in st){
foreach(var it2 in st){
if(it1.Key != it2.Key && it1.Value != it2.Value){
dist.Add(getDis(it1, it2));
}
}
}
// if total unique distance are more than 3,
// then line segment can't make a rectangle
if (dist.Count > 3)
return false;
// copying distance into array. Note that set maintains
// sorted order.
int[] distance = new int[3];
int i = 0;
foreach(var it in dist){
distance[i] = it;
i = i + 1;
}
// If line seqments form a square
if (dist.Count == 2)
return (2*distance[0] == distance[1]);
// distance of sides should satisfy pythagorean
// theorem
return (distance[0] + distance[1] == distance[2]);
}
// Driver code
public static void Main()
{
int[,] segments = {
{4, 2, 7, 5},
{2, 4, 4, 2},
{2, 4, 5, 7},
{5, 7, 7, 5}
};
if(isPossibleRectangle(segments) == true){
Console.WriteLine("Yes");
}
else{
Console.WriteLine("No");
}
}
}
// The code is contributed by Nidhi goel.
// JavaScript program to check whether it is possible
// to make a rectangle from 4 segments
const N = 4;
// Utility method to return square of distance
// between two points
function getDis(a, b)
{
return (parseInt(a[0]) - parseInt(b[0]))*(parseInt(a[0]) - parseInt(b[0])) + (parseInt(a[1]) - parseInt(b[1]))*(parseInt(a[1]) - parseInt(b[1]));
}
// method returns true if line Segments make
// a rectangle
function isPossibleRectangle(segments)
{
let st = new Set();
// putting all end points in a set to
// count total unique points
for (let i = 0; i < N; i++)
{
let tmp1 = [segments[i][0], segments[i][1]];
let tmp2 = [segments[i][2], segments[i][3]];
st.add(tmp1.join(''));
st.add(tmp2.join(''));
}
// If total unique points are not 4, then
// they can't make a rectangle
if (st.size != 4)
{
return false;
}
// dist will store unique 'square of distances'
let dist = new Set();
// calculating distance between all pair of
// end points of line segments
for(let it1 of st)
{
for(let it2 of st)
{
if(it1 !== it2)
{
dist.add(getDis(it1.split(''), it2.split('')));
}
}
}
// if total unique distance are more than 3,
// then line segment can't make a rectangle
if (dist.size > 3)
{
return false;
}
// copying distance into array. Note that set maintains
// sorted order.
let distance = new Array();
for (let x of dist)
{
distance.push(x);
}
// If line seqments form a square
if (dist.size === 2)
{
return (2*distance[0] == distance[1]);
}
// distance of sides should satisfy pythagorean
// theorem
return (distance[0] + distance[1] == distance[2]);
}
// Driver code to test above methods
{
let segments = [
[4, 2, 7, 5],
[2, 4, 4, 2],
[2, 4, 5, 7],
[5, 7, 7, 5] ]
if(isPossibleRectangle(segments)){
console.log("Yes");
}
else{
console.log("No");
}
}
// The code is contributed by Nidhi Goel
Output:
Yes
Time Complexity: O(n2logn)
Auxiliary Space: O(n)