# Count of sub-sets of size n with total element sum divisible by 3

Given an integer n and a range [l, r], the task is to find the count of total sub-sets of size n with integers from the given range such that the total sum of its elements is divisible by 3.

Examples:

Input: n = 2, l = 1, r = 5
Output: 9
Possible sub-sets are {1, 2}, {2, 1}, {3, 3}, {5, 1}, {1, 5}, {4, 2}, {2, 4}, {5, 4} and {4, 5}

Input: n = 3, l = 9, r = 9
Output: 1
{9, 9, 9} is the only possible sub-set

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

Approach: Since we need the sum of the sub-set elements to be divisible by 3. So, instead of caring about the numbers, we will count the numbers such that they give remainder 0, 1 and 2 on dividing with 3 separately by the formula given below:

For example, an element k such that k % 3 = 2 can be found as k = 3 * x + 2 for some integer x.
Then we have l ≤ (3 * x) + 2 ≤ r
l – 2 ≤ (3 * x) ≤ r – 2
ceil((l – 2) / 3) ≤ x ≤ floor((r – 2) / 3)

Now, by dynamic programming dp[i][j] we can check how many elements will give a sum that is divisible by 3. Here dp[i][j] represents the sum of first i elements that give remainder j on dividing by 3.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `#define MOD 1000000007 ` `#define ll long long int ` `using` `namespace` `std; ` ` `  `// Function to return the total number of  ` `// required sub-sets ` `int` `totalSubSets(ll n, ll l, ll r) ` `{ ` ` `  `    ``// Variable to store total elements  ` `    ``// which on dividing by 3  give  ` `    ``// remainder 0, 1 and 2 respectively ` `    ``ll zero = ``floor``((``double``)r / 3) ` `              ``- ``ceil``((``double``)l / 3) + 1; ` `    ``ll one = ``floor``((``double``)(r - 1) / 3) ` `             ``- ``ceil``((``double``)(l - 1) / 3) + 1; ` `    ``ll two = ``floor``((``double``)(r - 2) / 3) ` `             ``- ``ceil``((``double``)(l - 2) / 3) + 1; ` ` `  `    ``// Create a dp table ` `    ``ll dp[n]; ` `    ``memset``(dp, 0, ``sizeof``(dp)); ` `    ``dp = zero; ` `    ``dp = one; ` `    ``dp = two; ` ` `  `    ``// Process for n states and store ` `    ``// the sum (mod 3) for 0, 1 and 2 ` `    ``for` `(ll i = 1; i < n; ++i) { ` ` `  `        ``// Use of MOD for large numbers ` `        ``dp[i] = ((dp[i - 1] * zero) ` `                    ``+ (dp[i - 1] * two) ` `                    ``+ (dp[i - 1] * one)) ` `                   ``% MOD; ` `        ``dp[i] = ((dp[i - 1] * one) ` `                    ``+ (dp[i - 1] * zero) ` `                    ``+ (dp[i - 1] * two)) ` `                   ``% MOD; ` `        ``dp[i] = ((dp[i - 1] * two) ` `                    ``+ (dp[i - 1] * one) ` `                    ``+ (dp[i - 1] * zero)) ` `                   ``% MOD; ` `    ``} ` ` `  `    ``// Final answer store at dp[n - 1] ` `    ``return` `dp[n - 1]; ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` `    ``ll n = 5; ` `    ``ll l = 10; ` `    ``ll r = 100; ` `    ``cout << totalSubSets(n, l, r); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` ` `  `class` `GFG ` `{ ` `         `  `    ``static` `int` `MOD = ``1000000007``; ` `     `  `    ``// Function to return the total number of  ` `    ``// required sub-sets ` `    ``static` `int` `totalSubSets(``int` `n, ``int` `l, ``int` `r) ` `    ``{ ` `     `  `        ``// Variable to store total elements  ` `        ``// which on dividing by 3 give  ` `        ``// remainder 0, 1 and 2 respectively ` `        ``int` `zero = (``int``)Math.floor((``double``)r / ``3``) ` `                ``- (``int``)Math.ceil((``double``)l / ``3``) + ``1``; ` `        ``int` `one = (``int``)Math.floor((``double``)(r - ``1``) / ``3``) ` `                ``- (``int``)Math.ceil((``double``)(l - ``1``) / ``3``) + ``1``; ` `        ``int` `two = (``int``)Math.floor((``double``)(r - ``2``) / ``3``) ` `                ``- (``int``)Math.ceil((``double``)(l - ``2``) / ``3``) + ``1``; ` `     `  `        ``// Create a dp table ` `        ``int` `[][] dp = ``new` `int``[n][``3``]; ` `     `  `        ``dp[``0``][``0``] = zero; ` `        ``dp[``0``][``1``] = one; ` `        ``dp[``0``][``2``] = two; ` `     `  `        ``// Process for n states and store ` `        ``// the sum (mod 3) for 0, 1 and 2 ` `        ``for` `(``int` `i = ``1``; i < n; ++i) ` `        ``{ ` `     `  `            ``// Use of MOD for large numbers ` `            ``dp[i][``0``] = ((dp[i - ``1``][``0``] * zero) ` `                        ``+ (dp[i - ``1``][``1``] * two) ` `                        ``+ (dp[i - ``1``][``2``] * one)) ` `                    ``% MOD; ` `            ``dp[i][``1``] = ((dp[i - ``1``][``0``] * one) ` `                        ``+ (dp[i - ``1``][``1``] * zero) ` `                        ``+ (dp[i - ``1``][``2``] * two)) ` `                    ``% MOD; ` `            ``dp[i][``2``] = ((dp[i - ``1``][``0``] * two) ` `                        ``+ (dp[i - ``1``][``1``] * one) ` `                        ``+ (dp[i - ``1``][``2``] * zero)) ` `                    ``% MOD; ` `        ``} ` `     `  `        ``// Final answer store at dp[n - 1] ` `        ``return` `dp[n - ``1``][``0``]; ` `    ``} ` `     `  `    ``// Driver Program ` `    ``public` `static` `void` `main(String []args) ` `    ``{ ` `        ``int` `n = ``5``; ` `        ``int` `l = ``10``; ` `        ``int` `r = ``100``; ` `        ``System.out.println(totalSubSets(n, l, r)); ` `    ``} ` `} ` ` `  `// This code is contributed by ihritik `

## Python3

 `# Python3 implementation of the approach  ` `import` `math ` ` `  `# Function to return the total ` `# number of required sub-sets  ` `def` `totalSubSets(n, l, r): ` `     `  `    ``MOD ``=` `1000000007` `; ` `     `  `    ``# Variable to store total elements  ` `    ``# which on dividing by 3 give  ` `    ``# remainder 0, 1 and 2 respectively  ` `    ``zero ``=` `(math.floor(r ``/` `3``) ``-`  `            ``math.ceil(l ``/` `3``) ``+` `1``);  ` `    ``one ``=` `(math.floor((r ``-` `1``) ``/` `3``) ``-`  `           ``math.ceil((l ``-` `1``) ``/` `3``) ``+` `1``);  ` `    ``two ``=` `(math.floor((r ``-` `2``) ``/` `3``) ``-`  `           ``math.ceil((l ``-` `2``) ``/` `3``) ``+` `1``);  ` ` `  `    ``# Create a dp table  ` `    ``dp ``=` `[[``0` `for` `x ``in` `range``(``3``)]  ` `             ``for` `y ``in` `range``(n)]  ` `             `  `    ``dp[``0``][``0``] ``=` `zero;  ` `    ``dp[``0``][``1``] ``=` `one;  ` `    ``dp[``0``][``2``] ``=` `two;  ` ` `  `    ``# Process for n states and store  ` `    ``# the sum (mod 3) for 0, 1 and 2  ` `    ``for` `i ``in` `range``(``1``, n): ` ` `  `        ``# Use of MOD for large numbers  ` `        ``dp[i][``0``] ``=` `((dp[i ``-` `1``][``0``] ``*` `zero) ``+`  `                    ``(dp[i ``-` `1``][``1``] ``*` `two) ``+`  `                    ``(dp[i ``-` `1``][``2``] ``*` `one)) ``%` `MOD;  ` `        ``dp[i][``1``] ``=` `((dp[i ``-` `1``][``0``] ``*` `one) ``+`  `                    ``(dp[i ``-` `1``][``1``] ``*` `zero) ``+`  `                    ``(dp[i ``-` `1``][``2``] ``*` `two)) ``%` `MOD;  ` `        ``dp[i][``2``] ``=` `((dp[i ``-` `1``][``0``] ``*` `two)``+`  `                    ``(dp[i ``-` `1``][``1``] ``*` `one) ``+`  `                    ``(dp[i ``-` `1``][``2``] ``*` `zero)) ``%` `MOD;  ` ` `  `    ``# Final answer store at dp[n - 1]  ` `    ``return` `dp[n ``-` `1``][``0``]; ` ` `  `# Driver Code ` `n ``=` `5``;  ` `l ``=` `10``;  ` `r ``=` `100``;  ` `print``(totalSubSets(n, l, r));  ` `     `  `# This code is contributed ` `# by chandan_jnu `

## C#

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` `         `  `    ``static` `int` `MOD = 1000000007; ` `     `  `    ``// Function to return the total number of  ` `    ``// required sub-sets ` `    ``static` `int` `totalSubSets(``int` `n, ``int` `l, ``int` `r) ` `    ``{ ` `     `  `        ``// Variable to store total elements  ` `        ``// which on dividing by 3 give  ` `        ``// remainder 0, 1 and 2 respectively ` `        ``int` `zero = (``int``)Math.Floor((``double``)r / 3) ` `                ``- (``int``)Math.Ceiling((``double``)l / 3) + 1; ` `        ``int` `one = (``int``)Math.Floor((``double``)(r - 1) / 3) ` `                ``- (``int``)Math.Ceiling((``double``)(l - 1) / 3) + 1; ` `        ``int` `two = (``int``)Math.Floor((``double``)(r - 2) / 3) ` `                ``- (``int``)Math.Ceiling((``double``)(l - 2) / 3) + 1; ` `     `  `        ``// Create a dp table ` `        ``int` `[, ] dp = ``new` `int``[n, 3]; ` `     `  `        ``dp[0,0] = zero; ` `        ``dp[0,1] = one; ` `        ``dp[0,2] = two; ` `     `  `        ``// Process for n states and store ` `        ``// the sum (mod 3) for 0, 1 and 2 ` `        ``for` `(``int` `i = 1; i < n; ++i)  ` `        ``{ ` `     `  `            ``// Use of MOD for large numbers ` `            ``dp[i,0] = ((dp[i - 1, 0] * zero) ` `                        ``+ (dp[i - 1, 1] * two) ` `                        ``+ (dp[i - 1, 2] * one)) ` `                    ``% MOD; ` `            ``dp[i,1] = ((dp[i - 1, 0] * one) ` `                        ``+ (dp[i - 1, 1] * zero) ` `                        ``+ (dp[i - 1, 2] * two)) ` `                    ``% MOD; ` `            ``dp[i,2] = ((dp[i - 1, 0] * two) ` `                        ``+ (dp[i - 1, 1] * one) ` `                        ``+ (dp[i - 1, 2] * zero)) ` `                    ``% MOD; ` `        ``} ` `     `  `        ``// Final answer store at dp[n - 1,0] ` `        ``return` `dp[n - 1, 0]; ` `    ``} ` `     `  `    ``// Driver Program ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 5; ` `        ``int` `l = 10; ` `        ``int` `r = 100; ` `        ``Console.WriteLine(totalSubSets(n, l, r)); ` `    ``} ` `} ` ` `  `// This code is contributed by ihritik `

## PHP

 ` `

Output:

```80107136
```

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.

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.