Count maximum possible pairs from an array having sum K - GeeksforGeeks

17 Nov, 2021
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 = 5Output: 2Explanation: Pairs with sum K from the array are (1, 4), and (2, 3).
Input: arr[] = {3, 1, 3, 4, 3}, K = 6Output: 1Explanation: 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.
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++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to count the maximum number// of pairs from given array with sum Kvoid 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 Codeint 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 program for the above approachimport 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 program for the above approach # Function to count the maximum number# of pairs from given array with sum Kdef 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 Codeif __name__ == '__main__':         arr = [ 1, 2, 3, 4 ]    K = 5     # Function Call    maxPairs(arr, K)     # This code is contributed by mohit kumar 29
// C# program for the above approachusing 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
<script>     // JavaScript program for above approach     // Function to count the maximum number    // of pairs from given array with sum K    function maxPairs(nums, k)    {        // Sort array in increasing order        nums.sort();          // Stores the final result        let result = 0;          // Initialize the left and right pointers        let 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        document.write(result);    } // Driver Code            let arr = [ 1, 2, 3, 4 ];        let K = 5;          // Function Call        maxPairs(arr, K); </script>
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.
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++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>#include <string.h>using namespace std; // Function to find the maximum number// of pairs with a sum K such that// same element can't be used twicevoid 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 Codeint main(){    vector<int> arr = { 1, 2, 3, 4 };    int K = 5;     // Function Call    maxPairs(arr, K);} // This code is contributed by grand_master
// Java program for the above approachimport 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<Integer, Integer> 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 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 twicedef 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 CallmaxPairs(arr, K) # This code is contributed by divyesh072019
// C# program for the above approachusing 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
<script> // Javascript 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 twicefunction maxPairs(nums, k){         // Initialize a hashm    var m = new Map();         // Store the final result    var result = 0;     // Iterate over the array nums[]    nums.forEach(i => {                          // Decrement its frequency        // in m and increment        // the result by 1        if (m.has(i) && m.get(i) > 0)        {            m.set(i, m.get(i)-1);            result++;        }         // Increment its frequency by 1        // if it is already present in m.        // Otherwise, set its frequency to 1        else        {            if(m.has(k-i))                m.set(k-i, m.get(k-i)+1)            else                m.set(k-i, 1)        }    });         // Print the result    document.write( result);} // Driver Codevar arr = [1, 2, 3, 4];var K = 5;// Function CallmaxPairs(arr, K); </script>
2
 
Time Complexity: O(N)Auxiliary Space: O(N)
mohit kumar 29
susmitakundugoaldanga
ankthon
29AjayKumar
grand_master
divyesh072019
chinmoy1997pal
importantly
surinderdawra388
HashTable
two-pointer-algorithm
Arrays
Hash
Searching
Sorting
two-pointer-algorithm
Arrays
Searching
Hash
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Window Sliding Technique
Trapping Rain Water
Building Heap from Array
Reversal algorithm for array rotation
Program to find sum of elements in a given array
Internal Working of HashMap in Java
Hashing | Set 1 (Introduction)
Hashing | Set 3 (Open Addressing)
Count pairs with given sum
Hashing | Set 2 (Separate Chaining)