GeeksforGeeks App
Open App
Browser
Continue

# Count maximum possible pairs from an array having sum K

Given an array arr[] consisting of N integers and an integer K, the task is to find the maximum number of pairs having a sum K possible from the given array.

Note: Every array element can be part of a single pair.

Examples:

Input: arr[] = {1, 2, 3, 4}, K = 5
Output: 2
Explanation: Pairs with sum K from the array are (1, 4), and (2, 3).

Input: arr[] = {3, 1, 3, 4, 3}, K = 6
Output: 1
Explanation: Pair with sum K from the array is (3, 3).

Two-Pointer Approach: The idea is to use the Two Pointer Technique. Follow the steps below to solve the problem:

• Initialize the variable ans as 0 to store the maximum number of pairs with the sum K.
• Sort the array arr[] in increasing order.
• Initialize two index variables L as 0 and R as (N – 1) to find the candidate elements in the sorted array.
• Iterate until L is less than R and do the following:
• Check if the sum of arr[L] and arr[R] is K or not. If found to be true, then increment ans and L by 1 and decrement R by 1.
• If the sum of arr[L] and arr[R] is less than K, then increment L by 1.
• Otherwise, decrement R by 1.
• After the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the maximum number``// of pairs from given array with sum K``void` `maxPairs(``int` `nums[], ``int` `n, ``int` `k)``{` `  ``// Sort array in increasing order``  ``sort(nums, nums + n);` `  ``// Stores the final result``  ``int` `result = 0;` `  ``// Initialize the left and right pointers``  ``int` `start = 0, end = n - 1;` `  ``// Traverse array until start < end``  ``while` `(start < end) {` `    ``if` `(nums[start] + nums[end] > k)` `      ``// Decrement right by 1``      ``end--;` `    ``else` `if` `(nums[start] + nums[end] < k)` `      ``// Increment left by 1``      ``start++;` `    ``// Increment result and left``    ``// pointer by 1 and decrement``    ``// right pointer by 1``    ``else``    ``{``      ``start++;``      ``end--;``      ``result++;``    ``}``  ``}` `  ``// Print the result``  ``cout << result << endl;;``}` `// Driver Code``int` `main()``{``  ``int` `arr[] = { 1, 2, 3, 4 };``  ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);``  ``int` `K = 5;` `  ``// Function Call``  ``maxPairs(arr, n, K);` `  ``return` `0;``}` `// This code is contributed by AnkThon`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// Function to count the maximum number``    ``// of pairs from given array with sum K``    ``public` `static` `void` `maxPairs(``int``[] nums, ``int` `k)``    ``{``        ``// Sort array in increasing order``        ``Arrays.sort(nums);` `        ``// Stores the final result``        ``int` `result = ``0``;` `        ``// Initialize the left and right pointers``        ``int` `start = ``0``, end = nums.length - ``1``;` `        ``// Traverse array until start < end``        ``while` `(start < end) {` `            ``if` `(nums[start] + nums[end] > k)` `                ``// Decrement right by 1``                ``end--;` `            ``else` `if` `(nums[start] + nums[end] < k)` `                ``// Increment left by 1``                ``start++;` `            ``// Increment result and left``            ``// pointer by 1 and decrement``            ``// right pointer by 1``            ``else` `{``                ``start++;``                ``end--;``                ``result++;``            ``}``        ``}` `        ``// Print the result``        ``System.out.println(result);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``1``, ``2``, ``3``, ``4` `};``        ``int` `K = ``5``;` `        ``// Function Call``        ``maxPairs(arr, K);``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Function to count the maximum number``# of pairs from given array with sum K``def` `maxPairs(nums, k):``    ` `    ``# Sort array in increasing order``    ``nums ``=` `sorted``(nums)` `    ``# Stores the final result``    ``result ``=` `0` `    ``# Initialize the left and right pointers``    ``start, end ``=` `0``, ``len``(nums) ``-` `1``    ` `    ``# Traverse array until start < end``    ``while` `(start < end):``        ``if` `(nums[start] ``+` `nums[end] > k):` `            ``# Decrement right by 1``            ``end ``-``=` `1` `        ``elif` `(nums[start] ``+` `nums[end] < k):` `            ``# Increment left by 1``            ``start ``+``=` `1``            ` `        ``# Increment result and left``        ``# pointer by 1 and decrement``        ``# right pointer by 1``        ``else``:``            ``start ``+``=` `1``            ``end ``-``=` `1``            ``result ``+``=` `1` `    ``# Print the result``    ``print``(result)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4` `]``    ``K ``=` `5` `    ``# Function Call``    ``maxPairs(arr, K)``    ` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;`` ` `class` `GFG{``     ` `    ``// Function to count the maximum number``    ``// of pairs from given array with sum K``    ``public` `static` `void` `maxPairs(``int``[] nums, ``int` `k)``    ``{``      ` `        ``// Sort array in increasing order``        ``Array.Sort(nums);`` ` `        ``// Stores the final result``        ``int` `result = 0;`` ` `        ``// Initialize the left and right pointers``        ``int` `start = 0, end = nums.Length - 1;`` ` `        ``// Traverse array until start < end``        ``while` `(start < end) {`` ` `            ``if` `(nums[start] + nums[end] > k)`` ` `                ``// Decrement right by 1``                ``end--;`` ` `            ``else` `if` `(nums[start] + nums[end] < k)`` ` `                ``// Increment left by 1``                ``start++;`` ` `            ``// Increment result and left``            ``// pointer by 1 and decrement``            ``// right pointer by 1``            ``else``            ``{``                ``start++;``                ``end--;``                ``result++;``            ``}``        ``}`` ` `        ``// Print the result``        ``Console.Write(result);``    ``}`` ` `// Driver Code   ``public` `static` `void` `Main()``{``  ``int``[] arr = { 1, 2, 3, 4 };``  ``int` `K = 5;``  ` `  ``// Function Call``  ``maxPairs(arr, K);``}``}` `// This code is contributed by susmitakundugoaldanga`

## Javascript

 ``

Output:

`2`

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

Efficient Approach: To optimize the above approach, the idea is to use hashing. Follow the steps below to solve the problem:

• Initialize a variable, say ans, to store the maximum number of pairs with the sum K.
• Initialize a hash table, say S, to store the frequency of elements in arr[].
• Traverse the array arr[] using a variable, say i, and perform the following steps:
• If the frequency of (K – arr[i]) is positive, then increment ans by 1 and decrement the frequency of (K – arr[i]) by 1.
• Otherwise, insert arr[i] with frequency 1 in the Hash Table.
• After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``#include ``using` `namespace` `std;` `// Function to find the maximum number``// of pairs with a sum K such that``// same element can't be used twice``void` `maxPairs(vector<``int``> nums, ``int` `k)``{``    ` `    ``// Initialize a hashm``    ``map<``int``, ``int``> m;``    ` `    ``// Store the final result``    ``int` `result = 0;` `    ``// Iterate over the array nums[]``    ``for``(``auto` `i : nums)``    ``{``        ` `        ``// Decrement its frequency``        ``// in m and increment``        ``// the result by 1``        ``if` `(m.find(i) != m.end() && m[i] > 0)``        ``{``            ``m[i] = m[i] - 1;``            ``result++;``        ``}` `        ``// Increment its frequency by 1``        ``// if it is already present in m.``        ``// Otherwise, set its frequency to 1``        ``else``        ``{``            ``m[k - i] = m[k - i] + 1;``        ``}``    ``}``    ` `    ``// Print the result``    ``cout << result;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr = { 1, 2, 3, 4 };``    ``int` `K = 5;` `    ``// Function Call``    ``maxPairs(arr, K);``}` `// This code is contributed by grand_master`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the maximum number``    ``// of pairs with a sum K such that``    ``// same element can't be used twice``    ``public` `static` `void` `maxPairs(``        ``int``[] nums, ``int` `k)``    ``{` `        ``// Initialize a hashmap``        ``Map map``            ``= ``new` `HashMap<>();` `        ``// Store the final result``        ``int` `result = ``0``;` `        ``// Iterate over the array nums[]``        ``for` `(``int` `i : nums) {` `            ``// Decrement its frequency``            ``// in map and increment``            ``// the result by 1``            ``if` `(map.containsKey(i) &&``                ``map.get(i) > ``0``)``            ``{` `                ``map.put(i, map.get(i) - ``1``);``                ``result++;``            ``}` `            ``// Increment its frequency by 1``            ``// if it is already present in map.``            ``// Otherwise, set its frequency to 1``            ``else``            ``{``                ``map.put(k - i,``                        ``map.getOrDefault(k - i, ``0``) + ``1``);``            ``}``        ``}` `        ``// Print the result``        ``System.out.println(result);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``1``, ``2``, ``3``, ``4` `};``        ``int` `K = ``5``;` `        ``// Function Call``        ``maxPairs(arr, K);``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Function to find the maximum number``# of pairs with a sum K such that``# same element can't be used twice``def` `maxPairs(nums, k) :``    ` `    ``# Initialize a hashm``    ``m ``=` `{}``    ` `    ``# Store the final result``    ``result ``=` `0` `    ``# Iterate over the array nums[]``    ``for` `i ``in` `nums :``        ` `        ``# Decrement its frequency``        ``# in m and increment``        ``# the result by 1``        ``if` `((i ``in` `m) ``and` `m[i] > ``0``) :       ``            ``m[i] ``=` `m[i] ``-` `1``            ``result ``+``=` `1` `        ``# Increment its frequency by 1``        ``# if it is already present in m.``        ``# Otherwise, set its frequency to 1``        ``else` `:``        ` `            ``if` `k ``-` `i ``in` `m :``                ``m[k ``-` `i] ``+``=` `1``            ``else` `:``                ``m[k ``-` `i] ``=` `1``    ` `    ``# Print the result``    ``print``(result)` `# Driver code   ``arr ``=` `[ ``1``, ``2``, ``3``, ``4` `]``K ``=` `5` `# Function Call``maxPairs(arr, K)` `# This code is contributed by divyesh072019`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `    ``// Function to find the maximum number``    ``// of pairs with a sum K such that``    ``// same element can't be used twice``    ``public` `static` `void` `maxPairs(``        ``int``[] nums, ``int` `k)``    ``{` `        ``// Initialize a hashmap``        ``Dictionary<``int``, ``int``> map``            ``= ``new` `Dictionary<``int``, ``int``>();` `        ``// Store the readonly result``        ``int` `result = 0;` `        ``// Iterate over the array nums[]``        ``foreach` `(``int` `i ``in` `nums)``        ``{` `            ``// Decrement its frequency``            ``// in map and increment``            ``// the result by 1``            ``if` `(map.ContainsKey(i) &&``                ``map[i] > 0)``            ``{` `                ``map[i] = map[i] - 1;``                ``result++;``            ``}` `            ``// Increment its frequency by 1``            ``// if it is already present in map.``            ``// Otherwise, set its frequency to 1``            ``else``            ``{``              ``if` `(!map.ContainsKey(k - i))``                  ``map.Add(k - i, 1);``              ``else``                  ``map[i] = map[i] + 1;``            ``}``        ``}` `        ``// Print the result``        ``Console.WriteLine(result);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = {1, 2, 3, 4};``        ``int` `K = 5;` `        ``// Function Call``        ``maxPairs(arr, K);``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up