 Open in App
Not now

# Check if four segments form a rectangle

• Difficulty Level : Medium
• Last Updated : 08 Feb, 2023

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.

## CPP

 `// C++ program to check whether it is possible ` `// to make a rectangle from 4 segments ` `#include ` `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; ` `    ``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 == distance); `   `    ``// distance of sides should satisfy pythagorean ` `    ``// theorem ` `    ``return` `(distance + distance == distance); ` `} `   `// 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"``; ` `} `

## Java

 `/*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 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 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.`

## Python3

 `# 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#

 `// 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> st = ``new` `HashSet>();`   `    ``// 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``; ` `    ``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 == distance); `   `    ``// distance of sides should satisfy pythagorean ` `    ``// theorem ` `    ``return` `(distance + distance == distance); ` `  ``} `     `  ``// 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

 `// 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) - parseInt(b))*(parseInt(a) - parseInt(b)) + (parseInt(a) - parseInt(b))*(parseInt(a) - parseInt(b)); ` `} `   `// 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], segments[i]];` `        ``let tmp2 = [segments[i], segments[i]];` `        ``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 == distance); ` `    ``}`   `    ``// distance of sides should satisfy pythagorean ` `    ``// theorem ` `    ``return` `(distance + distance == distance); ` `} `   `// 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)

This article is contributed by Aarti_Rathi and Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.