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

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:

```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 ` `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

 ` `

Output:

` True `

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

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.