Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Medium
  • Last Updated : 05 May, 2021

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




// 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




<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>
Output: 
POSSIBLE

 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :