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

• Difficulty Level : Medium
• Last Updated : 31 May, 2022

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,
= Base of Right Angled Triangle
= 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 ``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<

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

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

 ``

Output:

`2`

Time Complexity: O(n*m) where n and m are the sizes of the array H and S respectively.
Auxiliary Space: O(1)

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

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

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

 ``

Output:

`2`

Time Complexity: O(n*log(n)+m*log(m)+n*log(m)) where n and m are the sizes of the array H and S respectively. Here n*log(n) and m*log(m) are for sorting the array and n*log(m) is for traversing and applying binary search each time.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up