Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Last Updated : 09 Jul, 2021

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 3

Input: arr[] = { 4, 8, 9, -4, 1, -1, -8, -9 }
Output: -1 1 -4 4 -8 8 -9 9

A naive approach is to run two loops i.e. Consider each element of the array using the outer loop and search for its corresponding positive/negative value in the array using an inner loop. Similarly, find all the pairs. Time Complexity of this approach will be O( n2).
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.
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

C++




// CPP program to find pairs of positive
// and negative values present in an array.
#include <bits/stdc++.h>
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



<script>
 
// 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] + "<br>");
 
                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);
 
</script>
Output: 


-9, 9
-8, 8
-4, 4
-1, 1
 
Time Complexity: O(nlogn)
An efficient Approach is to use hashing. Below are the required steps: 
 
  • Start traversing the array.
  • Store all the psoitve 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.
 
C++



// CPP program to find pairs of positive
// and negative values present in an array
#include <bits/stdc++.h>
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<Integer> pairs = new HashSet<Integer>();
    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



<script>
 
// JavaScript 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
function printPairs(arr,n)
{
    let pairs = new Set();
    let pair_exists = false;
  
    // Store all the positive elements
    // in the unordered_set
    for (let i = 0; i < n; i++)
        if (arr[i] > 0)
            pairs.add(arr[i]);
  
    // Start traversing the array
    for (let 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.has(-arr[i]))
            {
                // Print that pair
                document.write(arr[i] + ", " + -arr[i]+"<br>");
  
                pair_exists = true;
            }
    }
  
    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);
 
// This code is contributed by avanitrachhadiya2155
 
</script>
Output: 
-4, 4
-1, 1
-8, 8
-9, 9
 
Time Complexity: O(n)
 



My Personal Notes
arrow_drop_up
Previous
Pairs of Positive Negative values in an array
Next

C program to count Positive and Negative numbers in an Array
Recommended Articles
Page :
Pairs of Positive Negative values in an array
20, Oct 17
Only integer with positive value in positive negative value in array
08, Nov 17
Find the last positive element remaining after repeated subtractions of smallest positive element from all Array elements
10, Sep 21
Largest number having both positive and negative values present in the array
17, Jun 21
Replace all elements by difference of sums of positive and negative numbers after that element
19, Mar 19
Move all negative numbers to beginning and positive to end with constant extra space
06, Sep 17
Count ways to obtain triplets with positive product consisting of at most one negative element
18, Jan 21
Rearrange positive and negative numbers in O(n) time and O(1) extra space
13, Apr 13
Check if array elements are consecutive in O(n) time and O(1) space (Handles Both Positive and negative numbers)
15, Jul 17
Segregating negative and positive maintaining order and O(1) space
19, Aug 18
Rearrange positive and negative numbers with constant extra space
19, Jul 16
Positive elements at even and negative at odd positions (Relative order not maintained)
12, Sep 17
Rearrange positive and negative numbers using inbuilt sort function
25, Oct 17
Lambda expression in Python to rearrange positive and negative numbers
27, Oct 17
Longest alternating (positive and negative) subarray starting at every index
09, Dec 17
Make three non-empty sets with negative, positive and 0 products
14, Nov 17
Partition negative and positive without comparison with 0
05, Jun 18
Find ratio of zeroes, positive numbers and negative numbers in the Array
19, Apr 20
C program to count Positive and Negative numbers in an Array
21, Apr 20
Maximum sum subset having equal number of positive and negative elements
07, May 20
Split array into three continuous subarrays with negative, 0 and positive product respectively
18, May 21
Longest alternating subsequence in terms of positive and negative integers
18, Mar 20
Maximum sum possible by assigning alternate positive and negative sign to elements in a subsequence
20, Oct 20
Minimum number of changes such that elements are first Negative and then Positive
08, Apr 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Aashish Chauhan
@Aashish Chauhan
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox