# Ways to form an array having integers in given range such that total sum is divisible by 2

Given three positive integers N, L and R. The task is to find the number of ways to form an array of size N where each element lies in the range [L, R] such that the total sum of all the elements of the array is divisible by 2.

Examples:

Input: N = 2, L = 1, R = 3
Output: 5
Possible arrays having sum of all elements divisible by 2 are
[1, 1], [2, 2], [1, 3], [3, 1] and [3, 3]

Input: N = 3, L = 2, R = 2
Output: 1

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

Approach: The idea is to find the count of numbers having remainder 0 and 1 modulo 2 separately lying between L and R. This count can be calculated as follows:

We need to count numbers between range having remainder 1 modulo 2
F = First number in range of required type
L = Last number in range of required type
Count = (L – F) / 2
cnt0, and cnt1 represents Count of numbers between range of each type.

Then, using dynamic programming we can solve this problem. Let dp[i][j] denotes the number of ways where the sum of first i numbers modulo 2 is equal to j. Suppose we need to calculate dp[i][0], then it will have the following recurrence relation: dp[i][0] = (cnt0 * dp[i – 1][0] + cnt1 * dp[i – 1][1]). First term represents the number of ways upto (i – 1) having sum remainder as 0, so we can place cnt0 numbers in ith position such that sum remainder still remains 0. Second term represents the number of ways upto (i – 1) having sum remainder as 1, so we can place cnt1 numbers in ith position to such that sum remainder becomes 0. Similarly, we can calculate for dp[i][1].
Final answer will be denoted by dp[N][0].

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the number of ways to ` `// form an array of size n such that sum of ` `// all elements is divisible by 2 ` `int` `countWays(``int` `n, ``int` `l, ``int` `r) ` `{ ` `    ``int` `tL = l, tR = r; ` ` `  `    ``// Represents first and last numbers ` `    ``// of each type (modulo 0 and 1) ` `    ``int` `L[2] = { 0 }, R[2] = { 0 }; ` `    ``L[l % 2] = l, R[r % 2] = r; ` ` `  `    ``l++, r--; ` ` `  `    ``if` `(l <= tR && r >= tL) ` `        ``L[l % 2] = l, R[r % 2] = r; ` ` `  `    ``// Count of numbers of each type between range ` `    ``int` `cnt0 = 0, cnt1 = 0; ` `    ``if` `(R[0] && L[0]) ` `        ``cnt0 = (R[0] - L[0]) / 2 + 1; ` `    ``if` `(R[1] && L[1]) ` `        ``cnt1 = (R[1] - L[1]) / 2 + 1; ` ` `  `    ``int` `dp[n][2]; ` ` `  `    ``// Base Cases ` `    ``dp[1][0] = cnt0; ` `    ``dp[1][1] = cnt1; ` `    ``for` `(``int` `i = 2; i <= n; i++) { ` ` `  `        ``// Ways to form array whose sum upto ` `        ``// i numbers modulo 2 is 0 ` `        ``dp[i][0] = (cnt0 * dp[i - 1][0] ` `                    ``+ cnt1 * dp[i - 1][1]); ` ` `  `        ``// Ways to form array whose sum upto ` `        ``// i numbers modulo 2 is 1 ` `        ``dp[i][1] = (cnt0 * dp[i - 1][1] ` `                    ``+ cnt1 * dp[i - 1][0]); ` `    ``} ` ` `  `    ``// Return the required count of ways ` `    ``return` `dp[n][0]; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `n = 2, l = 1, r = 3; ` `    ``cout << countWays(n, l, r); ` ` `  `    ``return` `0; ` `} `

## Python3

# Python3 implementation of the approach

# Function to return the number of ways to
# form an array of size n such that sum of
# all elements is divisible by 2
def countWays(n, l, r):

tL, tR = l, r

# Represents first and last numbers
# of each type (modulo 0 and 1)
L = [0 for i in range(2)]
R = [0 for i in range(2)]

L[l % 2] = l
R[r % 2] = r

l += 1
r -= 1

if (l <= tR and r >= tL):
L[l % 2], R[r % 2] = l, r

# Count of numbers of each type
# between range
cnt0, cnt1 = 0, 0
if (R[0] and L[0]):
cnt0 = (R[0] – L[0]) // 2 + 1
if (R[1] and L[1]):
cnt1 = (R[1] – L[1]) // 2 + 1

dp = [[0 for i in range(2)]
for i in range(n + 1)]

# Base Cases
dp[1][0] = cnt0
dp[1][1] = cnt1
for i in range(2, n + 1):

# Ways to form array whose sum
# upto i numbers modulo 2 is 0
dp[i][0] = (cnt0 * dp[i – 1][0] +
cnt1 * dp[i – 1][1])

# Ways to form array whose sum upto
# i numbers modulo 2 is 1
dp[i][1] = (cnt0 * dp[i – 1][1] +
cnt1 * dp[i – 1][0])

# Return the required count of ways
return dp[n][0]

# Driver Code
n, l, r = 2, 1, 3
print(countWays(n, l, r))

# This code is contributed
# by Mohit Kumar

Output:

```5
```

My Personal Notes arrow_drop_up