Skip to content
Related Articles

Related Articles

Improve Article

Number of possible pairs of Hypotenuse and Area to form right angled triangle

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

Given two arrays H and S. The array H[] contains the length of the hypotenuse and the array S[] contains Area of a right-angled triangle. The task is to find all possible pairs of (H, S) such that we can construct a right-angled triangle with hypotenuse H and area S.
Examples
 

Input : H[] = {1, 6, 4}  ;  S[] = {23, 3, 42, 14}
Output : 2 
Possible pairs are {6, 3} {4, 3}

Input : H[] = {1, 6, 4, 3}  ;  S[] = {23, 3, 42, 5}
Output : 3
Possible pairs are {6, 3} {6, 5} {4, 3}

 

Say, 
a     = Base of Right Angled Triangle 
b     = Height of the Right Angled Triangle
Therefore, 
 

area S = (a*b)/2
or, 4*S*S=a*a*b*b

Also, 
 

a2 + b2 = H2

Therefore, 
 



4*S2 = a2(H2-a2)

Solving this quadratic equation in a2 and putting discriminant>=0 (condition for a to exist). We will get, 
 

H2 >= 4*S 

For a right-angled triangle to exist with 
hypotenuse H and area S.

Naive Approach: The naive approach is to find all possible pairs of (H,S) and check if they satisfy the condition, H2 >= 4*S. Count the number of pairs that satisfies this condition and print the count.
Below is the implementation of the naive approach: 
 

C++




#include <iostream>
using namespace std;
 
// Function to check the condition
bool check(int H, int S)
{
    // Condition for triangle to exist
    return H * H >= 4 * S;
}
 
// Function to find all pairs
int findPairs(int H[], int n, int S[], int m)
{
    int count = 0;
 
    // Checking all possible pairs
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (check(H[i], S[j]))
                count++;
        }
    }
 
    return count;
}
 
// Driver code
int main()
{
    int H[] = { 1, 6, 4 };
    int n = sizeof(H)/sizeof(H[0]);
     
    int S[] = { 23, 3, 42, 14 };
    int m = sizeof(S)/sizeof(S[0]);
     
    cout<<findPairs(H, n, S, m);
     
    return 0;
}

Java




class GFG
{
 
// Function to check the condition
static boolean check(int H, int S)
{
    // Condition for triangle to exist
    return H * H >= 4 * S;
}
 
// Function to find all pairs
static int findPairs(int H[], int n,
                     int S[], int m)
{
    int count = 0;
 
    // Checkinag all possible pairs
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (check(H[i], S[j]))
                count++;
        }
    }
 
    return count;
}
 
// Driver code
public static void main(String args[])
{
    int H[] = { 1, 6, 4 };
    int n = H.length;
     
    int S[] = { 23, 3, 42, 14 };
    int m = S.length;
     
    System.out.println(findPairs(H, n, S, m));
}
}
 
// This code is contributed
// by ankita_saini

Python3




# Python 3 implementation
# of above approach
 
# Function to check the condition
def check(H, S) :
 
    # Condition for triangle to exist
    return H * H >= 4 * S
 
# Function to find all pairs
def findPairs(H, n, S, m):
 
    count = 0
 
    # Checking all possible pairs
    for i in range(n) :
        for j in range(m) :
            if check(H[i], S[j]) :
                count += 1
 
    return count
 
# Driver Code
if __name__ == "__main__" :
 
    H = [ 1, 6, 4]
    n = len(H)
 
    S = [ 23, 3, 42, 14]
    m = len(S)
 
    # function calling
    print(findPairs(H, n, S,m))
     
# This code is contributed by ANKITRAI1

C#




// C# implementation of above approach
using System;
 
class GFG
{
 
// Function to check the condition
static bool check(int H, int S)
{
    // Condition for triangle to exist
    return H * H >= 4 * S;
}
 
// Function to find all pairs
static int findPairs(int[] H, int n,
                      int[] S, int m)
{
    int count = 0;
 
    // Checkinag all possible pairs
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (check(H[i], S[j]))
                count++;
        }
    }
 
    return count;
}
 
// Driver code
public static void Main()
{
    int[] H = { 1, 6, 4 };
    int n = H.Length;
     
    int[] S = { 23, 3, 42, 14 };
    int m = S.Length;
     
    Console.Write(findPairs(H, n, S, m));
}
}
 
// This code is contributed
// by ChitraNayal

PHP




<?php
// PHP implementation of above approach
 
// Function to check the condition
function check($H, $S)
{
    // Condition for triangle to exist
    return $H * $H >= 4 * $S;
}
 
// Function to find all pairs
function findPairs($H, $n, $S, $m)
{
    $count = 0;
 
    // Checking all possible pairs
    for ($i = 0; $i < $n; $i++)
    {
        for ($j = 0; $j < $m; $j++)
        {
            if (check($H[$i], $S[$j]))
                $count++;
        }
    }
 
    return $count;
}
 
// Driver code
$H = array( 1, 6, 4 );
$n = count($H);
 
$S = array( 23, 3, 42, 14 );
$m = count($S);
 
echo findPairs($H, $n, $S, $m);
     
// This code is contributed by mits
?>

Javascript




<script>
// Function to check the condition
    function check(H , S)
    {
     
        // Condition for triangle to exist
        return H * H >= 4 * S;
    }
 
    // Function to find all pairs
    function findPairs(H , n , S , m)
    {
        var count = 0;
 
        // Checkinag all possible pairs
        for (let i = 0; i < n; i++) {
            for (let j = 0; j < m; j++) {
                if (check(H[i], S[j]))
                    count++;
            }
        }
 
        return count;
    }
 
    // Driver code
     
    var H = [ 1, 6, 4 ];
    var n = H.length;
 
    var S = [ 23, 3, 42, 14 ];
    var m = S.length;
 
    document.write(findPairs(H, n, S, m));
 
// This code is contributed by Rajput-Ji
</script>
Output: 
2

 

Efficient Approach: An efficient approach is to sort both the arrays available in increasing order. Then, for every possible length of the hypotenuse, apply Binary search to find the maximum area which satisfies the necessary condition.
Say, after the Binary search maximum possible area is available at index 4 in the array S[]. Then we can form 4 such possible pairs since all area less than that at index 4 will also be satisfying the condition.
Below is the implementation of the efficient approach: 
 

C++




#include <bits/stdc++.h>
using namespace std;
 
// Function to check the condition
bool check(int H, int S)
{
    // Condition for triangle to exist
    return H * H >= 4 * S;
}
 
// Function to find all pairs
int findPairs(int H[], int n, int S[], int m)
{
    int count = 0;
     
    // Sort both the arrays
    sort(H, H + n);
    sort(S, S + m);
 
    // To keep track of last possible Area
    int index = -1;
     
    for (int i = 0; i < n; i++) {
        // Apply Binary Search for
        // each Hypotenuse Length
        int start = 0;
        int end = m - 1;
         
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (check(H[i], S[mid])) {
                index = mid;
                start = mid + 1;
            }
            else {
                end = mid - 1;
            }
        }
         
        // Check if we get any
        // possible Area or Not
        if (index != -1) {
            // All area less than area[index]
            // satisfy property
            count += index + 1;
        }
    }
 
    return count;
}
 
// Driver code
int main()
{
    int H[] = { 1, 6, 4 };
    int n = sizeof(H)/sizeof(H[0]);
     
    int S[] = { 23, 3, 42, 14 };
    int m = sizeof(S)/sizeof(S[0]);
     
    cout<<findPairs(H, n, S, m);
     
    return 0;
}

Java




/*package whatever //do not write package name here */
import java.util.Arrays;
import java.io.*;
 
class GFG {
     
// Function to check the condition
static boolean check(int H, int S)
{
    // Condition for triangle to exist
    return H * H >= 4 * S;
}
 
// Function to find all pairs
static int findPairs(int H[], int n, int S[], int m)
{
    int count = 0;
     
    // Sort both the arrays
    Arrays.sort(H);
    Arrays.sort(S);
 
    // To keep track of last possible Area
    int index = -1;
     
    for (int i = 0; i < n; i++) {
        // Apply Binary Search for
        // each Hypotenuse Length
        int start = 0;
        int end = m - 1;
         
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (check(H[i], S[mid])) {
                index = mid;
                start = mid + 1;
            }
            else {
                end = mid - 1;
            }
        }
         
        // Check if we get any
        // possible Area or Not
        if (index != -1) {
            // All area less than area[index]
            // satisfy property
            count += index + 1;
        }
    }
 
    return count;
}
 
// Driver code
    public static void main (String[] args) {
         
    int H[] = { 1, 6, 4 };
    int n = H.length;
     
    int S[] = { 23, 3, 42, 14 };
    int m = S.length;
     
    System.out.println(findPairs(H, n, S, m));
    }
     
// This code is contributed
// by ajit...
}

Python3




# Function to check the condition
def check(H, S):
     
    # Condition for triangle to exist
    return H * H >= 4 * S;
 
# Function to find all pairs
def findPairs(H, n, S, m):
    count = 0;
     
    # Sort both the arrays
    H.sort();
    S.sort();
 
    # To keep track of last possible Area
    index = -1;
     
    for i in range(n):
         
        # Apply Binary Search for
        # each Hypotenuse Length
        start = 0;
        end = m - 1;
         
        while (start <= end):
            mid = int(start + (end - start) / 2);
            if (check(H[i], S[mid])):
                index = mid;
                start = mid + 1;
            else:
                end = mid - 1;
         
        # Check if we get any possible
        # Area or Not
        if (index != -1):
             
            # All area less than area[index]
            # satisfy property
            count += index + 1;
 
    return count;
 
# Driver code
H = [ 1, 6, 4 ];
n = len(H);
 
S= [ 23, 3, 42, 14 ];
m = len(S);
 
print(findPairs(H, n, S, m));
 
# This code is contributed by mits

C#




/*package whatever //do not write package name here */
 
using System;
 
public class GFG{
         
// Function to check the condition
static bool check(int H, int S)
{
    // Condition for triangle to exist
    return H * H >= 4 * S;
}
 
// Function to find all pairs
static int findPairs(int []H, int n, int []S, int m)
{
    int count = 0;
     
    // Sort both the arrays
    Array.Sort(H);
    Array.Sort(S);
 
    // To keep track of last possible Area
    int index = -1;
     
    for (int i = 0; i < n; i++) {
        // Apply Binary Search for
        // each Hypotenuse Length
        int start = 0;
        int end = m - 1;
         
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (check(H[i], S[mid])) {
                index = mid;
                start = mid + 1;
            }
            else {
                end = mid - 1;
            }
        }
         
        // Check if we get any
        // possible Area or Not
        if (index != -1) {
            // All area less than area[index]
            // satisfy property
            count += index + 1;
        }
    }
 
    return count;
}
 
// Driver code
    static public void Main (){
        int []H = { 1, 6, 4 };
    int n = H.Length;
     
    int []S = { 23, 3, 42, 14 };
    int m = S.Length;
     
    Console.WriteLine(findPairs(H, n, S, m));
    }
     
// This code is contributed
// by  akt_mit...
}

PHP




<?php
// Function to check the condition
function check($H, $S)
{
    // Condition for triangle to exist
    return $H * $H >= 4 * $S;
}
 
// Function to find all pairs
function findPairs($H, $n, $S, $m)
{
    $count = 0;
     
    // Sort both the arrays
    sort($H);
    sort($S);
 
    // To keep track of last possible Area
    $index = -1;
     
    for ($i = 0; $i < $n; $i++)
    {
         
        // Apply Binary Search for
        // each Hypotenuse Length
        $start = 0;
        $end = $m - 1;
         
        while ($start <= $end)
        {
            $mid = $start + (int)($end - $start) / 2;
            if (check($H[$i], $S[$mid]))
            {
                $index = $mid;
                $start = $mid + 1;
            }
            else
            {
                $end = $mid - 1;
            }
        }
         
        // Check if we get any possible
        // Area or Not
        if ($index != -1)
        {
            // All area less than area[index]
            // satisfy property
            $count += $index + 1;
        }
    }
 
    return $count;
}
 
// Driver code
$H = array( 1, 6, 4 );
$n = sizeof($H);
 
$S = array(23, 3, 42, 14 );
$m = sizeof($S);
 
echo findPairs($H, $n, $S, $m);
 
// This code is contributed by Sach_Code
?>

Javascript




<script>
 
    // Function to check the condition
    function check(H, S)
    {
        // Condition for triangle to exist
        return H * H >= 4 * S;
    }
 
    // Function to find all pairs
    function findPairs(H, n, S, m)
    {
        let count = 0;
 
        // Sort both the arrays
        H.sort(function(a, b){return a - b});
        S.sort(function(a, b){return a - b});
         
        // To keep track of last possible Area
        let index = -1;
 
        for (let i = 0; i < n; i++) {
            // Apply Binary Search for
            // each Hypotenuse Length
            let start = 0;
            let end = m - 1;
 
            while (start <= end) {
                let mid = start +
                parseInt((end - start) / 2, 10);
                if (check(H[i], S[mid])) {
                    index = mid;
                    start = mid + 1;
                }
                else {
                    end = mid - 1;
                }
            }
 
            // Check if we get any
            // possible Area or Not
            if (index != -1) {
                // All area less than area[index]
                // satisfy property
                count += index + 1;
            }
        }
 
        return count;
    }
     
    let H = [ 1, 6, 4 ];
    let n = H.length;
      
    let S = [ 23, 3, 42, 14 ];
    let m = S.length;
      
    document.write(findPairs(H, n, S, m));
     
</script>
Output: 
2

 

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 :