Open In App

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

Pair the integers of Array so that each pair sum is consecutive and distinct

Given an array arr[]of size N. We have to pair the integers such that each integer should be in exactly one pair and each sum of pairs is consecutive and distinct. Formally, sum(arri +  arrj) + 1 = sum(arri1 + arrj1). Print the pairs of integers satisfying all the conditions. If it is not possible to find the pairs return -1.

Examples:



Input: N = 6, arr[] = {2, 3, 1, 4, 6, 5}
Output:
1 6 
3 5
4 2
Explanation: All pair’s sum is consecutive.

Input: N = 8 arr[] = {8, 7, 1, 2, 3, 5, 6, 4}
Output: -1



Approach: This can be solved with the following idea:

As we can choose any pair and as the array is a permutation we can ignore the arrangement in the array. Let’s assume that 1 to N is paired and each sum of the pair is: s, s + 1, ⋯, s + n/2 − 1. As the sum of the total number is equal to the sum s to s + n/2 − 1, we can obtain:

  • N(N + 1)/2 = (s + N/2 − 1 + s)N/4
  • or, 2N + 2 = 2S + N/2 – 1
  • let P = N/2.
  • or 4P + 2 = 2S + P + 1
  • as LHS = always even so P must be odd if P is even, then the answer will be -1.

If N/2 is even then we can find the pairs. Here is a pattern:

Fig: Pattern in the numbers

Steps involved in the implementation of code:

Below is the implementation of the above approach:

// C++ implementation of the code
#include <bits/stdc++.h>
using namespace std;

// Function to find pairs
void findPairs(int n, int a[])
{

    // N is reduced to N/2 for ease in
    // calculation
    n = n / 2;
    int end, start;

    // We can neglect the array
    if (n % 2 == 0) {

        // If the N/2 is even
        cout << -1 << endl;
    }
    else {

        int last = 2 * n;

        start = last / 2;
        end = start;
        start++;

        // To the next right element and
        // pair this element to the one
        // before the element of the
        // previous paired element

        while (end > 0) {
            cout << start << " " << end << endl;
            start++;
            end -= 2;
        }

        // The first element We have to
        // pair the second element with
        // the last element and the
        // fourth element with the second
        // last element.
        end = 2;

        start = last;
        while (end < (n + 1)) {
            cout << start << " " << end << endl;
            start--;
            end += 2;
        }
    }
    return;
}

// Driver code
int main()
{
    int n = 6;

    int a[] = { 2, 1, 5, 4, 6, 3 };

    // Function call
    findPairs(n, a);

    return 0;
}
// Java implementation of the code
import java.util.*;

class GFG {
  // Function to find pairs
  static void findPairs(int n, int[] a)
  {

    // N is reduced to N/2 for ease
    // in calculation
    n = n / 2;
    int end, start;

    // We can neglect the array
    if (n % 2 == 0) {
      // If the N/2 is even
      System.out.println("-1");
    }
    else {
      int last = 2 * n;
      start = last / 2;
      end = start;
      start++;

      // To the next right element and
      // pair this element to the one
      // before the element of the
      // previous paired element
      while (end > 0) {
        System.out.println(start + " " + end);
        start++;
        end -= 2;
      }

      // The first element We have to
      // pair the second element with
      // the last element and the
      // fourth element with the second
      // last element.
      end = 2;

      start = last;
      while (end < (n + 1)) {
        System.out.println(start + " " + end);
        start--;
        end += 2;
      }
    }
    return;
  }

  // Driver code
  public static void main(String[] args)
  {
    int n = 6;
    int[] a = { 2, 1, 5, 4, 6, 3 };

    // Function call
    findPairs(n, a);
  }
}
// This code is contributed by Prasad Kandekar(prasad264)
# Function to find pairs
def find_pairs(n, a):
    # N is reduced to N/2 for ease in calculation
    n = n // 2
    end, start = None, None

    # We can neglect the array
    if n % 2 == 0:
        # If the N/2 is even
        print(-1)
    else:
        last = 2 * n
        start = last // 2
        end = start
        start += 1

        # To the next right element and pair this element to the one
        # before the element of the previous paired element
        while end > 0:
            print(start, end)
            start += 1
            end -= 2

        # The first element We have to pair the second element with
        # the last element and the fourth element with the second
        # last element.
        end = 2
        start = last
        while end < n + 1:
            print(start, end)
            start -= 1
            end += 2


# Driver code
if __name__ == '__main__':
    n = 6
    a = [2, 1, 5, 4, 6, 3]

    # Function call
    find_pairs(n, a)

// JavaScript implementation of the code

// Function to find pairs
function findPairs(n, a) {

    // N is reduced to N/2 for ease in 
    // calculation
    n = Math.floor(n / 2);
    let end, start;

    // We can neglect the array
    if (n % 2 == 0) {

        // If the N/2 is even
        console.log(-1);
    }
    else {

        let last = 2 * n;

        start = Math.floor(last / 2);
        end = start;
        start++;

        // To the next right element and 
        // pair this element to the one 
        // before the element of the 
        // previous paired element
        while (end > 0) {
            console.log(start + " " + end);
            start++;
            end -= 2;
        }

        // The first element We have to 
        // pair the second element with 
        // the last element and the 
        // fourth element with the second 
        // last element.
        end = 2;

        start = last;
        while (end < (n + 1)) {
            console.log(start + " " + end);
            start--;
            end += 2;
        }
    }
}

// Driver code
let n = 6;
let a = [2, 1, 5, 4, 6, 3];

// Function call
findPairs(n, a);
using System;

public class Program
{
    // Function to find pairs
    public static void FindPairs(int n, int[] a)
    {
        // N is reduced to N/2 for ease in calculation
        n = n / 2;
        int end, start;

        // We can neglect the array
        if (n % 2 == 0)
        {
            // If the N/2 is even
            Console.WriteLine("-1");
        }
        else
        {
            int last = 2 * n;

            start = last / 2;
            end = start;
            start++;

            // To the next right element and
            // pair this element to the one
            // before the element of the
            // previous paired element
            while (end > 0)
            {
                Console.WriteLine(start + " " + end);
                start++;
                end -= 2;
            }

            // The first element We have to
            // pair the second element with
            // the last element and the
            // fourth element with the second
            // last element.
            end = 2;

            start = last;
            while (end < (n + 1))
            {
                Console.WriteLine(start + " " + end);
                start--;
                end += 2;
            }
        }
      
    }
  public static void Main()
    {
        int n = 6;

        int[] a = new int[] { 2, 1, 5, 4, 6, 3 };

        // Function call
        FindPairs(n, a);
    }
  
}
Output 
4 3
5 1
6 2

Time Complexity: O(N)
Auxiliary Space: O(1)

Article Tags :
Arrays
DSA
Recommended Articles
1. Find N distinct integers with GCD of sequence as 1 and GCD of each pair greater than 1
2. Form an array of distinct elements with each element as sum of an element from each array
3. Maximize sum of selected integers from an Array of pair of integers as per given condition
4. Count of ways to generate Sequence of distinct consecutive odd integers with sum N
5. Generate permutation of 1 to N such that absolute difference of consecutive numbers give K distinct integers
6. Find integers such that A contains exactly X distinct integers greater than A{i]
7. Count of elements to be multiplied with integers to make each pair of Array a perfect square
8. Number of triplets such that each value is less than N and each pair sum is a multiple of K
9. Maximum number of pairs of distinct array elements possible by including each element in only one pair
10. Generate longest Array containing distinct even integers with sum N
11. Last remaining value from 2^N integers after deleting Max from even sum and Min from odd sum pair
12. Find two integers such that at least one exists in each given Pair
13. Number expressed as sum of five consecutive integers
14. Remove two consecutive integers from 1 to N to make sum equal to S
15. Find K consecutive integers such that their sum is N
16. Sum of consecutive bit differences of first N non-negative integers
17. Count numbers up to N that cannot be expressed as sum of at least two consecutive positive integers
18. Count integers up to N which can be represented as sum of two or more consecutive numbers
19. Count of permutations of first N positive integers such that sum of any two consecutive numbers is prime
20. Check if N can be represented as sum of squares of two consecutive integers
21. Check if a number can be written as sum of three consecutive integers
22. Minimize insertions to make sum of every pair of consecutive array elements at most K
23. Rearrange an array to minimize sum of product of consecutive pair elements
24. Maximum score assigned to a subsequence of numerically consecutive and distinct array elements
25. Check if the sum of distinct digits of two integers are equal