# Print all the pairs that contains the positive and negative values of an element

Last Updated : 30 Oct, 2023

Given an array of distinct integers, print all the pairs having a positive value and negative value of a number that exists in the array.

Note: Order of the pairs doesn’t matter.

Examples:

`Input: arr[] = { 1, -3, 2, 3, 6, -1 }Output: -1 1 -3 3Input: arr[] = { 4, 8, 9, -4, 1, -1, -8, -9 }Output: -1 1 -4 4 -8 8 -9 9`

Naive approach(using two loops)

Algorithm

`Initialize an array with 6 integers.Find the size of the array.Loop through each element in the array.For each element, loop through each element after it.For each pair of elements, check if they have opposite signs and equal absolute values.If the condition is true, print the two elements.Repeat steps 4-6 for all pairs of elements.End the program.`

Implementation of following approach

## C++

 `#include ` `#include `   `using` `namespace` `std;`   `int` `main()` `{` `    ``int` `arr[] = { 1, -3, 2, 3, 6, -1 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = i + 1; j < n; j++) {` `            ``if` `((arr[i] > 0 && arr[j] < 0 && ``abs``(arr[i]) == ``abs``(arr[j])) || ` `                ``(arr[i] < 0 && arr[j] > 0 && ``abs``(arr[i]) == ``abs``(arr[j]))) {` `                ``if` `(arr[i] < 0) {` `                    ``cout << arr[i] << ``" "` `<< arr[j] << endl;` `                ``} ``else` `{` `                    ``cout << arr[j] << ``" "` `<< arr[i] << endl;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``return` `0;` `}`

## Java

 `import` `java.util.Arrays;`   `public` `class` `GFG {` `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = { ``1``, -``3``, ``2``, ``3``, ``6``, -``1` `};` `        ``int` `n = arr.length;` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``for` `(``int` `j = i + ``1``; j < n; j++) {` `                ``if` `((arr[i] > ``0` `&& arr[j] < ``0` `&& Math.abs(arr[i]) == Math.abs(arr[j])) || ` `                    ``(arr[i] < ``0` `&& arr[j] > ``0` `&& Math.abs(arr[i]) == Math.abs(arr[j]))) {` `                    ``if` `(arr[i] < ``0``) {` `                        ``System.out.println(arr[i] + ``" "` `+ arr[j]);` `                    ``} ``else` `{` `                        ``System.out.println(arr[j] + ``" "` `+ arr[i]);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}` `}`

## Python

 `# Define an array of integers` `arr ``=` `[``1``, ``-``3``, ``2``, ``3``, ``6``, ``-``1``]`   `# Get the length of the array` `n ``=` `len``(arr)`   `# Loop over all pairs of elements in the array` `for` `i ``in` `range``(n):` `    ``for` `j ``in` `range``(i ``+` `1``, n):` `        ``# Check if the elements have opposite signs and equal absolute values` `        ``if` `((arr[i] > ``0` `and` `arr[j] < ``0` `and` `abs``(arr[i]) ``=``=` `abs``(arr[j])) ``or` `            ``(arr[i] < ``0` `and` `arr[j] > ``0` `and` `abs``(arr[i]) ``=``=` `abs``(arr[j]))):` `            ``# Print the pair of elements to the console` `            ``if` `arr[i] < ``0``:` `                ``print``(arr[i], arr[j])` `            ``else``:` `                ``print``(arr[j], arr[i])`

## C#

 `using` `System;`   `class` `Program` `{` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``// Define an array of integers` `        ``int``[] arr = { 1, -3, 2, 3, 6, -1 };`   `        ``// Get the length of the array` `        ``int` `n = arr.Length;`   `        ``// Loop over all pairs of elements in the array` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{` `            ``for` `(``int` `j = i + 1; j < n; j++)` `            ``{` `                ``// Check if the elements have opposite signs and equal absolute values` `                ``if` `((arr[i] > 0 && arr[j] < 0 && Math.Abs(arr[i]) == Math.Abs(arr[j])) ||` `                    ``(arr[i] < 0 && arr[j] > 0 && Math.Abs(arr[i]) == Math.Abs(arr[j])))` `                ``{` `                    ``// Print the pair of elements to the console` `                    ``if` `(arr[i] < 0)` `                    ``{` `                        ``Console.WriteLine(arr[i] + ``" "` `+ arr[j]);` `                    ``}` `                    ``else` `                    ``{` `                        ``Console.WriteLine(arr[j] + ``" "` `+ arr[i]);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}` `}` `// This code is contributed by shivamgupta310570`

## Javascript

 `// Define an array of integers` `const arr = [1, -3, 2, 3, 6, -1];`   `// Get the length of the array` `const n = arr.length;`   `// Loop over all pairs of elements in the array` `for` `(let i = 0; i < n; i++) {` `    ``for` `(let j = i + 1; j < n; j++) {` `        ``// Check if the elements have opposite signs and equal absolute values` `        ``if` `((arr[i] > 0 && arr[j] < 0 && Math.abs(arr[i]) === Math.abs(arr[j])) ||` `            ``(arr[i] < 0 && arr[j] > 0 && Math.abs(arr[i]) === Math.abs(arr[j]))) {` `            ``// Print the pair of elements to the console` `            ``if` `(arr[i] < 0) {` `                ``console.log(arr[i], arr[j]);` `            ``} ``else` `{` `                ``console.log(arr[j], arr[i]);` `            ``}` `        ``}` `    ``}` `}`   `// This code is contributed by shivamgupta310570`

Output

```-1 1
-3 3

```
` Time complexity   O(n^2), where n is the size of the input array.  Auxiliary Space  O(1), as it uses a constant amount of additional memory to store variables like the loop counters and the array elements. `

A better approach is to use sorting i.e. first sort the array and then for each negative element, do a binary search to find its counterpart (+ve number). If found, print that pair. If the current element is positive then break that loop as after that there will be all the positive numbers.

Implementation:

## C++

 `// CPP program to find pairs of positive` `// and negative values present in an array.` `#include ` `using` `namespace` `std;`   `void` `printPairs(``int` `arr[], ``int` `n)` `{` `    ``bool` `pair_exists = ``false``;` `    ``// Sort the array` `    ``sort(arr, arr + n);`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// For every arr[i] < 0 element,` `        ``// do a binary search for arr[i] > 0.` `        ``if` `(arr[i] < 0) {`   `            ``// If found, print the pair.` `            ``if` `(binary_search(arr, arr + n, -arr[i])) {` `                ``cout << arr[i] << ``", "` `<< -arr[i] << endl;`   `                ``pair_exists = ``true``;` `            ``}` `        ``}`   `        ``else` `            ``break``;` `    ``}`   `    ``if` `(pair_exists == ``false``)` `        ``cout << ``"No such pair exists"``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 4, 8, 9, -4, 1, -1, -8, -9 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``printPairs(arr, n);`   `    ``return` `0;` `}`

## Java

 `// Java program to find pairs ` `// of positive and negative ` `// values present in an array.` `import` `java.util.*;` `class` `GFG` `{` `static` `void` `printPairs(``int` `arr[], ``int` `n)` `{` `    ``boolean` `pair_exists = ``false``;` `    `  `    ``// Sort the array` `    ``Arrays.sort(arr);`   `    ``// Traverse the array` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{`   `        ``// For every arr[i] < 0 element,` `        ``// do a binary search for arr[i] > 0.` `        ``if` `(arr[i] < ``0``) ` `        ``{`   `            ``// If found, print the pair.` `            ``if` `(java.util.Arrays.binarySearch(arr, -arr[i])!=-``1``) ` `            ``{` `                ``System.out.println(arr[i] + ``", "` `+ -arr[i] );`   `                ``pair_exists = ``true``;` `            ``}` `        ``}`   `        ``else` `            ``break``;` `    ``}`   `    ``if` `(pair_exists == ``false``)` `        ``System.out.println(``"No such pair exists"``);` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``int` `arr[] = { ``4``, ``8``, ``9``, -``4``, ``1``, -``1``, -``8``, -``9` `};` `    ``int` `n =arr.length;`   `    ``printPairs(arr, n);` `}` `}`   `// This code is contributed` `// by Arnab Kundu`

## Python 3

 `# Python3 program to find pairs of positive ` `# and negative values present in an array. `   `# function for binary search` `def` `binary_search(a, x, lo``=``0``, hi``=``None``):` `    ``if` `hi ``is` `None``:` `        ``hi ``=` `len``(a)` `    ``while` `lo < hi:` `        ``mid ``=` `(lo``+``hi)``/``/``2` `        ``midval ``=` `a[mid]` `        ``if` `midval < x:` `            ``lo ``=` `mid``+``1` `        ``elif` `midval > x: ` `            ``hi ``=` `mid` `        ``else``:` `            ``return` `mid` `    ``return` `-``1`   `def` `printPairs(arr, n): `   `    ``pair_exists ``=` `False` `    ``# Sort the array ` `    ``arr.sort() `   `    ``# Traverse the array ` `    ``for` `i ``in` `range``(n):` `    `    `        ``# For every arr[i] < 0 element, ` `        ``# do a binary search for arr[i] > 0. ` `        ``if` `(arr[i] < ``0``): `   `            ``# If found, print the pair. ` `            ``if` `(binary_search(arr,``-``arr[i])): ` `                ``print``(arr[i] , ``", "` `, ``-``arr[i]) `   `                ``pair_exists ``=` `True` `        `  `        `    `        ``else``:` `            ``break` `    `    `    ``if` `(pair_exists ``=``=` `False``): ` `        ``print``(``"No such pair exists"``) `     `# Driver code ` `if` `__name__``=``=``'__main__'``:` `    ``arr ``=` `[ ``4``, ``8``, ``9``, ``-``4``, ``1``, ``-``1``, ``-``8``, ``-``9` `] ` `    ``n ``=` `len``(arr) `   `    ``printPairs(arr, n) ` `    `  `# this code is contributed by ash264`

## C#

 `// C# program to find pairs ` `// of positive and negative ` `// values present in an array. `   `using` `System;` `public` `class` `GFG{`   `static` `void` `printPairs(``int` `[]arr, ``int` `n) ` `{ ` `    ``bool` `pair_exists = ``false``; ` `    `  `    ``// Sort the array ` `    ``Array.Sort(arr); `   `    ``// Traverse the array ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ `   `        ``// For every arr[i] < 0 element, ` `        ``// do a binary search for arr[i] > 0. ` `        ``if` `(arr[i] < 0) ` `        ``{ `   `            ``// If found, print the pair. ` `            ``if` `(Array.BinarySearch(arr, -arr[i])!=-1) ` `            ``{ ` `                ``Console.WriteLine(arr[i] + ``", "` `+ -arr[i] ); `   `                ``pair_exists = ``true``; ` `            ``} ` `        ``} `   `        ``else` `            ``break``; ` `    ``} `   `    ``if` `(pair_exists == ``false``) ` `        ``Console.WriteLine(``"No such pair exists"``); ` `} `   `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `[]arr = { 4, 8, 9, -4, 1, -1, -8, -9 }; ` `    ``int` `n =arr.Length; `   `    ``printPairs(arr, n); ` `} ` `} `     `// This code is contributed by 29AjayKumar`

## Javascript

 `// JavaScript program to find pairs of positive` `// and negative values present in an array.`     `function` `printPairs(arr, n) {` `    ``let pair_exists = ``false``;` `    ``// Sort the array` `    ``arr.sort((a, b) => a - b);`   `    ``// Traverse the array` `    ``for` `(let i = 0; i < n; i++) {`   `        ``// For every arr[i] < 0 element,` `        ``// do a binary search for arr[i] > 0.` `        ``if` `(arr[i] < 0) {`   `            ``// If found, print the pair.` `            ``if` `(arr.includes(-arr[i])) {` `                ``document.write(arr[i] + ``", "` `+ -arr[i] + ``"
"``);`   `                ``pair_exists = ``true``;` `            ``}` `        ``}`   `        ``else` `            ``break``;` `    ``}`   `    ``if` `(pair_exists == ``false``)` `        ``document.write(``"No such pair exists"``);` `}`   `// Driver code` `let arr = [4, 8, 9, -4, 1, -1, -8, -9];` `let n = arr.length;`   `printPairs(arr, n);`

Output

```-9, 9
-8, 8
-4, 4
-1, 1

```

Time Complexity: O(n log n)
Auxiliary Space: O(1)

An efficient approach is to use hashing. Below are the required steps:

• Start traversing the array.
• Store all the positive values in an unordered_set.
• Check for each negative element, if their corresponding positive element exists in the set or not.
• If yes, print the pair
• Also, maintain a flag to check if no such pair exists.

Implementation:

## C++

 `// CPP program to find pairs of positive` `// and negative values present in an array` `#include ` `using` `namespace` `std;`   `// Function to print pairs of positive` `// and negative values present in the array` `void` `printPairs(``int` `arr[], ``int` `n)` `{` `    ``unordered_set<``int``> pairs;` `    ``bool` `pair_exists = ``false``;`   `    ``// Store all the positive elements` `    ``// in the unordered_set` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``if` `(arr[i] > 0)` `            ``pairs.insert(arr[i]);`   `    ``// Start traversing the array` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Check if the positive value of current` `        ``// element exists in the set or not` `        ``if` `(arr[i] < 0)` `            ``if` `(pairs.find(-arr[i]) != pairs.end())`   `            ``{ ``// Print that pair` `                ``cout << arr[i] << ``", "` `<< -arr[i] << endl;`   `                ``pair_exists = ``true``;` `            ``}` `    ``}`   `    ``if` `(pair_exists == ``false``)` `        ``cout << ``"No such pair exists"``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 4, 8, 9, -4, 1, -1, -8, -9 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``printPairs(arr, n);` `    ``return` `0;` `}`

## Java

 `// Java program to find pairs of positive ` `// and negative values present in an array ` `import` `java.util.*;` `class` `GFG` `{`   `// Function to print pairs of positive ` `// and negative values present in the array ` `static` `void` `printPairs(``int` `arr[], ``int` `n) ` `{ ` `    ``Set pairs = ``new` `HashSet(); ` `    ``boolean` `pair_exists = ``false``; `   `    ``// Store all the positive elements ` `    ``// in the unordered_set ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``if` `(arr[i] > ``0``) ` `            ``pairs.add(arr[i]); `   `    ``// Start traversing the array ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{ `   `        ``// Check if the positive value of current ` `        ``// element exists in the set or not ` `        ``if` `(arr[i] < ``0``) ` `            ``if` `(pairs.contains(-arr[i])) ` `            ``{ ` `                ``// Print that pair ` `                ``System.out.println(arr[i] + ``", "` `+ -arr[i]); `   `                ``pair_exists = ``true``; ` `            ``} ` `    ``} `   `    ``if` `(pair_exists == ``false``) ` `        ``System.out.println(``"No such pair exists"``); ` `} `   `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `arr[] = { ``4``, ``8``, ``9``, -``4``, ``1``, -``1``, -``8``, -``9` `}; ` `    ``int` `n = arr.length; `   `    ``printPairs(arr, n); ` `} ` `}`   `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 program to find pairs of positive ` `# and negative values present in an array `   `# Function to print pairs of positive ` `# and negative values present in the array ` `def` `printPairs(arr, n): `   `    ``pairs ``=` `set``() ` `    ``pair_exists ``=` `False`   `    ``# Store all the positive elements ` `    ``# in the unordered_set ` `    ``for` `i ``in` `range``(``0``, n): ` `        ``if` `arr[i] > ``0``: ` `            ``pairs.add(arr[i]) `   `    ``# Start traversing the array ` `    ``for` `i ``in` `range``(``0``, n): `   `        ``# Check if the positive value of current ` `        ``# element exists in the set or not ` `        ``if` `arr[i] < ``0``:` `            ``if` `(``-``arr[i]) ``in` `pairs: `   `            ``# Print that pair ` `                ``print``(``"{}, {}"``.``format``(arr[i], ``-``arr[i])) ` `                ``pair_exists ``=` `True`   `    ``if` `pair_exists ``=``=` `False``:` `        ``print``(``"No such pair exists"``)`   `# Driver code ` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``4``, ``8``, ``9``, ``-``4``, ``1``, ``-``1``, ``-``8``, ``-``9``] ` `    ``n ``=` `len``(arr) `   `    ``printPairs(arr, n)`   `# This code is contributed by Rituraj Jain`

## C#

 `// C# program to find pairs of positive ` `// and negative values present in an array ` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `// Function to print pairs of positive ` `// and negative values present in the array ` `static` `void` `printPairs(``int` `[]arr, ``int` `n) ` `{ ` `    ``HashSet<``int``> pairs = ``new` `HashSet<``int``>(); ` `    ``bool` `pair_exists = ``false``; `   `    ``// Store all the positive elements ` `    ``// in the unordered_set ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``if` `(arr[i] > 0) ` `            ``pairs.Add(arr[i]); `   `    ``// Start traversing the array ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ `   `        ``// Check if the positive value of current ` `        ``// element exists in the set or not ` `        ``if` `(arr[i] < 0) ` `            ``if` `(pairs.Contains(-arr[i])) ` `            ``{ ` `                ``// Print that pair ` `                ``Console.WriteLine(arr[i] + ``", "` `+ -arr[i]); `   `                ``pair_exists = ``true``; ` `            ``} ` `    ``} `   `    ``if` `(pair_exists == ``false``) ` `        ``Console.WriteLine(``"No such pair exists"``); ` `} `   `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``int` `[]arr = { 4, 8, 9, -4, 1, -1, -8, -9 }; ` `    ``int` `n = arr.Length; `   `    ``printPairs(arr, n); ` `} ` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

```-4, 4
-1, 1
-8, 8
-9, 9

```

Time Complexity: O(n)
Auxiliary Space: O(n) because using unordered_set

Article Tags :
Practice Tags :