# Check if a right-angled triangle can be formed by moving any one of the coordinates

• Difficulty Level : Medium
• Last Updated : 13 Mar, 2022

Given three coordinates of a triangle (x1, y1), (x2, y2), (x3, y3). The task is to find out if the triangle can be transformed to a right-angled triangle by moving only one point exactly by the distance 1.
If it is possible to make the triangle right-angled, then print “POSSIBLE”, else print “NOT POSSIBLE”
If the triangle is already right-angled, it should also be reported.
Examples:

Input:
x1 = -1, y1 = 0
x2 = 2, y2 = 0
x3 = 0, y3 = 1
Output: POSSIBLE
First co-ordinate (-1, 0) can be changed to (0, 0) and make it right-angled
Input:
x1 = 36, y1 = 1
x2 = -17, y2 = -54
x3 = -19, y3 = 55
Output: POSSIBLE

Approach:
As it is known that for a triangle of sides a, b and c, the triangle will be right-angled if the following equation holds true : a2 + b2 = c2
So for every co-ordinates of the triangle, find out all the sides and for the 3 possible permutations of them check if it is already right-angle triangle and report it.
If the above condition doesn’t hold true, then the following operations need to be done-
We need to change all the co-ordinates by 1 one by one and check that is it a valid combination for a right-angled triangle.
Look that there can be 4 possible combinations to change every co-ordinates by 1. They are (-1, 0), (0, 1), (1, 0), (0, -1). So run a loop and apply those changes one by one for every co-ordinates and check that the formula a2 + b2 = c2 is true or not.
If it’s true then it is possible to transform the triangle to a right-angled triangle, otherwise not.
Below is the implementation of the above code:

## C++

 `// C++ implementation of``// the above approach``#include ``using` `namespace` `std;` `// Storing all the possible``// changes to make the triangle``// right-angled``int` `dx[] = { -1, 0, 1, 0 };``int` `dy[] = { 0, 1, 0, -1 };` `// Function to check if the triangle``// is right-angled or not``int` `ifRight(``int` `x1, ``int` `y1,``            ``int` `x2, ``int` `y2,``            ``int` `x3, ``int` `y3)``{` `    ``int` `a = ((x1 - x2) * (x1 - x2))``            ``+ ((y1 - y2) * (y1 - y2));` `    ``int` `b = ((x1 - x3) * (x1 - x3))``            ``+ ((y1 - y3) * (y1 - y3));` `    ``int` `c = ((x2 - x3) * (x2 - x3))``            ``+ ((y2 - y3) * (y2 - y3));` `    ``if` `((a == (b + c) && a != 0 && b != 0 && c != 0)``        ``|| (b == (a + c) && a != 0 && b != 0 && c != 0)``        ``|| (c == (a + b) && a != 0 && b != 0 && c != 0)) {``        ``return` `1;``    ``}` `    ``return` `0;``}` `// Function to check if the triangle``// can be transformed to right-angled``void` `isValidCombination(``int` `x1, ``int` `y1,``                        ``int` `x2, ``int` `y2,``                        ``int` `x3, ``int` `y3)``{``    ``int` `x, y;` `    ``// Boolean variable to``    ``// return true or false``    ``bool` `possible = 0;` `    ``// If it is already right-angled``    ``if` `(ifRight(x1, y1,``                ``x2, y2,``                ``x3, y3)) {``        ``cout << ``"ALREADY RIGHT ANGLED"``;``        ``return``;``    ``}``    ``else` `{` `        ``// Applying the changes on the``        ``// co-ordinates``        ``for` `(``int` `i = 0; i < 4; i++) {` `            ``// Applying on the first``            ``// co-ordinate``            ``x = dx[i] + x1;``            ``y = dy[i] + y1;` `            ``if` `(ifRight(x, y,``                        ``x2, y2,``                        ``x3, y3)) {``                ``cout << ``"POSSIBLE"``;``                ``return``;``            ``}` `            ``// Applying on the second``            ``// co-ordinate``            ``x = dx[i] + x2;``            ``y = dy[i] + y2;` `            ``if` `(ifRight(x1, y1,``                        ``x, y,``                        ``x3, y3)) {``                ``cout << ``"POSSIBLE"``;``                ``return``;``            ``}` `            ``// Applying on the third``            ``// co-ordinate``            ``x = dx[i] + x3;``            ``y = dy[i] + y3;` `            ``if` `(ifRight(x1, y1,``                        ``x2, y2,``                        ``x, y)) {``                ``cout << ``"POSSIBLE"``;``                ``return``;``            ``}``        ``}``    ``}` `    ``// If can't be transformed``    ``if` `(!possible)``        ``cout << ``"NOT POSSIBLE"` `<< endl;``}` `// Driver Code``int` `main()` `{``    ``int` `x1 = -49, y1 = 0;``    ``int` `x2 = 0, y2 = 50;``    ``int` `x3 = 0, y3 = -50;` `    ``isValidCombination(x1, y1,``                       ``x2, y2,``                       ``x3, y3);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;``class` `GFG``{` `// Storing all the possible``// changes to make the triangle``// right-angled``static` `int` `dx[] = { -``1``, ``0``, ``1``, ``0` `};``static` `int` `dy[] = { ``0``, ``1``, ``0``, -``1` `};` `// Function to check if the triangle``// is right-angled or not``static` `boolean` `ifRight(``int` `x1, ``int` `y1,``                       ``int` `x2, ``int` `y2,``                       ``int` `x3, ``int` `y3)``{``    ``int` `a = ((x1 - x2) * (x1 - x2)) +``            ``((y1 - y2) * (y1 - y2));` `    ``int` `b = ((x1 - x3) * (x1 - x3)) +``            ``((y1 - y3) * (y1 - y3));` `    ``int` `c = ((x2 - x3) * (x2 - x3)) +``            ``((y2 - y3) * (y2 - y3));` `    ``if` `((a == (b + c) && a != ``0` `&& b != ``0` `&& c != ``0``) ||``        ``(b == (a + c) && a != ``0` `&& b != ``0` `&& c != ``0``) ||``        ``(c == (a + b) && a != ``0` `&& b != ``0` `&& c != ``0``))``    ``{``        ``return` `true``;``    ``}``    ``return` `false``;``}` `// Function to check if the triangle``// can be transformed to right-angled``static` `void` `isValidCombination(``int` `x1, ``int` `y1,``                               ``int` `x2, ``int` `y2,``                               ``int` `x3, ``int` `y3)``{``    ``int` `x, y;` `    ``// Boolean variable to``    ``// return true or false``    ``boolean` `possible = ``false``;` `    ``// If it is already right-angled``    ``if` `(ifRight(x1, y1, x2, y2, x3, y3))``    ``{``        ``System.out.print(``"ALREADY RIGHT ANGLED"``);``        ``return``;``    ``}``    ``else``    ``{` `        ``// Applying the changes on the``        ``// co-ordinates``        ``for` `(``int` `i = ``0``; i < ``4``; i++)``        ``{` `            ``// Applying on the first``            ``// co-ordinate``            ``x = dx[i] + x1;``            ``y = dy[i] + y1;` `            ``if` `(ifRight(x, y, x2, y2, x3, y3))``            ``{``                ``System.out.print(``"POSSIBLE"``);``                ``return``;``            ``}` `            ``// Applying on the second``            ``// co-ordinate``            ``x = dx[i] + x2;``            ``y = dy[i] + y2;` `            ``if` `(ifRight(x1, y1, x, y, x3, y3))``            ``{``                ``System.out.print(``"POSSIBLE"``);``                ``return``;``            ``}` `            ``// Applying on the third``            ``// co-ordinate``            ``x = dx[i] + x3;``            ``y = dy[i] + y3;` `            ``if` `(ifRight(x1, y1, x2, y2, x, y))``            ``{``                ``System.out.print(``"POSSIBLE"``);``                ``return``;``            ``}``        ``}``    ``}` `    ``// If can't be transformed``    ``if` `(!possible)``        ``System.out.println(``"NOT POSSIBLE"``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `x1 = -``49``, y1 = ``0``;``    ``int` `x2 = ``0``, y2 = ``50``;``    ``int` `x3 = ``0``, y3 = -``50``;` `    ``isValidCombination(x1, y1, x2, y2, x3, y3);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the above approach` `# Storing all the possible``# changes to make the triangle``# right-angled``dx ``=` `[``-``1``, ``0``, ``1``, ``0``]``dy ``=` `[``0``, ``1``, ``0``, ``-``1``]` `# Function to check if the triangle``# is right-angled or not``def` `ifRight(x1, y1, x2, y2, x3, y3):` `    ``a ``=` `((x1 ``-` `x2) ``*` `(x1 ``-` `x2)) ``+` `\``        ``((y1 ``-` `y2) ``*` `(y1 ``-` `y2))` `    ``b ``=` `((x1 ``-` `x3) ``*` `(x1 ``-` `x3)) ``+` `\``        ``((y1 ``-` `y3) ``*` `(y1 ``-` `y3))` `    ``c ``=` `((x2 ``-` `x3) ``*` `(x2 ``-` `x3)) ``+` `\``        ``((y2 ``-` `y3) ``*` `(y2 ``-` `y3))` `    ``if` `((a ``=``=` `(b ``+` `c) ``and` `a !``=` `0` `and` `b !``=` `0` `and` `c !``=` `0``) ``or``        ``(b ``=``=` `(a ``+` `c) ``and` `a !``=` `0` `and` `b !``=` `0` `and` `c !``=` `0``) ``or``        ``(c ``=``=` `(a ``+` `b) ``and` `a !``=` `0` `and` `b !``=` `0` `and` `c !``=` `0``)):``        ``return` `1` `# Function to check if the triangle``# can be transformed to right-angled``def` `isValidCombination(x1, y1, x2, y2, x3, y3):` `    ``x, y ``=` `0``, ``0` `    ``# Boolean variable to``    ``# return true or false``    ``possible ``=` `0` `    ``# If it is already right-angled``    ``if` `(ifRight(x1, y1, x2, y2, x3, y3)):``        ``print``(``"ALREADY RIGHT ANGLED"``)``        ``return` `    ``else``:` `        ``# Applying the changes on the``        ``# co-ordinates``        ``for` `i ``in` `range``(``4``):` `            ``# Applying on the first``            ``# co-ordinate``            ``x ``=` `dx[i] ``+` `x1``            ``y ``=` `dy[i] ``+` `y1` `            ``if` `(ifRight(x, y, x2, y2, x3, y3)):``                ``print``(``"POSSIBLE"``)``                ``return` `            ``# Applying on the second``            ``# co-ordinate``            ``x ``=` `dx[i] ``+` `x2``            ``y ``=` `dy[i] ``+` `y2` `            ``if` `(ifRight(x1, y1, x, y, x3, y3)):``                ``print``(``"POSSIBLE"``)``                ``return` `            ``# Applying on the third``            ``# co-ordinate``            ``x ``=` `dx[i] ``+` `x3``            ``y ``=` `dy[i] ``+` `y3` `            ``if` `(ifRight(x1, y1, x2, y2, x, y)):``                ``print``(``"POSSIBLE"``)``                ``return` `    ``# If can't be transformed``    ``if` `(possible ``=``=` `0``):``        ``print``(``"NOT POSSIBLE"``)` `# Driver Code``x1 ``=` `-``49``y1 ``=` `0``x2 ``=` `0``y2 ``=` `50``x3 ``=` `0``y3 ``=` `-``50` `isValidCombination(x1, y1, x2, y2, x3, y3)` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``// Storing all the possible``    ``// changes to make the triangle``    ``// right-angled``    ``static` `int` `[]dx = { -1, 0, 1, 0 };``    ``static` `int` `[]dy = { 0, 1, 0, -1 };``    ` `    ``// Function to check if the triangle``    ``// is right-angled or not``    ``static` `bool` `ifRight(``int` `x1, ``int` `y1,``                        ``int` `x2, ``int` `y2,``                        ``int` `x3, ``int` `y3)``    ``{``        ``int` `a = ((x1 - x2) * (x1 - x2)) +``                ``((y1 - y2) * (y1 - y2));``    ` `        ``int` `b = ((x1 - x3) * (x1 - x3)) +``                ``((y1 - y3) * (y1 - y3));``    ` `        ``int` `c = ((x2 - x3) * (x2 - x3)) +``                ``((y2 - y3) * (y2 - y3));``    ` `        ``if` `((a == (b + c) && a != 0 && b != 0 && c != 0) ||``            ``(b == (a + c) && a != 0 && b != 0 && c != 0) ||``            ``(c == (a + b) && a != 0 && b != 0 && c != 0))``        ``{``            ``return` `true``;``        ``}``        ``return` `false``;``    ``}``    ` `    ``// Function to check if the triangle``    ``// can be transformed to right-angled``    ``static` `void` `isValidCombination(``int` `x1, ``int` `y1,``                                   ``int` `x2, ``int` `y2,``                                   ``int` `x3, ``int` `y3)``    ``{``        ``int` `x, y;``    ` `        ``// Boolean variable to``        ``// return true or false``        ``bool` `possible = ``false``;``    ` `        ``// If it is already right-angled``        ``if` `(ifRight(x1, y1, x2, y2, x3, y3))``        ``{``            ``Console.WriteLine(``"ALREADY RIGHT ANGLED"``);``            ``return``;``        ``}``        ``else``        ``{``    ` `            ``// Applying the changes on the``            ``// co-ordinates``            ``for` `(``int` `i = 0; i < 4; i++)``            ``{``    ` `                ``// Applying on the first``                ``// co-ordinate``                ``x = dx[i] + x1;``                ``y = dy[i] + y1;``    ` `                ``if` `(ifRight(x, y, x2, y2, x3, y3))``                ``{``                    ``Console.WriteLine(``"POSSIBLE"``);``                    ``return``;``                ``}``    ` `                ``// Applying on the second``                ``// co-ordinate``                ``x = dx[i] + x2;``                ``y = dy[i] + y2;``    ` `                ``if` `(ifRight(x1, y1, x, y, x3, y3))``                ``{``                    ``Console.WriteLine(``"POSSIBLE"``);``                    ``return``;``                ``}``    ` `                ``// Applying on the third``                ``// co-ordinate``                ``x = dx[i] + x3;``                ``y = dy[i] + y3;``    ` `                ``if` `(ifRight(x1, y1, x2, y2, x, y))``                ``{``                    ``Console.Write(``"POSSIBLE"``);``                    ``return``;``                ``}``            ``}``        ``}``    ` `        ``// If can't be transformed``        ``if` `(!possible)``            ``Console.WriteLine(``"NOT POSSIBLE"``);``    ``}``    ` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ``int` `x1 = -49, y1 = 0;``        ``int` `x2 = 0, y2 = 50;``        ``int` `x3 = 0, y3 = -50;``    ` `        ``isValidCombination(x1, y1, x2, y2, x3, y3);``    ``}``}` `// This code is contributed by AnkitRai01`

## Javascript

 ``

Output:

`POSSIBLE`

Time Complexity: O(1)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up