Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if a sorted array can be divided in pairs whose sum is k

  • Difficulty Level : Basic
  • Last Updated : 05 May, 2021

Given a sorted array of integers and a number k, write a function that returns true if given array can be divided into pairs such that sum of every pair k.
Expected time complexity O(n) and extra space O(1). This problem is a variation of below problem, but has a different interesting solution that requires only O(1) space.
Check if an array can be divided into pairs whose sum is divisible by k
 

Examples:

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.

 



Input: arr[] = {1, 3, 3, 5}, k = 6
Output: True
We can divide array into (1, 5) and (3, 3).
Sum of both of these pairs is 6.

Input: arr[] = {2, 5, 5, 5, 5, 8}, k = 10
Output: True
We can divide array into (2, 8), (5, 5) and 
(5, 5). Sum of all these pairs is 10.

 

We strongly recommend you to minimize your browser and try this yourself first.

A Simple Solution is to iterate through every element arr[i]. Find if there is another not yet visited element with value (k – arr[i]). If there is no such element, return false. If a pair is found, then mark both elements as visited. Time complexity of this solution is O(n2 and it requires O(n) extra space.
A Better Solution is to use Hashing. Solution given on this post can be easily modified to work. Time complexity of this solution is O9n) but it requires extra space for hash table.
An Efficient Solution is to use Meet in the Middle algorithm discussed in method 1 here. 

1) Initialize two index variables
  (a) Initialize first to the leftmost index: l = 0
  (b) Initialize second  the rightmost index:  r = n-1
2) Loop while l < r.
  (a) If (A[l] + A[r] != k)  then return false
  (b) Else r--, l++

Below is the implementation of above algorithm. 
 

C++




// A C++ program to check if arr[0..n-1] can be divided
// in pairs such that every pair has sum k.
#include <bits/stdc++.h>
using namespace std;
  
// Returns true if arr[0..n-1] can be divided into pairs
// with sum equal to k.
bool canPairsSorted(int arr[], int n, int k)
{
   // An odd length array cannot be divided into pairs
   if (n & 1)
       return false;  
 
   // Traverse from both sides of array
   int l = 0, r = n-1;
   while (l < r)
   {
       // If array can be divided, then sum of current
       // elements must be sum
       if (arr[l] + arr[r] != k)
          return false;
 
       // Move index variables
       l++; r--;
   }
 
   return true;
}
 
/* Driver program to test above function */
int main()
{
    int arr[] = {1, 2, 3, 3, 3, 3, 4, 5};
    int n = 6;
    int n = sizeof(arr)/sizeof(arr[0]);
    canPairs(arr, n, k)? cout << "True": cout << "False";
    return 0;
}
Java



// Java program to check if arr[0..n-1] can be divided
// in pairs such that every pair has sum k.
 
class GFG {
 
// Returns true if arr[0..n-1] can be divided into pairs
// with sum equal to k.
    static boolean canPairs(int arr[], int n, int k) {
// An odd length array cannot be divided into pairs
        if (n == 1) {
            return false;
        }
 
// Traverse from both sides of array
        int l = 0, r = n - 1;
        while (l < r) {
            // If array can be divided, then sum of current
            // elements must be sum
            if (arr[l] + arr[r] != k) {
                return false;
            }
 
            // Move index variables
            l++;
            r--;
        }
 
        return true;
    }
 
// Drivers code
    public static void main(String[] args) {
        int arr[] = {1, 2, 3, 3, 3, 3, 4, 5};
        int k = 6;
        int n = arr.length;
        if (canPairs(arr, n, k)) {
            System.out.println("True");
        } else {
            System.out.println("False");
        }
    }
}
//This code contributed by 29AjayKumar
Python 3



# A Python3 program to check if arr[0..n-1] can be
# divided in pairs such that every pair has sum k.
 
# Returns true if arr[0..n-1] can be divided
# into pairs with sum equal to k.
def canPairsSorted(arr, n, k):
 
    # An odd length array cannot
    # be divided into pairs
    if (n & 1):
        return False;
     
    # Traverse from both sides of array
    l = 0; r = n - 1;
    while (l < r):
     
        # If array can be divided, then
        # sum of current elements must be sum
        if (arr[l] + arr[r] != k):
            return False;
     
        # Move index variables
        l = l + 1; r = r - 1;
     
    return True
 
# Driver Code
arr = [1, 2, 3, 3, 3, 3, 4, 5]
k = 6
n = len(arr)
if(canPairsSorted(arr, n, k)):
    print("True")
else:
    print("False");
 
# This code is contributed
# by Akanksha Rai
C#



// C# program to check if arr[0..n-1]
// can be divided in pairs such that
// every pair has sum k.
using System;
 
class GFG
{
 
// Returns true if arr[0..n-1]
// can be divided into pairs
// with sum equal to k.
static bool canPairs(int []arr, int n, int k)
{
    // An odd length array cannot
    // be divided into pairs
    if (n == 1)
    {
        return false;
    }
 
    // Traverse from both sides of array
    int l = 0, r = n - 1;
    while (l < r)
    {
        // If array can be divided,
        // then sum of current
        // elements must be sum
        if (arr[l] + arr[r] != k)
        {
            return false;
        }
 
        // Move index variables
        l++;
        r--;
    }
 
    return true;
}
 
// Driver code
public static void Main()
{
    int []arr = {1, 2, 3, 3, 3, 3, 4, 5};
    int k = 6;
    int n = arr.Length;
    if (canPairs(arr, n, k))
    {
        Console.Write("True");
    }
    else
    {
        Console.Write("False");
    }
}
}
 
// This code is contributed by PrinciRaj
PHP



<?php
// A PHP program to check if arr[0..n-1]
// can be divided in pairs such that
// every pair has sum k.
 
// Returns true if arr[0..n-1] can be
// divided into pairs with sum equal to k.
function canPairs(&$arr, $n, $k)
{
    // An odd length array cannot be
    // divided into pairs
    if ($n & 1)
        return false;
     
    // Traverse from both sides of array
    $l = 0;
    $r = $n - 1;
    while ($l < $r)
    {
        // If array can be divided, then sum
        // of current elements must be sum
        if ($arr[$l] + $arr[$r] != $k)
            return false;
     
        // Move index variables
        $l++;
        $r--;
    }
     
    return true;
}
 
// Driver Code
$arr = array(1, 2, 3, 3, 3, 3, 4, 5);
$n = 6;
$k = 6;
$n = sizeof($arr);
if (canPairs($arr, $n, $k))
    echo ("True");
else
    echo ("False");
 
// This code is contributed
// by Shivi_Aggarwal
?>
Javascript



<script>
// Java Script program to check if arr[0..n-1] can be divided
// in pairs such that every pair has sum k.
 
// Returns true if arr[0..n-1] can be divided into pairs
// with sum equal to k.
    function canPairs(arr,n,k) {
// An odd length array cannot be divided into pairs
        if (n == 1) {
            return false;
        }
 
// Traverse from both sides of array
        let l = 0, r = n - 1;
        while (l < r)
        {
         
            // If array can be divided, then sum of current
            // elements must be sum
            if (arr[l] + arr[r] != k) {
                return false;
            }
 
            // Move index variables
            l++;
            r--;
        }
 
        return true;
    }
 
// Drivers code
        let arr = [1, 2, 3, 3, 3, 3, 4, 5];
        let k = 6;
        let n = arr.length;
        if (canPairs(arr, n, k)) {
            document.write("True");
        } else {
            document.write("False");
        }
 
 
// This code is contributed by Gottumukkala Sravan Kumar (171fa07058)
</script>
Output: 
 True 
Time Complexity: O(n) 
Auxiliary Space: O(1)
This article is contributed by Priyanka. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 



My Personal Notes
arrow_drop_up
Previous
Counters in Digital Logic
Next

Stop and Wait ARQ
Recommended Articles
Page :
Check if an array can be divided into pairs whose sum is divisible by k
02, Nov 15
Difference between ceil of array sum divided by K and sum of ceil of array elements divided by K
03, May 21
Check if a given array can be divided into pairs with even sum
14, Oct 20
Check if an array of pairs can be sorted by swapping pairs with different first elements
29, Apr 21
Check if an array of 1s and 2s can be divided into 2 parts with equal sum
14, Feb 19
Check if ceil of number divided by power of two exist in sorted array
15, Jul 20
Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
16, Nov 20
Generate Array whose sum of all K-size subarrays divided by N leaves remainder X
29, Jun 20
Check if array can be divided into two sub-arrays such that their absolute difference is K
29, Jan 19
Check if given Array can be divided into subsequences of K increasing consecutive integers
29, Sep 21
Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element
17, Sep 20
Check if an array can be sorted by swapping pairs from indices consisting of unequal elements in another array
03, Feb 21
Check if array can be sorted by swapping pairs having GCD equal to the smallest element in the array
16, Sep 20
Find if array can be divided into two subarrays of equal sum
04, Aug 16
Find the sums for which an array can be divided into sub-arrays of equal sum
31, Dec 18
Count pairs in a sorted array whose sum is less than x
31, Mar 17
Smallest subarray whose product leaves remainder K when divided by size of the array
18, Jul 20
Check if the array can be sorted only if the elements on given positions can be swapped
07, May 20
Count pairs from two sorted arrays whose sum is equal to a given value x
23, Jun 17
Number of K's such that the given array can be divided into two sets satisfying the given conditions
29, Oct 19
Minimize the sum of the squares of the sum of elements of each group the array is divided into
11, Feb 19
Count pairs in a sorted array whose product is less than k
19, Sep 18
Check if all array elements can be made divisible by K by replacing array elements with sum of pairs
17, Feb 21
Maximum number of partitions that can be sorted individually to make sorted
28, Feb 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Basic





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