# Check if the tower of sight issue occurs or not

Given four co-ordinates A, B, C and D where towers need to be constructed, the task is to check if the tower of sight issue occurs or not.

Tower of sight issue occurs if the towers at A or C lies in the line joining B and D or vice versa.

Examples:

Input: A = (0, 0), B = (0, -2), C = (2, 0), D = (0, 2)
Output: Yes
Explanation:
Tower A lies in the line joining B and D.

Input: A = (0, 0), B = (0, -2), C = (2, 0), D = (0, -5)
Output: No
Explanation:
No intersection occurs.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• If A and C are parallel to the X-axis, check if B or D has y coordinate equal to that of A and C and x coordinate in between that of A and C.
• If A and C are parallel to the Y-axis, check if B or D has x coordinate equal to that of A and C and y coordinate in between that of A and C.
• Otherwise, check if B or D satisfies the line equation of A and C.
• Similarly follow the above three steps to check if A or C lies in between B or D.

Below code is the implementation of the above approach:

## C++

 `// C++ program to check if tower ` `// of sight issue occurs or not ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to check if point p lies in ` `// between the line joining p1 and p2 ` `int` `checkIntersection(pair<``int``, ``int``> p1, ` `                      ``pair<``int``, ``int``> p2, ` `                      ``pair<``int``, ``int``> p) ` `{ ` `    ``int` `val; ` ` `  `    ``// If parallel to X-axis ` `    ``if` `(p1.second == p2.second ` `        ``&& p1.second == p.second) { ` ` `  `        ``if` `(p.first <= max(p1.first, p2.first) ` `            ``&& (p.first >= min(p1.first, p2.first))) ` ` `  `            ``// Point p lies between p1 and p2 ` `            ``return` `1; ` `    ``} ` ` `  `    ``// If parallel to Y-axis ` `    ``if` `(p1.first == p2.first ` `        ``&& p1.first == p.first) { ` ` `  `        ``if` `(p.second <= max(p1.second, p2.second) ` `            ``&& (p.second >= min(p1.second, p2.second))) ` ` `  `            ``// Point p lies between p1 and p2 ` `            ``return` `1; ` `    ``} ` ` `  `    ``// If point p satisfies the equation ` `    ``// of line joining p1 and p2 ` `    ``else` `{ ` `        ``val = (p.second - p1.second) ` `                  ``* (p2.first - p1.first) ` `              ``- (p.first - p1.first) ` `                    ``* (p2.second - p1.second); ` ` `  `        ``if` `(val == 0) ` `            ``if` `((p.first <= max(p1.first, p2.first) ` `                 ``&& (p.first >= min(p1.first, p2.first))) ` `                ``&& (p.second <= max(p1.second, p2.second) ` `                    ``&& (p.second >= min(p1.second, p2.second)))) ` `                ``return` `1; ` `    ``} ` ` `  `    ``return` `0; ` `} ` ` `  `// Function to check if tower ` `// of sight issue occurred ` `void` `towerOfSight(pair<``int``, ``int``> a, ` `                  ``pair<``int``, ``int``> b, ` `                  ``pair<``int``, ``int``> c, ` `                  ``pair<``int``, ``int``> d) ` `{ ` `    ``int` `flag = 0; ` ` `  `    ``if` `(checkIntersection(a, c, b)) ` ` `  `        ``// B lies between AC ` `        ``flag = 1; ` ` `  `    ``else` `if` `(checkIntersection(a, c, d)) ` ` `  `        ``// D lies between AC ` `        ``flag = 1; ` ` `  `    ``else` `if` `(checkIntersection(b, d, a)) ` ` `  `        ``// A lies between BD ` `        ``flag = 1; ` ` `  `    ``else` `if` `(checkIntersection(b, d, c)) ` ` `  `        ``// C lies between BD ` `        ``flag = 1; ` ` `  `    ``flag ? cout << ``"Yes\n"` `         ``: cout << ``"No\n"``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Point A ` `    ``pair<``int``, ``int``> a = { 0, 0 }; ` ` `  `    ``// Point B ` `    ``pair<``int``, ``int``> b = { 0, -2 }; ` ` `  `    ``// Point C ` `    ``pair<``int``, ``int``> c = { 2, 0 }; ` ` `  `    ``// Point D ` `    ``pair<``int``, ``int``> d = { 0, 2 }; ` ` `  `    ``towerOfSight(a, b, c, d); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to check if tower ` `// of sight issue occurs or not ` `class` `GFG{ ` ` `  `static` `class` `pair ` `{  ` `    ``int` `first, second;  ` `    ``public` `pair(``int` `first, ``int` `second)   ` `    ``{  ` `        ``this``.first = first;  ` `        ``this``.second = second;  ` `    ``}     ` `} ` `   `  `// Function to check if point p lies in ` `// between the line joining p1 and p2 ` `static` `int` `checkIntersection(pair p1, ` `                      ``pair p2, ` `                      ``pair p) ` `{ ` `    ``int` `val; ` `  `  `    ``// If parallel to X-axis ` `    ``if` `(p1.second == p2.second ` `        ``&& p1.second == p.second) { ` `  `  `        ``if` `(p.first <= Math.max(p1.first, p2.first) ` `            ``&& (p.first >= Math.min(p1.first, p2.first))) ` `  `  `            ``// Point p lies between p1 and p2 ` `            ``return` `1``; ` `    ``} ` `  `  `    ``// If parallel to Y-axis ` `    ``if` `(p1.first == p2.first ` `        ``&& p1.first == p.first) { ` `  `  `        ``if` `(p.second <= Math.max(p1.second, p2.second) ` `            ``&& (p.second >= Math.min(p1.second, p2.second))) ` `  `  `            ``// Point p lies between p1 and p2 ` `            ``return` `1``; ` `    ``} ` `  `  `    ``// If point p satisfies the equation ` `    ``// of line joining p1 and p2 ` `    ``else` `{ ` `        ``val = (p.second - p1.second) ` `                  ``* (p2.first - p1.first) ` `              ``- (p.first - p1.first) ` `                    ``* (p2.second - p1.second); ` `  `  `        ``if` `(val == ``0``) ` `            ``if` `((p.first <= Math.max(p1.first, p2.first) ` `                 ``&& (p.first >= Math.min(p1.first, p2.first))) ` `                ``&& (p.second <= Math.max(p1.second, p2.second) ` `                    ``&& (p.second >= Math.min(p1.second, p2.second)))) ` `                ``return` `1``; ` `    ``} ` `  `  `    ``return` `0``; ` `} ` `  `  `// Function to check if tower ` `// of sight issue occurred ` `static` `void` `towerOfSight(pair a, ` `                  ``pair b, ` `                  ``pair c, ` `                  ``pair d) ` `{ ` `    ``int` `flag = ``0``; ` `  `  `    ``if` `(checkIntersection(a, c, b) == ``1``) ` `  `  `        ``// B lies between AC ` `        ``flag = ``1``; ` `  `  `    ``else` `if` `(checkIntersection(a, c, d) == ``1``) ` `  `  `        ``// D lies between AC ` `        ``flag = ``1``; ` `  `  `    ``else` `if` `(checkIntersection(b, d, a) == ``1``) ` `  `  `        ``// A lies between BD ` `        ``flag = ``1``; ` `  `  `    ``else` `if` `(checkIntersection(b, d, c) == ``1``) ` `  `  `        ``// C lies between BD ` `        ``flag = ``1``; ` `  `  `    ``System.out.print(flag==``1``?``"Yes\n"``:``"No\n"``); ` `} ` `  `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// Point A ` `    ``pair a = ``new` `pair( ``0``, ``0` `); ` `  `  `    ``// Point B ` `    ``pair b = ``new` `pair( ``0``, -``2` `); ` `  `  `    ``// Point C ` `    ``pair c = ``new` `pair( ``2``, ``0` `); ` `  `  `    ``// Point D ` `    ``pair d = ``new` `pair( ``0``, ``2` `); ` `  `  `    ``towerOfSight(a, b, c, d); ` `  `  `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python 3 program to check if tower ` `# of sight issue occurs or not ` `  `  `# Function to check if point p lies in ` `# between the line joining p1 and p2 ` `def` `checkIntersection(p1,p2,p): ` `  `  `    ``# If parallel to X-axis ` `    ``if` `(p1[``1``] ``=``=` `p2[``1``] ` `        ``and` `p1[``1``] ``=``=` `p[``1``]): ` `  `  `        ``if` `(p[``0``] <``=` `max``(p1[``0``], p2[``0``]) ` `            ``and` `(p[``0``] >``=` `min``(p1[``0``], p2[``0``]))): ` `  `  `            ``# Point p lies between p1 and p2 ` `            ``return` `1` `  `  `    ``# If parallel to Y-axis ` `    ``if` `(p1[``0``] ``=``=` `p2[``0``] ` `        ``and` `p1[``0``] ``=``=` `p[``0``]): ` `  `  `        ``if` `(p[``1``] <``=` `max``(p1[``1``], p2[``1``]) ` `            ``and` `(p[``1``] >``=` `min``(p1[``1``], p2[``1``]))): ` `  `  `            ``# Point p lies between p1 and p2 ` `            ``return` `1` `  `  `    ``# If point p satisfies the equation ` `    ``# of line joining p1 and p2 ` `    ``else` `: ` `        ``val ``=` `((p[``1``] ``-` `p1[``1``])``*``(p2[``0``] ``-` `p1[``0``]) ` `              ``-` `(p[``0``] ``-` `p1[``0``]) ` `                    ``*` `(p2[``1``] ``-` `p1[``1``])) ` `  `  `        ``if` `(val ``=``=` `0``): ` `            ``if` `((p[``0``] <``=` `max``(p1[``0``], p2[``0``]) ` `                 ``and` `(p[``0``] >``=` `min``(p1[``0``], p2[``0``]))) ` `                ``and` `(p[``1``] <``=` `max``(p1[``1``], p2[``1``]) ` `                    ``and` `(p[``1``] >``=` `min``(p1[``1``], p2[``1``])))): ` `                ``return` `1` `  `  `    ``return` `0` `  `  `# Function to check if tower ` `# of sight issue occurred ` `def` `towerOfSight(a, b, c, d): ` `    ``flag ``=` `0` `  `  `    ``if` `(checkIntersection(a, c, b)): ` `  `  `        ``# B lies between AC ` `        ``flag ``=` `1` `  `  `    ``elif` `(checkIntersection(a, c, d)): ` `        ``# D lies between AC ` `        ``flag ``=` `1` `  `  `    ``elif` `(checkIntersection(b, d, a)): ` `  `  `        ``# A lies between BD ` `        ``flag ``=` `1` `  `  `    ``elif` `(checkIntersection(b, d, c)): ` `  `  `        ``# C lies between BD ` `        ``flag ``=` `1` `  `  `    ``if``(flag): ` `        ``print``(``"Yes"``) ` `    ``else``: ` `        ``print``(``"No"``) ` `  `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``# Point A ` `    ``a ``=` `[ ``0``, ``0` `] ` `  `  `    ``# Point B ` `    ``b ``=` `[ ``0``, ``-``2` `] ` `  `  `    ``# Point C ` `    ``c ``=` `[ ``2``, ``0` `] ` `  `  `    ``# Point D ` `    ``d ``=` `[ ``0``, ``2` `] ` `  `  `    ``towerOfSight(a, b, c, d) ` `  `  `# This code is contributed by chitranayal `

## C#

 `// C# program to check if tower ` `// of sight issue occurs or not ` `using` `System; ` ` `  `class` `GFG{ ` `  `  `class` `pair ` `{  ` `    ``public` `int` `first, second;  ` `    ``public` `pair(``int` `first, ``int` `second)   ` `    ``{  ` `        ``this``.first = first;  ` `        ``this``.second = second;  ` `    ``}     ` `} ` `    `  `// Function to check if point p lies in ` `// between the line joining p1 and p2 ` `static` `int` `checkIntersection(pair p1, ` `                      ``pair p2, ` `                      ``pair p) ` `{ ` `    ``int` `val; ` `   `  `    ``// If parallel to X-axis ` `    ``if` `(p1.second == p2.second ` `        ``&& p1.second == p.second) { ` `   `  `        ``if` `(p.first <= Math.Max(p1.first, p2.first) ` `            ``&& (p.first >= Math.Min(p1.first, p2.first))) ` `   `  `            ``// Point p lies between p1 and p2 ` `            ``return` `1; ` `    ``} ` `   `  `    ``// If parallel to Y-axis ` `    ``if` `(p1.first == p2.first ` `        ``&& p1.first == p.first) { ` `   `  `        ``if` `(p.second <= Math.Max(p1.second, p2.second) ` `            ``&& (p.second >= Math.Min(p1.second, p2.second))) ` `   `  `            ``// Point p lies between p1 and p2 ` `            ``return` `1; ` `    ``} ` `   `  `    ``// If point p satisfies the equation ` `    ``// of line joining p1 and p2 ` `    ``else` `{ ` `        ``val = (p.second - p1.second) ` `                  ``* (p2.first - p1.first) ` `              ``- (p.first - p1.first) ` `                    ``* (p2.second - p1.second); ` `   `  `        ``if` `(val == 0) ` `            ``if` `((p.first <= Math.Max(p1.first, p2.first) ` `                 ``&& (p.first >= Math.Min(p1.first, p2.first))) ` `                ``&& (p.second <= Math.Max(p1.second, p2.second) ` `                    ``&& (p.second >= Math.Min(p1.second, p2.second)))) ` `                ``return` `1; ` `    ``} ` `   `  `    ``return` `0; ` `} ` `   `  `// Function to check if tower ` `// of sight issue occurred ` `static` `void` `towerOfSight(pair a, ` `                  ``pair b, ` `                  ``pair c, ` `                  ``pair d) ` `{ ` `    ``int` `flag = 0; ` `   `  `    ``if` `(checkIntersection(a, c, b) == 1) ` `   `  `        ``// B lies between AC ` `        ``flag = 1; ` `   `  `    ``else` `if` `(checkIntersection(a, c, d) == 1) ` `   `  `        ``// D lies between AC ` `        ``flag = 1; ` `   `  `    ``else` `if` `(checkIntersection(b, d, a) == 1) ` `   `  `        ``// A lies between BD ` `        ``flag = 1; ` `   `  `    ``else` `if` `(checkIntersection(b, d, c) == 1) ` `   `  `        ``// C lies between BD ` `        ``flag = 1; ` `   `  `    ``Console.Write(flag==1?``"Yes\n"``:``"No\n"``); ` `} ` `   `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``// Point A ` `    ``pair a = ``new` `pair( 0, 0 ); ` `   `  `    ``// Point B ` `    ``pair b = ``new` `pair( 0, -2 ); ` `   `  `    ``// Point C ` `    ``pair c = ``new` `pair( 2, 0 ); ` `   `  `    ``// Point D ` `    ``pair d = ``new` `pair( 0, 2 ); ` `   `  `    ``towerOfSight(a, b, c, d); ` `   `  `} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```Yes
```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.