Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Find two non-overlapping pairs having equal sum in an Array

  • Difficulty Level : Easy
  • Last Updated : 28 Oct, 2020

Given an unsorted array of integers. The task is to find any two non-overlapping pairs whose sum is equal.
Two pairs are said to be non-overlapping if all the elements of the pairs are at different indices. That is, pair (Ai, Aj) and pair (Am, An) are said to be non-overlapping if i ≠ j ≠ m ≠ n.

Examples: 

Input: arr[] = {8, 4, 7, 8, 4}
Output: Pair First(4, 8)
        Pair Second (8, 4)

Input: arr[] = {8, 4, 7, 4}
Output: No such non-overlapping pairs present.
Note: (8, 4) and (8, 4) forms overlapping pair
as index of 8 is same in both pairs.

The idea is to use a map of key-value pair to store all occurrences of a sum. The key in the map will store the sum and the corresponding value will be a list of pair of indices (i, j) with that sum.  

  • The idea is to traverse the array and generate all possible pairs.
  • If a new sum is found, insert it directly to the map otherwise check if any of the previously encountered pairs with that sum does not overlap with current pair.
  • If not, print both of the pairs.

Below is implementation of the above approach: 

C++




// C++ programs to find two non-overlapping
// pairs having equal sum in an Array
 
#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;
 
typedef pair<int, int> Pair;
 
// Function to find two non-overlapping
// with same sum in an array
void findPairs(int arr[], int n)
{
    // first create an empty map
    // key -> which is sum of a pair of
    // elements in the array
    // value -> vector storing index of
    // every pair having that sum
    unordered_map<int, vector<Pair> > map;
 
    // consider every pair (arr[i], arr[j])
    // and where (j > i)
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // calculate sum of current pair
            int sum = arr[i] + arr[j];
 
            // if sum is already present in the map
            if (map.find(sum) != map.end()) {
 
                // check every pair having equal sum
                for (auto pair : map.find(sum)->second) {
                    int m = pair.first, n = pair.second;
 
                    // if pairs don't overlap,
                    // print them and return
                    if ((m != i && m != j) && (n != i && n != j)) {
                        cout << "Pair First(" << arr[i] << ", "
                             << arr[j] << ")\nPair Second ("
                             << arr[m] << ", " << arr[n] << ")";
                        return;
                    }
                }
            }
 
            // Insert current pair into the map
            map[sum].push_back({ i, j });
        }
    }
 
    // If no such pair found
    cout << "No such non-overlapping pairs present";
}
 
// Driver Code
int main()
{
    int arr[] = { 8, 4, 7, 8, 4 };
    int size = sizeof(arr) / sizeof(arr[0]);
 
    findPairs(arr, size);
 
    return 0;
}
Java



// Java program to find two non-overlapping
// pairs having equal sum in an Array
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
// Declare a pair
class Pair {
    public int x, y;
 
    Pair(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}
 
class GFG {
    // Function to find two non-overlapping
    // pairs with same sum in an array
    public static void findPairs(int[] A)
    {
        // first create an empty map
        // key -> which is sum of a pair
        // of elements in the array
        // value -> list storing index of
        // every pair having that sum
        Map<Integer, List<Pair> > map = new HashMap<>();
 
        // consider every pair (A[i], A[j]) where (j > i)
        for (int i = 0; i < A.length - 1; i++) {
            for (int j = i + 1; j < A.length; j++) {
 
                // calculate sum of current pair
                int sum = A[i] + A[j];
 
                // if sum is already present in the map
                if (map.containsKey(sum)) {
 
                    // check every pair having desired sum
                    for (Pair pair : map.get(sum)) {
                        int x = pair.x;
                        int y = pair.y;
 
                        // if pairs don't overlap, print
                        // them and return
                        if ((x != i && x != j) && (y != i && y != j)) {
                            System.out.println("Pair First(" + A[i] + ", "
                                               + A[j] + ")");
 
                            System.out.println("Pair Second (" + A[x] + ", "
                                               + A[y] + ")");
 
                            return;
                        }
                    }
                }
 
                // Insert current pair into the map
                map.putIfAbsent(sum, new ArrayList<>());
                map.get(sum).add(new Pair(i, j));
            }
        }
 
        System.out.print("No such non-overlapping pairs present");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] A = { 8, 4, 7, 8, 4 };
 
        findPairs(A);
    }
}
Python3



# Python3 programs to find two non-overlapping
# pairs having equal Sum in an Array
 
# Function to find two non-overlapping
# with same Sum in an array
def findPairs(arr, size):
 
    # first create an empty Map
    # key -> which is Sum of a pair of
    # elements in the array
    # value -> vector storing index of
    # every pair having that Sum
    Map = {}
 
    # consider every pair (arr[i], arr[j])
    # and where (j > i)
    for i in range(0, size - 1):
        for j in range(i + 1, size):
             
            # calculate Sum of current pair
            Sum = arr[i] + arr[j]
 
            # if Sum is already present in the Map
            if Sum in Map:
 
                # check every pair having equal Sum
                for pair in Map[Sum]:
                    m, n = pair
 
                    # if pairs don't overlap,
                    # print them and return
                    if ((m != i and m != j) and
                        (n != i and n != j)):
                         
                        print("Pair First ({}, {})".
                               format(arr[i], arr[j]))
                        print("Pair Second ({}, {})".
                               format(arr[m], arr[n]))
                        return
                     
            # Insert current pair into the Map
            if Sum not in Map:
                Map[Sum] = []
            Map[Sum].append((i, j))
     
    # If no such pair found
    print("No such non-overlapping pairs present")
 
# Driver Code
if __name__ == "__main__":
 
    arr = [8, 4, 7, 8, 4]
    size = len(arr)
 
    findPairs(arr, size)
     
# This code is contributed by Rituraj Jain
C#



// C# program to find two non-overlapping
// pairs having equal sum in an Array
using System;
using System.Collections.Generic;
 
// Declare a pair
class Pair
{
    public int x, y;
 
    public Pair(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}
 
class GFG{
     
// Function to find two non-overlapping
// pairs with same sum in an array
public static void findPairs(int[] A)
{
     
    // First create an empty map
    // key -> which is sum of a pair
    // of elements in the array
    // value -> list storing index of
    // every pair having that sum
    Dictionary<int,
               List<Pair>> map = new Dictionary<int,
                                                List<Pair>>();
 
    // Consider every pair (A[i], A[j])
    // where (j > i)
    for(int i = 0; i < A.Length - 1; i++)
    {
        for(int j = i + 1; j < A.Length; j++)
        {
             
            // Calculate sum of current pair
            int sum = A[i] + A[j];
 
            // If sum is already present in the map
            if (map.ContainsKey(sum))
            {
                 
                // Check every pair having desired sum
                foreach(Pair pair in map[sum])
                {
                    int x = pair.x;
                    int y = pair.y;
 
                    // If pairs don't overlap, print
                    // them and return
                    if ((x != i && x != j) &&
                        (y != i && y != j))
                    {
                        Console.WriteLine("Pair First(" + A[i] +
                                          ", " + A[j] + ")");
 
                        Console.WriteLine("Pair Second (" + A[x] +
                                          ", " + A[y] + ")");
                       
                        return;
                    }
                }
            }
 
            // Insert current pair into the map
            map[sum] = new List<Pair>();
            map[sum].Add(new Pair(i, j));
        }
    }
 
    Console.Write("No such non-overlapping pairs present");
}
 
// Driver Code
public static void Main(String[] args)
{
    int[] A = { 8, 4, 7, 8, 4 };
 
    findPairs(A);
}
}
 
// This code is contributed by Princi Singh
Output: 
Pair First(4, 8)
Pair Second (8, 4)





 

My Personal Notes
arrow_drop_up
Previous
Linked List Product of Nodes Between 0s
Next

Tree with N nodes and K leaves such that distance between farthest leaves is minimized
Recommended Articles
Page :
Number of ways to select equal sized subarrays from two arrays having atleast K equal pairs of elements
06, May 20
Split array into two subsequences having minimum count of pairs with sum equal to X
09, Oct 20
Count pairs in an array having sum of elements with their respective sum of digits equal
10, Aug 21
Count pairs from two arrays having sum equal to K
15, Nov 18
Split an Array A[] into Subsets having equal Sum and sizes equal to elements of Array B[]
21, Aug 20
Count pairs from an array having product of their sum and difference equal to 0
09, Oct 20
Number of pairs in an array having sum equal to product
02, Jan 20
Count pairs from an array having product of their sum and difference equal to 1
12, Oct 20
Count pairs from an array having sum of twice of their AND and XOR equal to K
01, Feb 21
Count pairs from an array having equal sum and quotient
16, Feb 21
Check if array can be sorted by swapping pairs having GCD equal to the smallest element in the array
16, Sep 20
Rearrange array to make it non-decreasing by swapping pairs having GCD equal to minimum array element
23, Sep 20
Find the pairs of IDs from two arrays having sum less than target closest to it
27, Sep 21
Count of all possible pairs having sum of LCM and GCD equal to N
31, Jul 20
Maximum Count of pairs having equal Sum based on the given conditions
18, Aug 20
Find two non-intersecting subarrays having equal sum of all elements raised to the power of 2
23, Dec 20
Maximize count of pairs (i, j) from two arrays having element from first array not exceeding that from second array
21, Oct 20
Count of pairs having each element equal to index of the other from an Array
30, Jul 20
Count pairs from an array having GCD equal to the minimum element in the pair
27, Apr 21
Count ways to split array into two subsets having difference between their sum equal to K
09, Jun 21
Maximum sum subarray having sum less than or equal to given sum using Set
22, Apr 20
Maximum sum subarray having sum less than or equal to given sum
05, Aug 17
Pair of integers having least GCD among all given pairs having GCD exceeding K
16, Sep 20
Find the index having sum of elements on its left equal to reverse of the sum of elements on its right
13, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Rajput-Ji
@Rajput-Ji
Vote for difficulty
Current difficulty :
Easy





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

Start Your Coding Journey Now!