Given a range [low, high], both inclusive, and an integer K, the task is to select K numbers from the range(a number can be chosen multiple times) such that the sum of those K numbers is even. Print the number of all such permutations.

Examples:

Input:_ low = 4, high = 5, k = 3_

Output:_ 4_

Explanation:

There are 4 valid permutation. They are {4, 4, 4}, {4, 5, 5}, {5, 4, 5} and {5, 5, 4} which sum up to an even number.

Input:_ low = 1, high = 10, k = 2_

Output:_ 50_

Explanation:

There are 50 valid permutations. They are {1, 1}, {1, 3}, … {1, 9} {2, 2}, {2, 4}, …, {2, 10}, …, {10, 2}, {10, 4}, … {10, 10}.

These 50 permutations, each sum up to an even number.

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: The idea is to find all subset of size K such that the sum of the subset is even and also calculate permutation for each required subset.

Time Complexity:_ O(K * (2K))_

Auxiliary Space:_ O(K)_

Efficient Approach: The idea is to use the fact that the sum of two even and odd numbers is always even. Follow the steps below to solve the problem:

1. Find the total count of even and odd numbers in the given range [low, high].
2. Initialize variable even_sum = 1 and odd_sum = 0 to store way to get even sum and odd sum respectively.
3. Iterate a loop K times and store the previous even sum as prev_even = even_sum and the previouse odd sum as prev_odd = odd_sum where even_sum = (prev_eveneven_count) + (prev_oddodd_count) and odd_sum = (prev_evenodd_count) + (prev_oddeven_count).
4. Print the even_sum at the end as there is a count for odd sum because the previous odd_sum will contribute to the next even_sum.

Below is the implementation of the above approach:

• Java

`// Java program for the above approach`

`**import**` `java.util.*;`

`**class**` `GFG {`

`// Function to return the number`

`// of all permutations such that`

`// sum of K numbers in range is even`

`**public**` `**static**` `**void**`

`countEvenSum(``**int**` `low,` `**int**` `high,`

`**int**` `k)`

`{`

`// Find total count of even and`

`// odd number in given range`

`**int**` `even_count = high /` `2` `- (low -` `1``) /` `2``;`

`**int**` `odd_count = (high +` `1``) /` `2` `- low /` `2``;`

`**long**` `even_sum =` `1``;`

`**long**` `odd_sum =` `0``;`

`// Iterate loop k times and update`

`// even_sum & odd_sum using`

`// previous values`

`**for**` `(``**int**` `i =` `0``; i < k; i++) {`

`// Update the prev_even and`

`// odd_sum`

`**long**` `prev_even = even_sum;`

`**long**` `prev_odd = odd_sum;`

`// Even sum`

`even_sum = (prev_even * even_count)`

`+ (prev_odd * odd_count);`

`// Odd sum`

`odd_sum = (prev_even * odd_count)`

`+ (prev_odd * even_count);`

`}`

`// Return even_sum`

`System.out.println(even_sum);`

`}`

`// Driver Code`

`**public**` `**static**` `**void**` `main(String[] args)`

`{`

`// Given ranges`

`**int**` `low =` `4``;`

`**int**` `high =` `5``;`

`// Length of permutation`

`**int**` `K =` `3``;`

`// Function call`

`countEvenSum(low, high, K);`

`}`

`}`

Output:

``````4
``````

Time Complexity:_ O(K)_

Auxiliary Space:_ O(1)_

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.

#arrays #dynamic programming #greedy #mathematical #adobe #array-range-queries #permutation #permutation and combination

7.90 GEEK