# Count total number of even sum sequences

Given an integer N, the task is to count all possible sequences of length N such that all the elements of the sequence are from the range [1, N] and the sum of the elements of the sequence is even. As the answer coulb be very large so print the answer modulo 109 + 7.

Examples:

Input: N = 3
Output: 13
All possible sequences of length 3 will be (1, 1, 2), (1, 3, 2),
(3, 1, 2), (3, 3, 2), (1, 2, 1), (1, 2, 3), (3, 2, 1), (3, 2, 3),
(2, 1, 1), (2, 1, 3), (2, 3, 1), (2, 3, 3) and (2, 2, 2).

Input: N = 5
Output: 1562

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

Approach: To get even sum for any sequence, the number of odd elements must be even. Let’s choose to put x number of odd elements in the sequence where x is even. The total number of ways to put these odd numbers will be C(N, x) and in each position, y number of elements can be put where y is the count of odd numbers from 1 to N and the remaining positions can be filled with even numbers in the same way. So if x odd numbers are to be taken then their contribution will be C(N, x) * yx * (N – y)(N – x).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `#define M 1000000007 ` `#define ll long long int ` ` `  `// Iterative function to calculate ` `// (x^y)%p in O(log y) ` `ll power(ll x, ll y, ll p) ` `{ ` ` `  `    ``// Initialize result ` `    ``ll res = 1; ` ` `  `    ``// Update x if it is greater ` `    ``// than or equal to p ` `    ``x = x % p; ` ` `  `    ``while` `(y > 0) { ` ` `  `        ``// If y is odd then multiply ` `        ``// x with the result ` `        ``if` `(y & 1) ` `            ``res = (res * x) % p; ` ` `  `        ``// y must be even now ` `        ``y = y >> 1; ``// y = y/2 ` `        ``x = (x * x) % p; ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Function to return n^(-1) mod p ` `ll modInverse(ll n, ll p) ` `{ ` `    ``return` `power(n, p - 2, p); ` `} ` ` `  `// Function to return (nCr % p) using ` `// Fermat's little theorem ` `ll nCrModPFermat(ll n, ll r, ll p) ` `{ ` `    ``// Base case ` `    ``if` `(r == 0) ` `        ``return` `1; ` ` `  `    ``// Fill factorial array so that we ` `    ``// can find all factorial of r, n ` `    ``// and n-r ` `    ``ll fac[n + 1]; ` `    ``fac = 1; ` `    ``for` `(ll i = 1; i <= n; i++) ` `        ``fac[i] = fac[i - 1] * i % p; ` ` `  `    ``return` `(fac[n] * modInverse(fac[r], p) % p ` `            ``* modInverse(fac[n - r], p) % p) ` `           ``% p; ` `} ` ` `  `// Function to return the count of ` `// odd numbers from 1 to n ` `ll countOdd(ll n) ` `{ ` `    ``ll x = n / 2; ` `    ``if` `(n % 2 == 1) ` `        ``x++; ` `    ``return` `x; ` `} ` ` `  `// Function to return the count of ` `// even numbers from 1 to n ` `ll counteEven(ll n) ` `{ ` `    ``ll x = n / 2; ` `    ``return` `x; ` `} ` ` `  `// Function to return the count ` `// of the required sequences ` `ll CountEvenSumSequences(ll n) ` `{ ` ` `  `    ``ll count = 0; ` ` `  `    ``for` `(ll i = 0; i <= n; i++) { ` ` `  `        ``// Take i even and n - i odd numbers ` `        ``ll even = i, odd = n - i; ` ` `  `        ``// Number of odd numbers must be even ` `        ``if` `(odd % 2 == 1) ` `            ``continue``; ` ` `  `        ``// Total ways of placing n - i odd ` `        ``// numbers in the sequence of n numbers ` `        ``ll tot = (power(countOdd(n), odd, M) ` `                  ``* nCrModPFermat(n, odd, M)) ` `                 ``% M; ` `        ``tot = (tot * power(counteEven(n), i, M)) % M; ` ` `  `        ``// Add this number to the final answer ` `        ``count += tot; ` `        ``count %= M; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``ll n = 5; ` ` `  `    ``cout << CountEvenSumSequences(n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach  ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` `    ``static` `final` `int` `M = ``1000000007``; ` ` `  `    ``// Iterative function to calculate  ` `    ``// (x^y)%p in O(log y)  ` `    ``static` `long` `power(``long` `x, ``int` `y, ``int` `p)  ` `    ``{  ` `     `  `        ``// Initialize result  ` `        ``long` `res = ``1``;  ` `     `  `        ``// Update x if it is greater  ` `        ``// than or equal to p  ` `        ``x = x % p;  ` `     `  `        ``while` `(y > ``0``) ` `        ``{  ` `     `  `            ``// If y is odd then multiply  ` `            ``// x with the result  ` `            ``if` `((y & ``1``) == ``1``)  ` `                ``res = (res * x) % p;  ` `     `  `            ``// y must be even now  ` `            ``y = y >> ``1``; ``// y = y/2  ` `            ``x = (x * x) % p;  ` `        ``}  ` `        ``return` `res;  ` `    ``}  ` `     `  `    ``// Function to return n^(-1) mod p  ` `    ``static` `long` `modInverse(``long` `n, ``int` `p)  ` `    ``{  ` `        ``return` `power(n, p - ``2``, p);  ` `    ``}  ` `     `  `    ``// Function to return (nCr % p) using  ` `    ``// Fermat's little theorem  ` `    ``static` `long` `nCrModPFermat(``long` `n, ``int` `r, ``int` `p)  ` `    ``{  ` `        ``// Base case  ` `        ``if` `(r == ``0``)  ` `            ``return` `1``;  ` `     `  `        ``// Fill factorial array so that we  ` `        ``// can find all factorial of r, n  ` `        ``// and n-r  ` `        ``long` `fac[] = ``new` `long``[(``int``)n + ``1``];  ` `        ``fac[``0``] = ``1``;  ` `        ``int` `i ; ` `        ``for` `( i = ``1``; i <= n; i++)  ` `            ``fac[i] = fac[i - ``1``] * i % p;  ` `     `  `        ``return` `(fac[(``int``)n] * modInverse(fac[r], p) % p *  ` `                              ``modInverse(fac[(``int``)n - r], p) % p) % p;  ` `    ``}  ` `     `  `    ``// Function to return the count of  ` `    ``// odd numbers from 1 to n  ` `    ``static` `long` `countOdd(``long` `n)  ` `    ``{  ` `        ``long` `x = n / ``2``;  ` `        ``if` `(n % ``2` `== ``1``)  ` `            ``x++;  ` `        ``return` `x;  ` `    ``}  ` `     `  `    ``// Function to return the count of  ` `    ``// even numbers from 1 to n  ` `    ``static` `long` `counteEven(``long` `n)  ` `    ``{  ` `        ``long` `x = n / ``2``;  ` `        ``return` `x;  ` `    ``}  ` `     `  `    ``// Function to return the count  ` `    ``// of the required sequences  ` `    ``static` `long` `CountEvenSumSequences(``long` `n)  ` `    ``{  ` `        ``long` `count = ``0``;  ` `     `  `        ``for` `(``int` `i = ``0``; i <= n; i++) ` `        ``{  ` `     `  `            ``// Take i even and n - i odd numbers  ` `            ``int` `even = i, odd = (``int``)n - i;  ` `     `  `            ``// Number of odd numbers must be even  ` `            ``if` `(odd % ``2` `== ``1``)  ` `                ``continue``;  ` `     `  `            ``// Total ways of placing n - i odd  ` `            ``// numbers in the sequence of n numbers  ` `            ``long` `tot = (power(countOdd(n), odd, M) *  ` `                          ``nCrModPFermat(n, odd, M)) % M;  ` `            ``tot = (tot * power(counteEven(n), i, M)) % M;  ` `     `  `            ``// Add this number to the final answer  ` `            ``count += tot;  ` `            ``count %= M;  ` `        ``}  ` `        ``return` `count;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{  ` `     `  `        ``long` `n = ``5``;  ` `     `  `        ``System.out.println(CountEvenSumSequences(n));  ` `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 implementation of the approach  ` `M ``=` `1000000007` ` `  `# Iterative function to calculate  ` `# (x^y)%p in O(log y)  ` `def` `power(x, y, p):  ` ` `  `    ``# Initialize result  ` `    ``res ``=` `1` ` `  `    ``# Update x if it is greater  ` `    ``# than or equal to p  ` `    ``x ``=` `x ``%` `p  ` ` `  `    ``while` `(y > ``0``) :  ` ` `  `        ``# If y is odd then multiply  ` `        ``# x with the result  ` `        ``if` `(y & ``1``) :  ` `            ``res ``=` `(res ``*` `x) ``%` `p  ` ` `  `        ``# y must be even now  ` `        ``y ``=` `y >> ``1` `# y = y/2  ` `        ``x ``=` `(x ``*` `x) ``%` `p  ` `         `  `    ``return` `res  ` ` `  `# Function to return n^(-1) mod p  ` `def` `modInverse(n, p) :  ` ` `  `    ``return` `power(n, p ``-` `2``, p)  ` ` `  `# Function to return (nCr % p) using  ` `# Fermat's little theorem  ` `def` `nCrModPFermat(n, r, p) :  ` `     `  `    ``# Base case  ` `    ``if` `(r ``=``=` `0``) :  ` `        ``return` `1` ` `  `    ``# Fill factorial array so that we  ` `    ``# can find all factorial of r, n  ` `    ``# and n-r  ` `    ``fac ``=` `[``0``] ``*` `(n``+``1``)  ` `    ``fac[``0``] ``=` `1` `    ``for` `i ``in` `range``(``1``, n``+``1``) :  ` `        ``fac[i] ``=` `fac[i ``-` `1``] ``*` `i ``%` `p  ` ` `  `    ``return` `(fac[n] ``*` `modInverse(fac[r], p) ``%` `p ``*`  `                     ``modInverse(fac[n ``-` `r], p) ``%` `p) ``%` `p  ` ` `  `# Function to return the count of  ` `# odd numbers from 1 to n  ` `def` `countOdd(n) :  ` ` `  `    ``x ``=` `n ``/``/` `2` `    ``if` `(n ``%` `2` `=``=` `1``) :  ` `        ``x ``+``=` `1` `    ``return` `x  ` ` `  `# Function to return the count of  ` `# even numbers from 1 to n  ` `def` `counteEven(n) :  ` ` `  `    ``x ``=` `n ``/``/` `2` `    ``return` `x ` ` `  `# Function to return the count  ` `# of the required sequences  ` `def` `CountEvenSumSequences(n) :  ` ` `  `    ``count ``=` `0` ` `  `    ``for` `i ``in` `range``(n ``+` `1``) :  ` ` `  `        ``# Take i even and n - i odd numbers  ` `        ``even ``=` `i ` `        ``odd ``=` `n ``-` `i  ` ` `  `        ``# Number of odd numbers must be even  ` `        ``if` `(odd ``%` `2` `=``=` `1``) :  ` `            ``continue` ` `  `        ``# Total ways of placing n - i odd  ` `        ``# numbers in the sequence of n numbers  ` `        ``tot ``=` `(power(countOdd(n), odd, M) ``*`  `                 ``nCrModPFermat(n, odd, M)) ``%` `M  ` `        ``tot ``=` `(tot ``*` `power(counteEven(n), i, M)) ``%` `M  ` ` `  `        ``# Add this number to the final answer  ` `        ``count ``+``=` `tot  ` `        ``count ``%``=` `M  ` `     `  `    ``return` `count  ` ` `  `# Driver code  ` `n ``=` `5` `print``(CountEvenSumSequences(n))  ` ` `  `# This code is contributed by ` `# divyamohan123 `

## C#

 `// C# implementation of the above approach  ` `using` `System;          ` ` `  `class` `GFG  ` `{ ` `    ``static` `readonly` `int` `M = 1000000007; ` ` `  `    ``// Iterative function to calculate  ` `    ``// (x^y)%p in O(log y)  ` `    ``static` `long` `power(``long` `x, ``int` `y, ``int` `p)  ` `    ``{  ` `     `  `        ``// Initialize result  ` `        ``long` `res = 1;  ` `     `  `        ``// Update x if it is greater  ` `        ``// than or equal to p  ` `        ``x = x % p;  ` `     `  `        ``while` `(y > 0) ` `        ``{  ` `     `  `            ``// If y is odd then multiply  ` `            ``// x with the result  ` `            ``if` `((y & 1) == 1)  ` `                ``res = (res * x) % p;  ` `     `  `            ``// y must be even now  ` `            ``y = y >> 1; ``// y = y/2  ` `            ``x = (x * x) % p;  ` `        ``}  ` `        ``return` `res;  ` `    ``}  ` `     `  `    ``// Function to return n^(-1) mod p  ` `    ``static` `long` `modInverse(``long` `n, ``int` `p)  ` `    ``{  ` `        ``return` `power(n, p - 2, p);  ` `    ``}  ` `     `  `    ``// Function to return (nCr % p) using  ` `    ``// Fermat's little theorem  ` `    ``static` `long` `nCrModPFermat(``long` `n, ``int` `r, ``int` `p)  ` `    ``{  ` `        ``// Base case  ` `        ``if` `(r == 0)  ` `            ``return` `1;  ` `     `  `        ``// Fill factorial array so that we  ` `        ``// can find all factorial of r, n  ` `        ``// and n-r  ` `        ``long` `[]fac = ``new` `long``[(``int``)n + 1];  ` `        ``fac = 1;  ` `        ``int` `i; ` `        ``for` `(i = 1; i <= n; i++)  ` `            ``fac[i] = fac[i - 1] * i % p;  ` `     `  `        ``return` `(fac[(``int``)n] * modInverse(fac[r], p) % p *  ` `                              ``modInverse(fac[(``int``)n - r], p) % p) % p;  ` `    ``}  ` `     `  `    ``// Function to return the count of  ` `    ``// odd numbers from 1 to n  ` `    ``static` `long` `countOdd(``long` `n)  ` `    ``{  ` `        ``long` `x = n / 2;  ` `        ``if` `(n % 2 == 1)  ` `            ``x++;  ` `        ``return` `x;  ` `    ``}  ` `     `  `    ``// Function to return the count of  ` `    ``// even numbers from 1 to n  ` `    ``static` `long` `counteEven(``long` `n)  ` `    ``{  ` `        ``long` `x = n / 2;  ` `        ``return` `x;  ` `    ``}  ` `     `  `    ``// Function to return the count  ` `    ``// of the required sequences  ` `    ``static` `long` `CountEvenSumSequences(``long` `n)  ` `    ``{  ` `        ``long` `count = 0;  ` `     `  `        ``for` `(``int` `i = 0; i <= n; i++) ` `        ``{  ` `     `  `            ``// Take i even and n - i odd numbers  ` `            ``int` `even = i, odd = (``int``)n - i;  ` `     `  `            ``// Number of odd numbers must be even  ` `            ``if` `(odd % 2 == 1)  ` `                ``continue``;  ` `     `  `            ``// Total ways of placing n - i odd  ` `            ``// numbers in the sequence of n numbers  ` `            ``long` `tot = (power(countOdd(n), odd, M) *  ` `                        ``nCrModPFermat(n, odd, M)) % M;  ` `            ``tot = (tot * power(counteEven(n), i, M)) % M;  ` `     `  `            ``// Add this number to the final answer  ` `            ``count += tot;  ` `            ``count %= M;  ` `        ``}  ` `        ``return` `count;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main (String[] args)  ` `    ``{  ` `        ``long` `n = 5;  ` `     `  `        ``Console.WriteLine(CountEvenSumSequences(n));  ` `    ``}  ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```1562
```

Time Complexity: O(N*logN)

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.