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

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 which 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); ` `     `  `    ``int` `S[] = { 23, 3, 42, 14 }; ` `    ``int` `m = ``sizeof``(S)/``sizeof``(S); ` `     `  `    ``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 ` `?> `

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 ` `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); ` `     `  `    ``int` `S[] = { 23, 3, 42, 14 }; ` `    ``int` `m = ``sizeof``(S)/``sizeof``(S); ` `     `  `    ``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 ` `?> `

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.