 Open in App
Not now

# Count of subsets having sum of min and max element less than K

• Difficulty Level : Medium
• Last Updated : 16 Jan, 2022

Given an integer array arr[] and an integer K, the task is to find the number of non-empty subsets S such that min(S) + max(S) < K.
Examples:

Input: arr[] = {2, 4, 5, 7} K = 8
Output: 4
Explanation:
The possible subsets are {2}, {2, 4}, {2, 4, 5} and {2, 5}
Input:: arr[] = {2, 4, 2, 5, 7} K = 10
Output: 26

Approach

• Sort the input array first.
• Now use Two Pointer Technique to count the number of subsets.
• Let take two pointers left and right and set left = 0 and right = N-1.

if (arr[left] + arr[right] < K )
Increment the left pointer by 1 and add 2 j – i into answer, because the left and right values make up a potential end values of a subset. All the values from [i, j – 1] also make up end of subsets which will have the sum < K. So, we need to calculate all the possible subsets for left = i and right ∊ [i, j]. So, after summing up values 2 j – i + 1 + 2 j – i – 2 + … + 2 0 of the GP, we get 2 j – i
if( arr[left] + arr[right] >= K )
Decrement the right pointer by 1.

• Repeat the below process until left <= right.

Below is the implementation of the above approach:

## C++

 `// C++ program to print count``// of subsets S such that``// min(S) + max(S) < K` `#include ``using` `namespace` `std;` `// Function that return the``// count of subset such that``// min(S) + max(S) < K``int` `get_subset_count(``int` `arr[], ``int` `K,``                     ``int` `N)``{``    ``// Sorting the array``    ``sort(arr, arr + N);` `    ``int` `left, right;``    ``left = 0;``    ``right = N - 1;` `    ``// ans stores total number of subsets``    ``int` `ans = 0;` `    ``while` `(left <= right) {``        ``if` `(arr[left] + arr[right] < K) {` `            ``// add all possible subsets``            ``// between i and j``            ``ans += 1 << (right - left);``            ``left++;``        ``}``        ``else` `{``            ``// Decrease the sum``            ``right--;``        ``}``    ``}``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 2, 4, 5, 7 };``    ``int` `K = 8;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << get_subset_count(arr, K, N);``    ``return` `0;``}`

## Java

 `// Java program to print count``// of subsets S such that``// Math.min(S) + Math.max(S) < K``import` `java.util.*;` `class` `GFG{` `// Function that return the``// count of subset such that``// Math.min(S) + Math.max(S) < K``static` `int` `get_subset_count(``int` `arr[], ``int` `K,``                                       ``int` `N)``{``    ` `    ``// Sorting the array``    ``Arrays.sort(arr);` `    ``int` `left, right;``    ``left = ``0``;``    ``right = N - ``1``;` `    ``// ans stores total number``    ``// of subsets``    ``int` `ans = ``0``;` `    ``while` `(left <= right)``    ``{``        ``if` `(arr[left] + arr[right] < K)``        ``{` `            ``// Add all possible subsets``            ``// between i and j``            ``ans += ``1` `<< (right - left);``            ``left++;``        ``}``        ``else``        ``{``            ` `            ``// Decrease the sum``            ``right--;``        ``}``    ``}``    ``return` `ans;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``2``, ``4``, ``5``, ``7` `};``    ``int` `K = ``8``;``    ``int` `N = arr.length;``    ` `    ``System.out.print(get_subset_count(arr, K, N));``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to print``# count of subsets S such``# that min(S) + max(S) < K` `# Function that return the``# count of subset such that``# min(S) + max(S) < K``def` `get_subset_count(arr, K, N):` `    ``# Sorting the array``    ``arr.sort()` `    ``left ``=` `0``;``    ``right ``=` `N ``-` `1``;` `    ``# ans stores total number of subsets``    ``ans ``=` `0``;` `    ``while` `(left <``=` `right):``        ``if` `(arr[left] ``+` `arr[right] < K):``            ` `            ``# Add all possible subsets``            ``# between i and j``            ``ans ``+``=` `1` `<< (right ``-` `left);``            ``left ``+``=` `1``;``        ``else``:``            ` `            ``# Decrease the sum``            ``right ``-``=` `1``;``    ` `    ``return` `ans;` `# Driver code``arr ``=` `[ ``2``, ``4``, ``5``, ``7` `];``K ``=` `8``;` `print``(get_subset_count(arr, K, ``4``))` `# This code is contributed by grand_master`

## C#

 `// C# program to print count``// of subsets S such that``// Math.Min(S) + Math.Max(S) < K``using` `System;` `class` `GFG{` `// Function that return the``// count of subset such that``// Math.Min(S) + Math.Max(S) < K``static` `int` `get_subset_count(``int` `[]arr, ``int` `K,``                                       ``int` `N)``{``    ` `    ``// Sorting the array``    ``Array.Sort(arr);` `    ``int` `left, right;``    ``left = 0;``    ``right = N - 1;` `    ``// ans stores total number``    ``// of subsets``    ``int` `ans = 0;` `    ``while` `(left <= right)``    ``{``        ``if` `(arr[left] + arr[right] < K)``        ``{``            ` `            ``// Add all possible subsets``            ``// between i and j``            ``ans += 1 << (right - left);``            ``left++;``        ``}``        ``else``        ``{``            ` `            ``// Decrease the sum``            ``right--;``        ``}``    ``}``    ``return` `ans;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 2, 4, 5, 7 };``    ``int` `K = 8;``    ``int` `N = arr.Length;``    ` `    ``Console.Write(get_subset_count(arr, K, N));``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output:

`4`

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

My Personal Notes arrow_drop_up