Related Articles
Count maximum possible pairs from an array having sum K
• Last Updated : 21 Apr, 2021

Given an array arr[] consisting of N integers and an integer K, the task is to find the maximum number of pairs having sum K possible from 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 a variable ans as 0 to store the maximum number of pairs with 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 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

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

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

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

## 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 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 twicevoid maxPairs(vector nums, int k){         // Initialize a hashm    map 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 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 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 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 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#

 // 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 map            = new Dictionary();         // 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
Output:
2

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

My Personal Notes arrow_drop_up