Count odd and even Binomial Coefficients of N-th power

Given an integer N, the task is to count the number of even and odd binomial coefficients up to N^th power.

Examples:

Input: N = 4
Output:
Odd: 2
Even: 3
Explanation:
The binomial coefficients are as follows:
⁴C₀ = 1, ⁴C₁ = 4 , ⁴C₂ = 6 , ⁴C₃ = 4 , ⁴C₄ = 1.
Therefore, it can be observed that there exists exactly 2 odd and 3 even Binomial Coefficients.

Input: N = 5
Output:
Odd: 4
Even: 2
Explanation:
The binomial coefficients are as follows:
⁵C₀ = 1, ⁵C₁ = 5, ⁵C₂ = 10, ⁵C₃ = 10, ⁵C₄ = 5, ⁵C₅ = 1.
Therefore, there are 4 odd and 2 even coefficients.

Solution Approach: The idea to solve this problem is using Bit Manipulation. Find the set bits in the given integer N. Count of odd binomial coefficients are equal to 2 ^ Count of Set Bits in N. Similarly the count of even binomial coefficients is equal to (N + 1 – 2 ^ Count of Set Bits in N).

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <iostream>
#include <math.h>
using namespace std;

// Function to count set bits in
// binary representation of number N
int countSetBits(int N)
{
    int count = 0;

    // Count set bits in N
    while (N) {

        N = N & (N - 1);
        count++;
    }

    // Return the final count
    return count;
}

// Driver Code
int main()
{
    int N = 4;

    int bits = countSetBits(N);

    // Print odd Binomial coefficients
    cout << "Odd "
         << ": " << pow(2, bits) << "\n";

    // Print even Binomial coefficients
    cout << "Even "
         << ": " << N + 1 - pow(2, bits)
         << "\n";

    return 0;
}

Java

// Java program for the above approach
import java.util.*;

class GFG{

// Function to count set bits in
// binary representation of number N
static int countSetBits(int N)
{
    int count = 0;

    // Count set bits in N
    while (N != 0)
    {

        N = N & (N - 1);
        count++;
    }

    // Return the final count
    return count;
}

// Driver code
public static void main(String[] args)
{
    int N = 4;

    int bits = countSetBits(N);

    // Print odd Binomial coefficients
    System.out.println("Odd " + ": " +
               (int)(Math.pow(2, bits)));

    // Print even Binomial coefficients
    System.out.println("Even " + ": " +
               (N + 1 - (int)(Math.pow(2, bits))));
}
}

// This code is contributed by susmitakundugoaldanga

Python3

# Python3 program for the above approach

# Function to count set bits in
# binary representation of number N
def countSetBits(N: int) -> int:

    count = 0

    # Count set bits in N
    while (N):
        N = N & (N - 1)
        count += 1

    # Return the final count
    return count

# Driver Code
if __name__ == "__main__":

    N = 4

    bits = countSetBits(N)

    # Print odd Binomial coefficients
    print("Odd : {}".format(pow(2, bits)))

    # Print even Binomial coefficients
    print("Even : {}".format(N + 1 - pow(2, bits)))

# This code is contributed by sanjeev2552

C#

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

class GFG{

// Function to count set bits in
// binary representation of number N
static int countSetBits(int N)
{
    int count = 0;

    // Count set bits in N
    while (N != 0)
    {
        N = N & (N - 1);
        count++;
    }

    // Return the final count
    return count;
}

// Driver Code
public static void Main()
{
    int N = 4;
    int bits = countSetBits(N);

    // Print odd Binomial coefficients
    Console.WriteLine("Odd " + ": " +
                     (int)(Math.Pow(2, bits)));

    // Print even Binomial coefficients
    Console.WriteLine("Even " + ": " +
                     (N + 1 - (int)(Math.Pow(2, bits))));
}
}

// This code is contributed by sanjoy_62

Javascript

<script>

// Javascript program for the above approach

// Function to count set bits in
// binary representation of number N
function countSetBits(N)
{
    let count = 0;

    // Count set bits in N
    while (N != 0)
    {
        N = N & (N - 1);
        count++;
    }

    // Return the final count
    return count;
}

// Driver Code
let N = 4;

let bits = countSetBits(N);

// Print odd Binomial coefficients
document.write("Odd " + ": " +
              (Math.pow(2, bits)) + "<br/>");

// Print even Binomial coefficients
document.write("Even " + ": " +
              (N + 1 - (Math.pow(2, bits))));

// This code is contributed by splevel62

</script>

Output:

Odd : 2
Even : 3

Time Complexity: O(log N), where N is the input number
Auxiliary Space: O(1)

Approach: To count the number of odd and even binomial coefficients of N-th power, we can use the following approach

1. Initialize two counters, one for counting odd coefficients and one for counting even coefficients, to zero.
2. Loop through all possible values of k from 0 to N.
3. For each value of k, calculate the binomial coefficient C(N, k) using the formula: C(N, k) = N! / (k! * (N – k)!) where “!” denotes the factorial function.
4. Check if the calculated binomial coefficient is odd or even. If it’s odd, increment the counter for odd coefficients. If it’s even, increment the counter for even coefficients. After the loop, the counters will contain the total count of odd and even binomial coefficients for N-th power.

C++

#include <iostream>
#include <tuple> // Include the tuple library

using namespace std;

tuple<int, int> count_odd_even_binomial_coefficients(int N) {
    int odd_count = 0;
    int even_count = 0;

    for (int k = 0; k <= N; k++) {
        int coefficient = 1;
        for (int i = 1; i <= k; i++) {
            coefficient = coefficient * (N - i + 1) / i;
        }

        if (coefficient % 2 == 0) {
            even_count++;
        } else {
            odd_count++;
        }
    }

    return make_tuple(odd_count, even_count); // Use make_tuple to return a tuple
}

int main() {
    int N = 4;
    int odd_count, even_count;
    tie(odd_count, even_count) = count_odd_even_binomial_coefficients(N);
    cout << "Odd: " << odd_count << endl;
    cout << "Even: " << even_count << endl;

    return 0;
}

Output

Odd: 2
Even: 3

Time Complexity: O(N^2), where N is the input parameter. 
Auxiliary Space: O(1)