# Pythagorean Triplet in an array

• Difficulty Level : Easy
• Last Updated : 03 Nov, 2022

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.

Recommended Practice

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

 `// A C++ program that returns true if there is a Pythagorean` `// Triplet in a given array.` `#include `   `using` `namespace` `std;`   `// Returns true if there is Pythagorean triplet in ar[0..n-1]` `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++) {` `                ``// Calculate square of array elements` `                ``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``;` `            ``}` `        ``}` `    ``}`   `    ``// If we reach here, no triplet found` `    ``return` `false``;` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``int` `ar[] = { 3, 1, 4, 6, 5 };` `    ``int` `ar_size = ``sizeof``(ar) / ``sizeof``(ar[0]);` `    ``isTriplet(ar, ar_size) ? cout << ``"Yes"` `: cout << ``"No"``;` `    ``return` `0;` `}`

## Java

 `// A Java program that returns true if there is a Pythagorean` `// Triplet in a given array.` `import` `java.io.*;`   `class` `PythagoreanTriplet {`   `    ``// Returns true if there is Pythagorean triplet in ar[0..n-1]` `    ``static` `boolean` `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++) {` `                    ``// Calculate square of array elements` `                    ``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``;` `                ``}` `            ``}` `        ``}`   `        ``// If we reach here, no triplet found` `        ``return` `false``;` `    ``}`   `    ``// Driver program to test above function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `ar[] = { ``3``, ``1``, ``4``, ``6``, ``5` `};` `        ``int` `ar_size = ar.length;` `        ``if` `(isTriplet(ar, ar_size) == ``true``)` `            ``System.out.println(``"Yes"``);` `        ``else` `            ``System.out.println(``"No"``);` `    ``}` `}` `/* This code is contributed by Devesh Agrawal */`

## Python3

 `# Python program to check if there is Pythagorean` `# triplet in given array`   `# Returns true if there is Pythagorean` `# triplet in ar[0..n-1]`   `def` `isTriplet(ar, n):` `    ``j ``=` `0` `    `  `    ``for` `i ``in` `range``(n ``-` `2``):` `        ``for` `j ``in` `range``(i ``+` `1``, n):` `            ``for` `k ``in` `range``(j ``+` `1``, n ``-` `1``):` `                ``# Calculate square of array elements` `                ``x ``=` `ar[i]``*``ar[i]` `                ``y ``=` `ar[j]``*``ar[j]` `                ``z ``=` `ar[k]``*``ar[k] ` `                ``if` `(x ``=``=` `y ``+` `z ``or` `y ``=``=` `x ``+` `z ``or` `z ``=``=` `x ``+` `y):` `                    ``return` `1` `    `  `    ``# If we reach here, no triplet found` `    ``return` `0`     `# Driver program to test above function ` `ar ``=` `[``3``, ``1``, ``4``, ``6``, ``5``]` `ar_size ``=` `len``(ar)`   `if``(isTriplet(ar, ar_size)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed by Anvesh Govind Saxena`

## C#

 `// A C# program that returns true` `// if there is a Pythagorean` `// Triplet in a given array.` `using` `System;`   `class` `GFG {`   `    ``// Returns true if there is Pythagorean` `    ``// triplet in ar[0..n-1]` `    ``static` `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++) {`   `                    ``// Calculate square of array elements` `                    ``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``;` `                ``}` `            ``}` `        ``}`   `        ``// If we reach here,` `        ``// no triplet found` `        ``return` `false``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] ar = { 3, 1, 4, 6, 5 };` `        ``int` `ar_size = ar.Length;` `        ``if` `(isTriplet(ar, ar_size) == ``true``)` `            ``Console.WriteLine(``"Yes"``);` `        ``else` `            ``Console.WriteLine(``"No"``);` `    ``}` `}`   `// This code is contributed by shiv_bhakt.`

## PHP

 ``

## Javascript

 ``

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.

1. Fix ‘a’ as the last element of the sorted array.
2. 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.
3. 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++

 `// A C++ program that returns true if there is a Pythagorean` `// Triplet in a given array.` `#include ` `#include `   `using` `namespace` `std;`   `// Returns true if there is a triplet with following property` `// A[i]*A[i] = A[j]*A[j] + A[k]*[k]` `// Note that this function modifies given array` `bool` `isTriplet(``int` `arr[], ``int` `n)` `{` `    ``// Square array elements` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``arr[i] = arr[i] * arr[i];`   `    ``// Sort array elements` `    ``sort(arr, arr + n);`   `    ``// Now fix one element one by one and find the other two` `    ``// elements` `    ``for` `(``int` `i = n - 1; i >= 2; i--) {` `        ``// To find the other two elements, start two index` `        ``// variables from two corners of the array and move` `        ``// them toward each other` `        ``int` `l = 0; ``// index of the first element in arr[0..i-1]` `        ``int` `r = i - 1; ``// index of the last element in arr[0..i-1]` `        ``while` `(l < r) {` `            ``// A triplet found` `            ``if` `(arr[l] + arr[r] == arr[i])` `                ``return` `true``;`   `            ``// Else either move 'l' or 'r'` `            ``(arr[l] + arr[r] < arr[i]) ? l++ : r--;` `        ``}` `    ``}`   `    ``// If we reach here, then no triplet found` `    ``return` `false``;` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``int` `arr[] = { 3, 1, 4, 6, 5 };` `    ``int` `arr_size = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``isTriplet(arr, arr_size) ? cout << ``"Yes"` `: cout << ``"No"``;` `    ``return` `0;` `}`

## Java

 `// A Java program that returns true if there is a Pythagorean` `// Triplet in a given array.` `import` `java.io.*;` `import` `java.util.*;`   `class` `PythagoreanTriplet {` `    ``// Returns true if there is a triplet with following property` `    ``// A[i]*A[i] = A[j]*A[j] + A[k]*[k]` `    ``// Note that this function modifies given array` `    ``static` `boolean` `isTriplet(``int` `arr[], ``int` `n)` `    ``{` `        ``// Square array elements` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``arr[i] = arr[i] * arr[i];`   `        ``// Sort array elements` `        ``Arrays.sort(arr);`   `        ``// Now fix one element one by one and find the other two` `        ``// elements` `        ``for` `(``int` `i = n - ``1``; i >= ``2``; i--) {` `            ``// To find the other two elements, start two index` `            ``// variables from two corners of the array and move` `            ``// them toward each other` `            ``int` `l = ``0``; ``// index of the first element in arr[0..i-1]` `            ``int` `r = i - ``1``; ``// index of the last element in arr[0..i-1]` `            ``while` `(l < r) {` `                ``// A triplet found` `                ``if` `(arr[l] + arr[r] == arr[i])` `                    ``return` `true``;`   `                ``// Else either move 'l' or 'r'` `                ``if` `(arr[l] + arr[r] < arr[i])` `                    ``l++;` `                ``else` `                    ``r--;` `            ``}` `        ``}`   `        ``// If we reach here, then no triplet found` `        ``return` `false``;` `    ``}`   `    ``// Driver program to test above function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``3``, ``1``, ``4``, ``6``, ``5` `};` `        ``int` `arr_size = arr.length;` `        ``if` `(isTriplet(arr, arr_size) == ``true``)` `            ``System.out.println(``"Yes"``);` `        ``else` `            ``System.out.println(``"No"``);` `    ``}` `}` `/*This code is contributed by Devesh Agrawal*/`

## Python3

 `# Python program that returns true if there is ` `# a Pythagorean Triplet in a given array.`   `# Returns true if there is Pythagorean` `# triplet in ar[0..n-1]` `def` `isTriplet(ar, n):` `    ``# Square all the elements` `    ``for` `i ``in` `range``(n):` `        ``ar[i] ``=` `ar[i] ``*` `ar[i]`   `    ``# sort array elements` `    ``ar.sort()`   `    ``# fix one element` `    ``# and find other two` `    ``# i goes from n - 1 to 2` `    ``for` `i ``in` `range``(n``-``1``, ``1``, ``-``1``):` `        ``# start two index variables from ` `        ``# two corners of the array and ` `        ``# move them toward each other` `        ``j ``=` `0` `        ``k ``=` `i ``-` `1` `        ``while` `(j < k):` `            ``# A triplet found` `            ``if` `(ar[j] ``+` `ar[k] ``=``=` `ar[i]):` `                ``return` `True` `            ``else``:` `                ``if` `(ar[j] ``+` `ar[k] < ar[i]):` `                    ``j ``=` `j ``+` `1` `                ``else``:` `                    ``k ``=` `k ``-` `1` `    ``# If we reach here, then no triplet found` `    ``return` `False`   `# Driver program to test above function */` `ar ``=` `[``3``, ``1``, ``4``, ``6``, ``5``]` `ar_size ``=` `len``(ar)` `if``(isTriplet(ar, ar_size)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed by Aditi Sharma`

## C#

 `// C# program that returns true` `// if there is a Pythagorean` `// Triplet in a given array.` `using` `System;`   `class` `GFG {`   `    ``// Returns true if there is a triplet` `    ``// with following property A[i]*A[i]` `    ``// = A[j]*A[j]+ A[k]*[k] Note that` `    ``// this function modifies given array` `    ``static` `bool` `isTriplet(``int``[] arr, ``int` `n)` `    ``{`   `        ``// Square array elements` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``arr[i] = arr[i] * arr[i];`   `        ``// Sort array elements` `        ``Array.Sort(arr);`   `        ``// Now fix one element one by one` `        ``// and find the other two elements` `        ``for` `(``int` `i = n - 1; i >= 2; i--) {` `            ``// To find the other two elements,` `            ``// start two index variables from` `            ``// two corners of the array and` `            ``// move them toward each other` `            ``// index of the first element` `            ``// in arr[0..i-1]` `            ``int` `l = 0;`   `            ``// index of the last element` `            ``// in arr[0..i - 1]` `            ``int` `r = i - 1;` `            ``while` `(l < r) {`   `                ``// A triplet found` `                ``if` `(arr[l] + arr[r] == arr[i])` `                    ``return` `true``;`   `                ``// Else either move 'l' or 'r'` `                ``if` `(arr[l] + arr[r] < arr[i])` `                    ``l++;` `                ``else` `                    ``r--;` `            ``}` `        ``}`   `        ``// If we reach here, then` `        ``// no triplet found` `        ``return` `false``;` `    ``}`   `    ``// Driver Code` `    ``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"``);` `    ``}` `}`   `// This code is contributed by shiv_bhakt.`

## PHP

 `= 2; ``\$i``--)` `    ``{` `        `  `        ``// To find the other two ` `        ``// elements, start two index` `        ``// variables from two corners` `        ``// of the array and move` `        ``// them toward each other` `        `  `        ``// index of the first element` `        ``// in arr[0..i-1]` `        ``\$l` `= 0; ` `        `  `        ``// index of the last element` `        ``// in arr[0..i-1]` `        ``\$r` `= ``\$i` `- 1; ` `        ``while` `(``\$l` `< ``\$r``)` `        ``{` `            `  `            ``// A triplet found` `            ``if` `(``\$arr``[``\$l``] + ``\$arr``[``\$r``] == ``\$arr``[``\$i``])` `                ``return` `true;`   `            ``// Else either move 'l' or 'r'` `            ``(``\$arr``[``\$l``] + ``\$arr``[``\$r``] < ``\$arr``[``\$i``])? ``\$l``++: ``\$r``--;` `        ``}` `    ``}`   `    ``// If we reach here, ` `    ``// then no triplet found` `    ``return` `false;` `}`   `    ``// Driver Code` `    ``\$arr` `= ``array``(3, 1, 4, 6, 5);` `    ``\$arr_size` `= ``count``(``\$arr``);` `    ``if``(isTriplet(``\$arr``, ``\$arr_size``))` `        ``echo` `"Yes"``;` `    ``else` `        ``echo` `"No"``;`   `// This code is contributed by anuj_67.` `?>`

## Javascript

 ``

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;`   `// Function to check if the` `// Pythagorean triplet exists or not` `bool` `checkTriplet(``int` `arr[], ``int` `n)` `{` `    ``int` `maximum = 0;`   `    ``// Find the maximum element` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``maximum = max(maximum, arr[i]);` `    ``}`   `    ``// Hashing array` `    ``int` `hash[maximum + 1] = { 0 };`   `    ``// Increase the count of array elements` `    ``// in hash table` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``hash[arr[i]]++;`   `    ``// Iterate for all possible a` `    ``for` `(``int` `i = 1; i < maximum + 1; i++) {`   `        ``// If a is not there` `        ``if` `(hash[i] == 0)` `            ``continue``;`   `        ``// Iterate for all possible b` `        ``for` `(``int` `j = 1; j < maximum + 1; j++) {`   `            ``// If a and b are same and there is only one a` `            ``// or if there is no b in original array` `            ``if` `((i == j && hash[i] == 1) || hash[j] == 0)` `                ``continue``;`   `            ``// Find c` `            ``int` `val = ``sqrt``(i * i + j * j);`   `            ``// If c^2 is not a perfect square` `            ``if` `((val * val) != (i * i + j * j))` `                ``continue``;`   `            ``// If c exceeds the maximum value` `            ``if` `(val > maximum)` `                ``continue``;`   `            ``// If there exists c in the original array,` `            ``// we have the triplet` `            ``if` `(hash[val]) {` `                ``return` `true``;` `            ``}` `        ``}` `    ``}` `    ``return` `false``;` `}` `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 3, 2, 4, 6, 5 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``if` `(checkTriplet(arr, n))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;` `}`

## Java

 `import` `java.util.*;`   `class` `GFG` `{`   `// Function to check if the` `// Pythagorean triplet exists or not` `static` `boolean` `checkTriplet(``int` `arr[], ``int` `n)` `{` `    ``int` `maximum = ``0``;`   `    ``// Find the maximum element` `    ``for` `(``int` `i = ``0``; i < n; i++)` `    ``{` `        ``maximum = Math.max(maximum, arr[i]);` `    ``}`   `    ``// Hashing array` `    ``int` `[]hash = ``new` `int``[maximum + ``1``];`   `    ``// Increase the count of array elements` `    ``// in hash table` `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``hash[arr[i]]++;`   `    ``// Iterate for all possible a` `    ``for` `(``int` `i = ``1``; i < maximum + ``1``; i++)` `    ``{`   `        ``// If a is not there` `        ``if` `(hash[i] == ``0``)` `            ``continue``;`   `        ``// Iterate for all possible b` `        ``for` `(``int` `j = ``1``; j < maximum + ``1``; j++) ` `        ``{`   `            ``// If a and b are same and there is only one a` `            ``// or if there is no b in original array` `            ``if` `((i == j && hash[i] == ``1``) || hash[j] == ``0``)` `                ``continue``;`   `            ``// Find c` `            ``int` `val = (``int``) Math.sqrt(i * i + j * j);`   `            ``// If c^2 is not a perfect square` `            ``if` `((val * val) != (i * i + j * j))` `                ``continue``;`   `            ``// If c exceeds the maximum value` `            ``if` `(val > maximum)` `                ``continue``;`   `            ``// If there exists c in the original array,` `            ``// we have the triplet` `            ``if` `(hash[val] == ``1``) ` `            ``{` `                ``return` `true``;` `            ``}` `        ``}` `    ``}` `    ``return` `false``;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``3``, ``2``, ``4``, ``6``, ``5` `};` `    ``int` `n = arr.length;` `    ``if` `(checkTriplet(arr, n))` `        ``System.out.print(``"Yes"``);` `    ``else` `        ``System.out.print(``"No"``);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Function to check if the` `# Pythagorean triplet exists or not` `import` `math`   `def` `checkTriplet(arr, n):` `    ``maximum ``=` `0`   `    ``# Find the maximum element` `    ``maximum ``=` `max``(arr)`   `        ``# Hashing array` `    ``hash` `=` `[``0``]``*``(maximum``+``1``)`   `    ``# Increase the count of array elements` `    ``# in hash table` `    ``for` `i ``in` `range``(n):` `        ``hash``[arr[i]] ``+``=` `1`   `        ``# Iterate for all possible a` `    ``for` `i ``in` `range``(``1``, maximum``+``1``):` `        ``# If a is not there` `        ``if` `(``hash``[i] ``=``=` `0``):` `            ``continue`   `        ``# Iterate for all possible b` `        ``for` `j ``in` `range``(``1``, maximum``+``1``):` `            ``# If a and b are same and there is only one a` `            ``# or if there is no b in original array` `            ``if` `((i ``=``=` `j ``and` `hash``[i] ``=``=` `1``) ``or` `hash``[j] ``=``=` `0``):` `                ``continue`   `            ``# Find c` `            ``val ``=` `int``(math.sqrt(i ``*` `i ``+` `j ``*` `j))`   `            ``# If c^2 is not a perfect square` `            ``if` `((val ``*` `val) !``=` `(i ``*` `i ``+` `j ``*` `j)):` `                ``continue`   `            ``# If c exceeds the maximum value` `            ``if` `(val > maximum):` `                ``continue`   `            ``# If there exists c in the original array,` `            ``# we have the triplet` `            ``if` `(``hash``[val]):` `                ``return` `True` `    ``return` `False`     `# Driver Code` `arr ``=` `[``3``, ``2``, ``4``, ``6``, ``5``]` `n ``=` `len``(arr)` `if` `(checkTriplet(arr, n)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`     `# This code is contributed by ankush_953`

## C#

 `using` `System;`   `class` `GFG` `{`   `// Function to check if the` `// Pythagorean triplet exists or not` `static` `bool` `checkTriplet(``int` `[]arr, ``int` `n)` `{` `    ``int` `maximum = 0;`   `    ``// Find the maximum element` `    ``for` `(``int` `i = 0; i < n; i++)` `    ``{` `        ``maximum = Math.Max(maximum, arr[i]);` `    ``}`   `    ``// Hashing array` `    ``int` `[]hash = ``new` `int``[maximum + 1];`   `    ``// Increase the count of array elements` `    ``// in hash table` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``hash[arr[i]]++;`   `    ``// Iterate for all possible a` `    ``for` `(``int` `i = 1; i < maximum + 1; i++)` `    ``{`   `        ``// If a is not there` `        ``if` `(hash[i] == 0)` `            ``continue``;`   `        ``// Iterate for all possible b` `        ``for` `(``int` `j = 1; j < maximum + 1; j++) ` `        ``{`   `            ``// If a and b are same and there is only one a` `            ``// or if there is no b in original array` `            ``if` `((i == j && hash[i] == 1) || hash[j] == 0)` `                ``continue``;`   `            ``// Find c` `            ``int` `val = (``int``) Math.Sqrt(i * i + j * j);`   `            ``// If c^2 is not a perfect square` `            ``if` `((val * val) != (i * i + j * j))` `                ``continue``;`   `            ``// If c exceeds the maximum value` `            ``if` `(val > maximum)` `                ``continue``;`   `            ``// If there exists c in the original array,` `            ``// we have the triplet` `            ``if` `(hash[val] == 1) ` `            ``{` `                ``return` `true``;` `            ``}` `        ``}` `    ``}` `    ``return` `false``;` `}`   `// Driver Code` `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"``);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`Yes`

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;`   `//  Returns true if there is Pythagorean triplet in` `//  ar[0..n-1]` `bool` `checkTriplet(``int` `arr[], ``int` `n)` `{ ` `    ``// initializing unordered map with key and value as` `    ``// integers` `    ``unordered_map<``int``, ``int``> umap;` `    `  `    ``// Increase the count of array elements in unordered map` `    ``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++)` `        ``{    ` `            ``// calculating the squares of two elements as` `            ``// integer and float` `            ``int` `p = ``sqrt``(arr[i] * arr[i] + arr[j] * arr[j]);` `            ``float` `q` `                ``= ``sqrt``(arr[i] * arr[i] + arr[j] * arr[j]);` `            `  `            ``// Condition is true if the value is same in` `            ``// integer and float and also the value is` `            ``// present in unordered map` `            ``if` `(p == q && umap[p] != 0)` `                ``return` `true``;` `        ``}` `    ``}` `   `  `    ``// If we reach here, no triplet found` `    ``return` `false``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 3, 2, 4, 6, 5 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``if` `(checkTriplet(arr, n))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;` `}` `// This code is contributed by Vikkycirus`

## Java

 `import` `java.util.*;` `class` `GFG{`   `  ``//  Returns true if there is Pythagorean triplet in` `  ``//  ar[0..n-1]` `  ``static` `boolean` `checkTriplet(``int` `arr[], ``int` `n)` `  ``{ `   `    ``// initializing unordered map with key and value as` `    ``// integers` `    ``HashMap umap = ``new` `HashMap<>();`   `    ``// Increase the count of array elements in unordered map` `    ``for` `(``int` `i = ``0``; i < n; i++)` `      ``if``(umap.containsKey(arr[i]))` `        ``umap.put(arr[i] , umap.get(arr[i]) + ``1``);` `    ``else` `      ``umap.put(arr[i], ``1``);`   `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++) ` `    ``{` `      ``for` `(``int` `j = i + ``1``; j < n; j++)` `      ``{    `   `        ``// calculating the squares of two elements as` `        ``// integer and float` `        ``int` `p =(``int``) Math.sqrt(arr[i] * arr[i] + arr[j] * arr[j]);` `        ``float` `q` `          ``=(``float``) Math.sqrt(arr[i] * arr[i] + arr[j] * arr[j]);`   `        ``// Condition is true if the value is same in` `        ``// integer and float and also the value is` `        ``// present in unordered map` `        ``if` `(p == q && umap.get(p) != ``0``)` `          ``return` `true``;` `      ``}` `    ``}`   `    ``// If we reach here, no triplet found` `    ``return` `false``;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `arr[] = { ``3``, ``2``, ``4``, ``6``, ``5` `};` `    ``int` `n = arr.length;` `    ``if` `(checkTriplet(arr, n))` `      ``System.out.print(``"Yes"``);` `    ``else` `      ``System.out.print(``"No"``);` `  ``}` `}`   `// This code is contributed by umadevi9616`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``// Returns true if there is Pythagorean triplet in` `  ``// ar[0..n-1]` `  ``static` `bool` `checkTriplet(``int` `[]arr, ``int` `n) {`   `    ``// initializing unordered map with key and value as` `    ``// integers` `    ``Dictionary<``int``, ``int``> umap = ``new` `Dictionary<``int``,``int``>();`   `    ``// Increase the count of array elements in unordered map` `    ``for` `(``int` `i = 0; i < n; i++)` `      ``if` `(umap.ContainsKey(arr[i]))` `        ``umap.Add(arr[i], umap[arr[i]] + 1);` `    ``else` `      ``umap.Add(arr[i], 1);`   `    ``for` `(``int` `i = 0; i < n - 1; i++) {` `      ``for` `(``int` `j = i + 1; j < n; j++) {`   `        ``// calculating the squares of two elements as` `        ``// integer and float` `        ``int` `p = (``int``) Math.Sqrt(arr[i] * arr[i] + arr[j] * arr[j]);` `        ``float` `q = (``float``) Math.Sqrt(arr[i] * arr[i] + arr[j] * arr[j]);`   `        ``// Condition is true if the value is same in` `        ``// integer and float and also the value is` `        ``// present in unordered map` `        ``if` `(p == q && umap[p] != 0)` `          ``return` `true``;` `      ``}` `    ``}`   `    ``// If we reach here, no triplet found` `    ``return` `false``;` `  ``}`   `  ``// Driver Code` `  ``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"``);` `  ``}` `}`   `// This code is contributed by umadevi9616`

## Javascript

 ``

## Python3

 `# Function to check if the` `# Pythagorean triplet exists or not` `import` `math`   `def` `checkTriplet(arr, n):` `  `  `    ``# creating dictionary/unordered map` `    ``h ``=` `{arr[i]: ``1` `for` `i ``in` `range``(n)}` `    ``for` `i ``in` `range``(n``-``1``):` `        ``for` `j ``in` `range``(i``+``1``, n):` `          `  `            ``# Calculating the squares of 2 elements` `            ``q ``=` `math.sqrt(arr[i]``*``arr[i] ``+` `arr[j]``*``arr[j])` `            `  `            ``# Checking if squareroot is integer and present in map` `            ``if` `q ``=``=` `int``(q) ``and` `int``(q) ``in` `h:` `                ``return` `True` `    ``return` `False`   `# Driver Code` `arr ``=` `[``3``, ``2``, ``4``, ``6``, ``5``]` `n ``=` `len``(arr)` `if` `(checkTriplet(arr, n)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed by Anvesh Govind Saxena`

Output

`Yes`

Time Complexity:O(n2)
Auxiliary Space:O(n)

Method 5 – A better hashing based approach

This approach uses Set. Firstly, we’ll square the elements of the array and then sort the array in increasing order. Run two loops where the outer loop starts from the last index of the array to the second index (0 based indexing is assumed) and the inner loop starts from outerLoopIndex – 1 to the start. Create a set to store the elements in between outerLoopIndex and innerLoopIndex. Check if there is a number in the set which is equal to arr[outerLoopIndex] â€“ arr[innerLoopIndex]. If yes, then return “True”.

## C++

 `#include ` `using` `namespace` `std;` `bool` `checkTriplet(``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 > 1; i--)` `  ``{` `    ``unordered_set<``int``> s;` `    ``for``(``int` `j = i - 1; j >- 1; j--)` `    ``{` `      ``if``(s.count(arr[i] - arr[j]))` `        ``return` `true``;`   `      ``s.insert(arr[j]);` `    ``}` `  ``}`   `  ``return` `false``;` `}` `int` `main()` `{` `  ``int` `arr[] = {3, 2, 4, 6, 5};` `  ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);`   `  ``if` `(checkTriplet(arr, n))` `    ``cout << ``"Yes"``;` `  ``else` `    ``cout << ``"No"``;`   `  ``return` `0;` `}`   `// This code is contributed by aditya942003patil`

## Python3

 `# Python program to check if there exists a pythagorean triplet` `def` `checkTriplet(arr, n):` `    ``for` `i ``in` `range``(n):` `        ``arr[i] ``=` `arr[i] ``*` `arr[i]`   `    ``arr.sort()`   `    ``for` `i ``in` `range``(n ``-` `1``, ``1``, ``-``1``):` `        ``s ``=` `set``()` `        ``for` `j ``in` `range``(i ``-` `1``, ``-``1``, ``-``1``):` `            ``if` `(arr[i] ``-` `arr[j]) ``in` `s:` `                ``return` `True` `            ``s.add(arr[j])` `    ``return` `False`   `# Driver Program` `arr ``=` `[``3``, ``2``, ``4``, ``6``, ``5``]` `n ``=` `len``(arr)` `if` `(checkTriplet(arr, n)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This is contributed by Manvi Pandey`

Output

`Yes`

Time Complexity: O(n2)
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up
Related Articles