Count of permutations such that sum of K numbers from given range is even

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.

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 * (2^K)) 
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 previous odd sum as prev_odd = odd_sum where even_sum = (prev_even*even_count) + (prev_odd*odd_count) and odd_sum = (prev_even*odd_count) + (prev_odd*even_count).
4. Print the even_sum at the end as there is a count for the odd sum because the previous odd_sum will contribute to the next even_sum.

Below is the implementation of the above approach: 

  
// C++ program for the above approach 
#include<bits/stdc++.h>
using namespace std;

// Function to return the number 
// of all permutations such that 
// sum of K numbers in range is even 
int 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 
    cout << (even_sum); 
} 

// Driver Code 
int main()
{ 
    
    // Given ranges 
    int low = 4; 
    int high = 5; 

    // Length of permutation 
    int K = 3; 
    
    // Function call 
    countEvenSum(low, high, K); 
}

// This code is contributed by Stream_Cipher

// 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);
    }
}

# Python3 program for the above approach 

# Function to return the number 
# of all permutations such that 
# sum of K numbers in range is even 
def countEvenSum(low, high, k):

    # Find total count of even and 
    # odd number in given range 
    even_count = high / 2 - (low - 1) / 2
    odd_count = (high + 1) / 2 - low / 2

    even_sum = 1
    odd_sum = 0

    # Iterate loop k times and update 
    # even_sum & odd_sum using 
    # previous values 
    for i in range(0, k):
        
        # Update the prev_even and 
        # odd_sum 
        prev_even = even_sum
        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 
    print(int(even_sum)) 

# Driver Code 

# Given ranges 
low = 4; 
high = 5; 

# Length of permutation 
K = 3; 

# Function call 
countEvenSum(low, high, K); 

# This code is contributed by Stream_Cipher

// C# program for the above approach
using System;

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
    Console.WriteLine(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);
}
}

// This code is contributed by amal kumar choubey

<script>

// JavaScript program for the above approach

    // Function to return the number
    // of all permutations such that
    // sum of K numbers in range is even
    function
    countEvenSum(low, high, k)
    {
        // Find total count of even and
        // odd number in given range
        let even_count = high / 2 - (low - 1) / 2;
        let odd_count = (high + 1) / 2 - low / 2;
  
        let even_sum = 1;
        let odd_sum = 0;
  
        // Iterate loop k times and update
        // even_sum & odd_sum using
        // previous values
        for (let i = 0; i < k; i++) {
  
            // Update the prev_even and
            // odd_sum
            let prev_even = even_sum;
            let 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
        document.write(even_sum);
    }


// Driver Code

     // Given ranges
        let low = 4;
        let high = 5;
  
        // Length of permutation
        let K = 3;
  
        // Function call
        countEvenSum(low, high, K);
     
</script>

4

Time Complexity: O(K)
Auxiliary Space: O(1)