# Count ways to select K array elements lying in a given range

• Difficulty Level : Medium
• Last Updated : 27 Apr, 2021

Given three positive integers, L, R, K and an array arr[] consisting of N positive integers, the task is to count the number of ways to select at least K array elements from the given array having values in the range [L, R].

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {12, 4, 6, 13, 5, 10}, K = 3, L = 4, R = 10
Output:
Explanation:
Possible ways to select at least K(= 3) array elements having values in the range [4, 10] are: { (arr, arr, arr), (arr, arr, arr), (arr, arr, arr), (arr, arr, arr), (arr, arr, arr, arr) }
Therefore, the required output is 5.

Input: arr[] = {1, 2, 3, 4, 5}, K = 4, L = 1, R = 5
Output:

Approach: Follow the steps below to solve the problem:

• Initialize a variable, say cntWays, to store the count of ways to select at least K array elements having values lies in the range [L, R].
• Initialize a variable, say cntNum to store the count of numbers in the given array whose values lies in the range given range.
• Finally, print the sum of all possible value of such that (K + i) is less than or equal to cntNum.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to calculate factorial` `// of all the numbers up to N` `vector<``int``> calculateFactorial(``int` `N)` `{` `    ``vector<``int``> fact(N + 1);`   `    ``// Factorial of 0 is 1` `    ``fact = 1;`   `    ``// Calculate factorial of` `    ``// all the numbers upto N` `    ``for` `(``int` `i = 1; i <= N; i++) {`   `        ``// Calculate factorial of i` `        ``fact[i] = fact[i - 1] * i;` `    ``}`   `    ``return` `fact;` `}`   `// Function to find the count of ways to select` `// at least K elements whose values in range [L, R]` `int` `cntWaysSelection(``int` `arr[], ``int` `N, ``int` `K,` `                     ``int` `L, ``int` `R)` `{`   `    ``// Stores count of ways to select at least` `    ``// K elements whose values in range [L, R]` `    ``int` `cntWays = 0;`   `    ``// Stores count of numbers having` `    ``// value lies in the range [L, R]` `    ``int` `cntNum = 0;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Checks if the array elements` `        ``// lie in the given range` `        ``if` `(arr[i] >= L && arr[i] <= R) {`   `            ``// Update cntNum` `            ``cntNum++;` `        ``}` `    ``}`   `    ``// Stores factorial of numbers upto N` `    ``vector<``int``> fact` `        ``= calculateFactorial(cntNum);`   `    ``// Calculate total ways to select at least` `    ``// K elements whose values lies in [L, R]` `    ``for` `(``int` `i = K; i <= cntNum; i++) {`   `        ``// Update cntWays` `        ``cntWays += fact[cntNum] / (fact[i]` `                                   ``* fact[cntNum - i]);` `    ``}`   `    ``return` `cntWays;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 12, 4, 6, 13, 5, 10 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `K = 3;` `    ``int` `L = 4;` `    ``int` `R = 10;`   `    ``cout << cntWaysSelection(arr, N, K, L, R);` `}`

## Java

 `// Java program to implement` `// the above approach` `class` `GFG{`   `// Function to calculate factorial` `// of all the numbers up to N` `static` `int``[] calculateFactorial(``int` `N)` `{` `    ``int` `[]fact = ``new` `int``[N + ``1``];`   `    ``// Factorial of 0 is 1` `    ``fact[``0``] = ``1``;`   `    ``// Calculate factorial of` `    ``// all the numbers upto N` `    ``for` `(``int` `i = ``1``; i <= N; i++) {`   `        ``// Calculate factorial of i` `        ``fact[i] = fact[i - ``1``] * i;` `    ``}`   `    ``return` `fact;` `}`   `// Function to find the count of ways to select` `// at least K elements whose values in range [L, R]` `static` `int` `cntWaysSelection(``int` `arr[], ``int` `N, ``int` `K,` `                     ``int` `L, ``int` `R)` `{`   `    ``// Stores count of ways to select at least` `    ``// K elements whose values in range [L, R]` `    ``int` `cntWays = ``0``;`   `    ``// Stores count of numbers having` `    ``// value lies in the range [L, R]` `    ``int` `cntNum = ``0``;`   `    ``// Traverse the array` `    ``for` `(``int` `i = ``0``; i < N; i++) {`   `        ``// Checks if the array elements` `        ``// lie in the given range` `        ``if` `(arr[i] >= L && arr[i] <= R) {`   `            ``// Update cntNum` `            ``cntNum++;` `        ``}` `    ``}`   `    ``// Stores factorial of numbers upto N` `    ``int` `[]fact` `        ``= calculateFactorial(cntNum);`   `    ``// Calculate total ways to select at least` `    ``// K elements whose values lies in [L, R]` `    ``for` `(``int` `i = K; i <= cntNum; i++) {`   `        ``// Update cntWays` `        ``cntWays += fact[cntNum] / (fact[i]` `                                   ``* fact[cntNum - i]);` `    ``}`   `    ``return` `cntWays;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``12``, ``4``, ``6``, ``13``, ``5``, ``10` `};` `    ``int` `N = arr.length;` `    ``int` `K = ``3``;` `    ``int` `L = ``4``;` `    ``int` `R = ``10``;`   `    ``System.out.print(cntWaysSelection(arr, N, K, L, R));` `}` `}`   `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to implement the` `# above approach`   `# Function to calculate factorial ` `# of all the numbers up to N` `def` `calculateFactorial(N):`   `    ``fact ``=` `[``0``] ``*` `(N ``+` `1``)`   `    ``# Factorial of 0 is 1` `    ``fact[``0``] ``=` `1`   `    ``# Calculate factorial of all` `    ``# the numbers upto N` `    ``for` `i ``in` `range``(``1``, N ``+` `1``):`   `        ``# Calculate factorial of i` `        ``fact[i] ``=` `fact[i ``-` `1``] ``*` `i` `        `  `    ``return` `fact`   `# Function to find count of ways to select` `# at least K elements whose values in range[L,R]` `def` `cntWaysSelection(arr, N, K, L, R):` `    `  `    ``# Stores count of ways to select at leas` `    ``# K elements whose values in range[L,R]` `    ``cntWays ``=` `0`   `    ``# Stores count of numbers having` `    ``# Value lies in the range[L,R]` `    ``cntNum ``=` `0`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(``0``, N):` `        `  `        ``# Check if the array elements ` `        ``# Lie in the given range` `        ``if` `(arr[i] >``=` `L ``and` `arr[i] <``=` `R):` `            `  `            ``# Update cntNum` `            ``cntNum ``+``=` `1`   `    ``# Stores factorial of numbers upto N` `    ``fact ``=` `list``(calculateFactorial(cntNum))`   `    ``# Calculate total ways to select at least` `    ``# K elements whose values Lies in [L,R]` `    ``for` `i ``in` `range``(K, cntNum ``+` `1``):` `        `  `        ``# Update cntWays` `        ``cntWays ``+``=` `fact[cntNum] ``/``/` `(fact[i] ``*` `                                    ``fact[cntNum ``-` `i])` `                                    `  `    ``return` `cntWays `   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``arr ``=` `[ ``12``, ``4``, ``6``, ``13``, ``5``, ``10` `]` `    ``N ``=` `len``(arr)` `    ``K ``=` `3` `    ``L ``=` `4` `    ``R ``=` `10` `    `  `    ``print``(cntWaysSelection(arr, N, K, L, R))`   `# This code is contributed by Virusbuddah`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` ` `  `class` `GFG{` ` `  `// Function to calculate factorial` `// of all the numbers up to N` `static` `int``[] calculateFactorial(``int` `N)` `{` `    ``int``[] fact = ``new` `int``[(N + 1)];` `    `  `    ``// Factorial of 0 is 1` `    ``fact = 1;` `    `  `    ``// Calculate factorial of` `    ``// all the numbers upto N` `    ``for``(``int` `i = 1; i <= N; i++) ` `    ``{` `        `  `        ``// Calculate factorial of i` `        ``fact[i] = fact[i - 1] * i;` `    ``}` `    ``return` `fact;` `}` ` `  `// Function to find the count of ways to select` `// at least K elements whose values in range [L, R]` `static` `int` `cntWaysSelection(``int``[] arr, ``int` `N, ``int` `K,` `                            ``int` `L, ``int` `R)` `{` `    `  `    ``// Stores count of ways to select at least` `    ``// K elements whose values in range [L, R]` `    ``int` `cntWays = 0;` `    `  `    ``// Stores count of numbers having` `    ``// value lies in the range [L, R]` `    ``int` `cntNum = 0;` `    `  `    ``// Traverse the array` `    ``for``(``int` `i = 0; i < N; i++)` `    ``{` `        `  `        ``// Checks if the array elements` `        ``// lie in the given range` `        ``if` `(arr[i] >= L && arr[i] <= R) ` `        ``{` `            `  `            ``// Update cntNum` `            ``cntNum++;` `        ``}` `    ``}` ` `  `    ``// Stores factorial of numbers upto N` `    ``int``[] fact = calculateFactorial(cntNum);` ` `  `    ``// Calculate total ways to select at least` `    ``// K elements whose values lies in [L, R]` `    ``for``(``int` `i = K; i <= cntNum; i++) ` `    ``{` `        `  `        ``// Update cntWays` `        ``cntWays += fact[cntNum] / (fact[i] * ` `                   ``fact[cntNum - i]);` `    ``}` `    ``return` `cntWays;` `}` ` `  `// Driver Code` `public` `static` `void` `Main() ` `{` `    ``int``[] arr = { 12, 4, 6, 13, 5, 10 };` `    ``int` `N = arr.Length;` `    ``int` `K = 3;` `    ``int` `L = 4;` `    ``int` `R = 10;` `    `  `    ``Console.WriteLine(cntWaysSelection(` `        ``arr, N, K, L, R));` `}` `}`   `// This code is contributed by code_hunt`

## Javascript

 ``

Output:

`5`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :