# Number of substrings divisible by 6 in a string of integers

Given a string consisting of integers 0 to 9. The task is to count the number of substrings which when convert into integer are divisible by 6. Substring does not contain leading zeroes.

**Examples:**

Input : s = "606". Output : 5 Substrings "6", "0", "6", "60", "606" are divisible by 6. Input : s = "4806". Output : 5 "0", "6", "48", "480", "4806" are substring which are divisible by 6.

**Method 1: (Brute Force)** The idea is to find all the substrings of the given string and check if substring is divisible by 6 or not.

**Time Complexity: **O(n^{2}).

**Method 2:(Dynamic Programming)** As discussed in Check if a large number is divisible by 6 or not. A number is divisible by 6 if last digit is divisible by 2 and sum of digits is divisible by 3.

The idea is to use Dynamic Programming, which enables us to compute answer quickly and efficiently by tracking previously computed answers and using these stored answer instead of recomputing values.

Let * f(i, m) be the number of strings starting at index i and sum of their digits modulo 3 (so far) is m and number it represents is even*. So, our answer would be

Let x be the i^{th} digit in the string. From f(i, m) we need to find all the even substrings that start in i + 1.

Also, we will get an extra substring if (x + m) itself is divisible by 3 and x is even. So, we get recurrence relation

// We initially pass m (sum modulo 3 so far) as 0 f(i, m) = ((x + m)%3 == 0 and x%2 == 0) + f(i + 1, (m + x)%3) // Recursive

By memorizing the states, we get O(n) solution.

Below is implementation of this approach:

## C++

`// C++ program to calculate number of substring ` `// divisible by 6. ` `#include <bits/stdc++.h> ` `#define MAX 100002 ` `using` `namespace` `std; ` ` ` `// Return the number of substring divisible by 6 ` `// and starting at index i in s[] and previous sum ` `// of digits modulo 3 is m. ` `int` `f(` `int` `i, ` `int` `m, ` `char` `s[], ` `int` `memoize[][3]) ` `{ ` ` ` `// End of the string. ` ` ` `if` `(i == ` `strlen` `(s)) ` ` ` `return` `0; ` ` ` ` ` `// If already calculated, return the ` ` ` `// stored value. ` ` ` `if` `(memoize[i][m] != -1) ` ` ` `return` `memoize[i][m]; ` ` ` ` ` `// Converting into integer. ` ` ` `int` `x = s[i] - ` `'0'` `; ` ` ` ` ` `// Increment result by 1, if current digit ` ` ` `// is divisible by 2 and sum of digits is ` ` ` `// divisible by 3. ` ` ` `// And recur for next index with new modulo. ` ` ` `int` `ans = ((x+m)%3 == 0 && x%2 == 0) + ` ` ` `f(i+1, (m+x)%3, s, memoize); ` ` ` ` ` `return` `memoize[i][m] = ans; ` `} ` ` ` `// Returns substrings divisible by 6. ` `int` `countDivBy6(` `char` `s[]) ` `{ ` ` ` `int` `n = ` `strlen` `(s); ` ` ` ` ` `// For storing the value of all states. ` ` ` `int` `memoize[n+1][3]; ` ` ` `memset` `(memoize, -1, ` `sizeof` `memoize); ` ` ` ` ` `int` `ans = 0; ` ` ` `for` `(` `int` `i = 0; i < ` `strlen` `(s); i++) ` ` ` `{ ` ` ` `// If string contain 0, increment count by 1. ` ` ` `if` `(s[i] == ` `'0'` `) ` ` ` `ans++; ` ` ` ` ` `// Else calculate using recursive function. ` ` ` `// Pass previous sum modulo 3 as 0. ` ` ` `else` ` ` `ans += f(i, 0, s, memoize); ` ` ` `} ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driven Program ` `int` `main() ` `{ ` ` ` `char` `s[] = ` `"4806"` `; ` ` ` ` ` `cout << countDivBy6(s) << endl; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to calculate number ` `# of substring ` ` ` `# Return the number of substring divisible ` `# by 6 and starting at index i in s[] and ` `# previous sum of digits modulo 3 is m. ` `def` `f(i, m, s, memoize): ` ` ` ` ` `# End of the string. ` ` ` `if` `(i ` `=` `=` `len` `(s)): ` ` ` `return` `0` ` ` ` ` `# If already calculated, return ` ` ` `# the stored value. ` ` ` `if` `(memoize[i][m] !` `=` `-` `1` `): ` ` ` `return` `memoize[i][m] ` ` ` ` ` `# Converting into integer. ` ` ` `x ` `=` `ord` `(s[i]) ` `-` `ord` `(` `'0'` `) ` ` ` ` ` `# Increment result by 1, if current digit ` ` ` `# is divisible by 2 and sum of digits is ` ` ` `# divisible by 3. ` ` ` `# And recur for next index with new modulo. ` ` ` `ans ` `=` `(((x ` `+` `m) ` `%` `3` `=` `=` `0` `and` `x ` `%` `2` `=` `=` `0` `) ` `+` ` ` `f(i ` `+` `1` `, (m ` `+` `x) ` `%` `3` `, s, memoize)) ` ` ` ` ` `memoize[i][m] ` `=` `ans ` ` ` `return` `memoize[i][m] ` ` ` `# Returns substrings divisible by 6. ` `def` `countDivBy6(s): ` ` ` `n ` `=` `len` `(s) ` ` ` ` ` `# For storing the value of all states. ` ` ` `memoize ` `=` `[[` `-` `1` `] ` `*` `3` `for` `i ` `in` `range` `(n ` `+` `1` `)] ` ` ` ` ` `ans ` `=` `0` ` ` `for` `i ` `in` `range` `(` `len` `(s)): ` ` ` ` ` `# If string contain 0, increment ` ` ` `# count by 1. ` ` ` `if` `(s[i] ` `=` `=` `'0'` `): ` ` ` `ans ` `+` `=` `1` ` ` ` ` `# Else calculate using recursive function. ` ` ` `# Pass previous sum modulo 3 as 0. ` ` ` `else` `: ` ` ` `ans ` `+` `=` `f(i, ` `0` `, s, memoize) ` ` ` ` ` `return` `ans ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `'__main__'` `: ` ` ` `s ` `=` `"4806"` ` ` ` ` `print` `(countDivBy6(s)) ` ` ` `# This code is contributed by PranchalK ` |

*chevron_right*

*filter_none*

**Output:**

5

**Time Complexity: **O(n).

This article is contributed by **Anuj Chauhan**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- Number of substrings divisible by 4 in a string of integers
- Number of substrings divisible by 8 but not by 3
- Find number of substrings of length k whose sum of ASCII value of characters is divisible by k
- Number of substrings of a string
- Number of substrings of one string present in other
- Sum of all substrings of a string representing a number | Set 1
- Number of even substrings in a string of digits
- Number of substrings with odd decimal value in a binary string
- Count the number of vowels occurring in all the substrings of given string
- Given a binary string, count number of substrings that start and end with 1.
- Rearrange the string to maximize the number of palindromic substrings
- Sum of all substrings of a string representing a number | Set 2 (Constant Extra Space)
- Number of subsequences in a string divisible by n
- Count of m digit integers that are divisible by an integer n
- Count integers in a range which are divisible by their euler totient value