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++ implementation of // the above approach #include <bits/stdc++.h> 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 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 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# 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 |
<script> // Javascript implementation of // the above approach // Storing all the possible // changes to make the triangle // right-angled let dx = [ -1, 0, 1, 0 ]; let dy = [ 0, 1, 0, -1 ]; // Function to check if the triangle // is right-angled or not function ifRight(x1, y1, x2, y2,
x3, y3)
{ let a = ((x1 - x2) * (x1 - x2))
+ ((y1 - y2) * (y1 - y2));
let b = ((x1 - x3) * (x1 - x3))
+ ((y1 - y3) * (y1 - y3));
let 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 function isValidCombination(x1, y1,
x2, y2,
x3, y3)
{ let x, y;
// Boolean variable to
// return true or false
let possible = 0;
// If it is already right-angled
if (ifRight(x1, y1,
x2, y2,
x3, y3)) {
document.write( "ALREADY RIGHT ANGLED" );
return ;
}
else {
// Applying the changes on the
// co-ordinates
for (let 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)) {
document.write( "POSSIBLE" );
return ;
}
// Applying on the second
// co-ordinate
x = dx[i] + x2;
y = dy[i] + y2;
if (ifRight(x1, y1,
x, y,
x3, y3)) {
document.write( "POSSIBLE" );
return ;
}
// Applying on the third
// co-ordinate
x = dx[i] + x3;
y = dy[i] + y3;
if (ifRight(x1, y1,
x2, y2,
x, y)) {
document.write( "POSSIBLE" );
return ;
}
}
}
// If can't be transformed
if (!possible)
document.write( "NOT POSSIBLE<br>" );
} // Driver Code let x1 = -49, y1 = 0;
let x2 = 0, y2 = 50;
let x3 = 0, y3 = -50;
isValidCombination(x1, y1,
x2, y2,
x3, y3);
</script> |
POSSIBLE
Time Complexity: O(1)
Auxiliary Space: O(1)