Given an array of integers, write a function that returns true if there is a triplet [a, b, c] that satisfies a2 + b2 = c2.
Example:
Input: arr[] = {3, 1, 4, 6, 5}
Output: True
There is a Pythagorean triplet [3, 4, 5].Input: arr[] = {10, 4, 6, 12, 5}
Output: False
There is no Pythagorean triplet.
Method 1 [Naive]
A simple solution is to run three loops, three loops pick three array elements, and check if the current three elements form a Pythagorean Triplet.
Below is the implementation of the above idea :
C++
#include
using
namespace
std;
bool
isTriplet[
int
ar[],
int
n]
{
for
[
int
i = 0; i < n; i++] {
for
[
int
j = i + 1; j < n; j++] {
for
[
int
k = j + 1; k < n; k++] {
int
x = ar[i] * ar[i], y = ar[j] * ar[j], z = ar[k] * ar[k];
if
[x == y + z || y == x + z || z == x + y]
return
true
;
}
}
}
return
false
;
}
int
main[]
{
int
ar[] = { 3, 1, 4, 6, 5 };
int
ar_size =
sizeof
[ar] /
sizeof
[ar[0]];
isTriplet[ar, ar_size] ? cout
Javascript
function
isTriplet[ ar, n]
{
for
[let i = 0; i < n; i++] {
for
[let j = i + 1; j < n; j++] {
for
[let k = j + 1; k < n; k++] {
let x = ar[i] * ar[i], y = ar[j] *
ar[j], z = ar[k] * ar[k];
if
[x == y + z || y == x + z ||
z == x + y]
return
true
;
}
}
}
return
false
;
}
let ar = [ 3, 1, 4, 6, 5 ];
let ar_size = ar.length;
if
[isTriplet[ar, ar_size] ==
true
]
document.write[
"Yes"
];
else
document.write[
"No"
];
Output:
Yes
The Time Complexity of the above solution is O[n3].
Auxiliary Space: O[1]
Method 2 [Use Sorting]
We can solve this in O[n2] time by sorting the array first.
1] Do the square of every element in the input array. This step takes O[n] time.
2] Sort the squared array in increasing order. This step takes O[nLogn] time.
3] To find a triplet [a, b, c] such that a2 = b2 + c2, do
following.
- Fix ‘a’ as the last element of the sorted array.
- Now search for pair [b, c] in subarray between the first element and ‘a’. A pair [b, c] with a given sum can be found in O[n] time using the meet in middle algorithm discussed in method 1 of this post.
- If no pair is found for current ‘a’, then move ‘a’ one position back and repeat step 3.2.
Below image is a dry run of the above approach:
Below is the implementation of the above approach:
C++
#include
#include
using
namespace
std;
bool
isTriplet[
int
arr[],
int
n]
{
for
[
int
i = 0; i < n; i++]
arr[i] = arr[i] * arr[i];
sort[arr, arr + n];
for
[
int
i = n - 1; i >= 2; i--] {
int
l = 0;
int
r = i - 1;
while
[l < r] {
if
[arr[l] + arr[r] == arr[i]]
return
true
;
[arr[l] + arr[r] < arr[i]] ? l++ : r--;
}
}
return
false
;
}
int
main[]
{
int
arr[] = { 3, 1, 4, 6, 5 };
int
arr_size =
sizeof
[arr] /
sizeof
[arr[0]];
isTriplet[arr, arr_size] ? cout = 2; i--] {
int
l = 0;
int
r = i - 1;
while
[l < r] {
if
[arr[l] + arr[r] == arr[i]]
return
true
;
if
[arr[l] + arr[r] < arr[i]]
l++;
else
r--;
}
}
return
false
;
}
public
static
void
Main[]
{
int
[] arr = { 3, 1, 4, 6, 5 };
int
arr_size = arr.Length;
if
[isTriplet[arr, arr_size] ==
true
]
Console.WriteLine[
"Yes"
];
else
Console.WriteLine[
"No"
];
}
}
PHP
Javascript
function
isTriplet[arr , n]
{
for
[i = 0; i < n; i++]
arr[i] = arr[i] * arr[i];
arr.sort[[a,b]=>a-b];
for
[i = n - 1; i >= 2; i--]
{
var
l = 0;
var
r = i - 1;
while
[l < r]
{
if
[arr[l] + arr[r] == arr[i]]
return
true
;
if
[arr[l] + arr[r] < arr[i]]
l++;
else
r--;
}
}
return
false
;
}
var
arr = [ 3, 1, 4, 6, 5 ];
var
arr_size = arr.length;
if
[isTriplet[arr, arr_size] ==
true
]
document.write[
"Yes"
];
else
document.write[
"No"
];
Output:
Yes
The time complexity of this method is O[n2].
Auxiliary Space: O[1]
Method 3: [Using Hashing]
The
problem can also be solved using hashing. We can use a hash map to mark all the values of the given array. Using two loops, we can iterate for all the possible combinations of a and b, and then check if there exists the third value c. If there exists any such value, then there is a Pythagorean triplet.
Below is the implementation of the above approach:
C++
#include
using
namespace
std;
bool
checkTriplet[
int
arr[],
int
n]
{
int
maximum = 0;
for
[
int
i = 0; i < n; i++] {
maximum = max[maximum, arr[i]];
}
int
hash[maximum + 1] = { 0 };
for
[
int
i = 0; i < n; i++]
hash[arr[i]]++;
for
[
int
i = 1; i < maximum + 1; i++] {
if
[hash[i] == 0]
continue
;
for
[
int
j = 1; j < maximum + 1; j++] {
if
[[i == j && hash[i] == 1] || hash[j] == 0]
continue
;
int
val =
sqrt
[i * i + j * j];
if
[[val * val] != [i * i + j * j]]
continue
;
if
[val > maximum]
continue
;
if
[hash[val]] {
return
true
;
}
}
}
return
false
;
}
int
main[]
{
int
arr[] = { 3, 2, 4, 6, 5 };
int
n =
sizeof
[arr] /
sizeof
[arr[0]];
if
[checkTriplet[arr, n]]
cout maximum]:
continue
if
[
hash
[val]]:
return
True
return
False
arr
=
[
3
,
2
,
4
,
6
,
5
]
n
=
len
[arr]
if
[checkTriplet[arr, n]]:
print
[
"Yes"
]
else
:
print
[
"No"
]
C#
using
System;
class
GFG
{
static
bool
checkTriplet[
int
[]arr,
int
n]
{
int
maximum = 0;
for
[
int
i = 0; i < n; i++]
{
maximum = Math.Max[maximum, arr[i]];
}
int
[]hash =
new
int
[maximum + 1];
for
[
int
i = 0; i < n; i++]
hash[arr[i]]++;
for
[
int
i = 1; i < maximum + 1; i++]
{
if
[hash[i] == 0]
continue
;
for
[
int
j = 1; j < maximum + 1; j++]
{
if
[[i == j && hash[i] == 1] || hash[j] == 0]
continue
;
int
val = [
int
] Math.Sqrt[i * i + j * j];
if
[[val * val] != [i * i + j * j]]
continue
;
if
[val > maximum]
continue
;
if
[hash[val] == 1]
{
return
true
;
}
}
}
return
false
;
}
public
static
void
Main[String[] args]
{
int
[]arr = { 3, 2, 4, 6, 5 };
int
n = arr.Length;
if
[checkTriplet[arr, n]]
Console.Write[
"Yes"
];
else
Console.Write[
"No"
];
}
}
Javascript
function
checkTriplet[arr , n] {
var
maximum = 0;
for
[i = 0; i < n; i++] {
maximum = Math.max[maximum, arr[i]];
}
var
hash = Array[maximum + 1].fill[0];
for
[i = 0; i < n; i++]
hash[arr[i]]++;
for
[i = 1; i < maximum + 1; i++] {
if
[hash[i] == 0]
continue
;
for
[j = 1; j < maximum + 1; j++] {
if
[[i == j && hash[i] == 1] || hash[j] == 0]
continue
;
var
val = parseInt[ Math.sqrt[i * i + j * j]];
if
[[val * val] != [i * i + j * j]]
continue
;
if
[val > maximum]
continue
;
if
[hash[val] == 1] {
return
true
;
}
}
}
return
false
;
}
var
arr = [ 3, 2, 4, 6, 5 ];
var
n = arr.length;
if
[checkTriplet[arr, n]]
document.write[
"Yes"
];
else
document.write[
"No"
];
Thanks to
Striver for suggesting the above approach.
Time Complexity: O[ max * max ], where max is the maximum most element in the array.
Auxiliary Space: O[max]
Method -4:Using STL
Approach:
The problem can be solved using ordered maps and unordered maps. There is no need to store the elements in an ordered manner so implementation by an unordered map is faster. We can use the unordered map to mark all the values of the given array. Using two loops, we can iterate for all the possible combinations of a and b, and then check if there exists the third value c. If there exists any such value, then there is a Pythagorean triplet.
Below is the implementation of the above approach:
C++
#include
using
namespace
std;
bool
checkTriplet[
int
arr[],
int
n]
{
unordered_map umap;
for
[
int
i = 0; i < n; i++]
umap[arr[i]] = umap[arr[i]] + 1;
for
[
int
i = 0; i < n - 1; i++]
{
for
[
int
j = i + 1; j < n; j++]
{
int
p =
sqrt
[arr[i] * arr[i] + arr[j] * arr[j]];
float
q
=
sqrt
[arr[i] * arr[i] + arr[j] * arr[j]];
if
[p == q && umap[p] != 0]
return
true
;
}
}
return
false
;
}
int
main[]
{
int
arr[] = { 3, 2, 4, 6, 5 };
int
n =
sizeof
[arr] /
sizeof
[arr[0]];
if
[checkTriplet[arr, n]]
cout