# Given a number as a string, find the number of contiguous subsequences which recursively add up to 9

Given a number as a string, write a function to find the number of substrings (or contiguous subsequences) of the given string which recursively add up to 9.

**Example:**

Digits of 729 recursively add to 9, 7 + 2 + 9 = 18 Recur for 18 1 + 8 = 9

**Examples:**

Input: 4189 Output: 3 There are three substrings which recursively add to 9. The substrings are 18, 9 and 189. Input: 999 Output: 6 There are 6 substrings which recursively add to 9. 9, 99, 999, 9, 99, 9

All digits of a number recursively add up to 9, if only if the number is multiple of 9. We basically need to check for s%9 for all substrings s. One trick used in below program is to do modular arithmetic to avoid overflow for big strings.

Following is a simple implementation based on this approach. The implementation assumes that there are no leading 0’s in input number.

## C++

`// C++ program to count substrings with recursive sum equal to 9` `#include <iostream>` `#include <cstring>` `using` `namespace` `std;` `int` `count9s(string number)` `{` ` ` `int` `count = 0; ` `// To store result` ` ` `int` `n = number.size();` ` ` `// Consider every character as beginning of substring` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `int` `sum = number[i] - ` `'0'` `; ` `//sum of digits in current substring` ` ` `if` `(number[i] == ` `'9'` `) count++;` ` ` `// One by one choose every character as an ending character` ` ` `for` `(` `int` `j = i+1; j < n; j++)` ` ` `{` ` ` `// Add current digit to sum, if sum becomes multiple of 5` ` ` `// then increment count. Let us do modular arithmetic to` ` ` `// avoid overflow for big strings` ` ` `sum = (sum + number[j] - ` `'0'` `)%9;` ` ` `if` `(sum == 0)` ` ` `count++;` ` ` `}` ` ` `}` ` ` `return` `count;` `}` `// driver program to test above function` `int` `main()` `{` ` ` `cout << count9s(` `"4189"` `) << endl;` ` ` `cout << count9s(` `"1809"` `);` ` ` `return` `0;` `}` |

## Java

`// Java program to count` `// substrings with` `// recursive sum equal to 9` `import` `java.io.*;` `class` `GFG` `{` `static` `int` `count9s(String number)` `{` ` ` `// To store result` ` ` `int` `count = ` `0` `;` ` ` `int` `n = number.length();` ` ` `// Consider every character` ` ` `// as beginning of substring` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `// sum of digits in` ` ` `// current substring` ` ` `int` `sum = number.charAt(i) - ` `'0'` `;` ` ` `if` `(number.charAt(i) == ` `'9'` `)` ` ` `count++;` ` ` `// One by one choose` ` ` `// every character as` ` ` `// an ending character` ` ` `for` `(` `int` `j = i + ` `1` `;` ` ` `j < n; j++)` ` ` `{` ` ` `// Add current digit to` ` ` `// sum, if sum becomes` ` ` `// multiple of 5 then` ` ` `// increment count. Let` ` ` `// us do modular arithmetic` ` ` `// to avoid overflow for` ` ` `// big strings` ` ` `sum = (sum +` ` ` `number.charAt(j) -` ` ` `'0'` `) % ` `9` `;` ` ` `if` `(sum == ` `0` `)` ` ` `count++;` ` ` `}` ` ` `}` ` ` `return` `count;` `}` `// Driver Code` `public` `static` `void` `main (String[] args)` `{` ` ` `System.out.println(count9s(` `"4189"` `));` ` ` `System.out.println(count9s(` `"1809"` `));` `}` `}` `// This code is contributed` `// by anuj_67.` |

## Python 3

`# Python 3 program to count substrings` `# with recursive sum equal to 9` `def` `count9s(number):` ` ` `count ` `=` `0` `# To store result` ` ` `n ` `=` `len` `(number)` ` ` `# Consider every character as` ` ` `# beginning of substring` ` ` `for` `i ` `in` `range` `(n):` ` ` ` ` `# sum of digits in current substring` ` ` `sum` `=` `ord` `(number[i]) ` `-` `ord` `(` `'0'` `) ` ` ` `if` `(number[i] ` `=` `=` `'9'` `):` ` ` `count ` `+` `=` `1` ` ` `# One by one choose every character` ` ` `# as an ending character` ` ` `for` `j ` `in` `range` `(i ` `+` `1` `, n):` ` ` ` ` `# Add current digit to sum, if` ` ` `# sum becomes multiple of 5 then` ` ` `# increment count. Let us do` ` ` `# modular arithmetic to avoid` ` ` `# overflow for big strings` ` ` `sum` `=` `(` `sum` `+` `ord` `(number[j]) ` `-` ` ` `ord` `(` `'0'` `)) ` `%` `9` ` ` `if` `(` `sum` `=` `=` `0` `):` ` ` `count ` `+` `=` `1` ` ` `return` `count` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` ` ` `print` `(count9s(` `"4189"` `))` ` ` `print` `(count9s(` `"1809"` `))` `# This code is contributed by ita_c` |

## C#

`// C# program to count` `// substrings with` `// recursive sum equal to 9` `using` `System;` `class` `GFG` `{` `static` `int` `count9s(String number)` `{` ` ` `// To store result` ` ` `int` `count = 0;` ` ` `int` `n = number.Length;` ` ` `// Consider every character` ` ` `// as beginning of substring` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `// sum of digits in` ` ` `// current substring` ` ` `int` `sum = number[i] - ` `'0'` `;` ` ` `if` `(number[i] == ` `'9'` `)` ` ` `count++;` ` ` `// One by one choose` ` ` `// every character as` ` ` `// an ending character` ` ` `for` `(` `int` `j = i + 1;` ` ` `j < n; j++)` ` ` `{` ` ` `// Add current digit to` ` ` `// sum, if sum becomes` ` ` `// multiple of 5 then` ` ` `// increment count. Let` ` ` `// us do modular arithmetic` ` ` `// to avoid overflow for` ` ` `// big strings` ` ` `sum = (sum + number[j] -` ` ` `'0'` `) % 9;` ` ` `if` `(sum == 0)` ` ` `count++;` ` ` `}` ` ` `}` ` ` `return` `count;` `}` `// Driver Code` `public` `static` `void` `Main ()` `{` ` ` `Console.WriteLine(count9s(` `"4189"` `));` ` ` `Console.WriteLine(count9s(` `"1809"` `));` `}` `}` `// This code is contributed` `// by anuj_67.` |

## PHP

`<?php` `// PHP program to count substrings` `// with recursive sum equal to 9` `function` `count9s(` `$number` `)` `{` ` ` `// To store result` ` ` `$count` `= 0;` ` ` `$n` `= ` `strlen` `(` `$number` `);` ` ` `// Consider every character as` ` ` `// beginning of substring` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `$n` `; ` `$i` `++)` ` ` `{` ` ` `//sum of digits in` ` ` `// current substring` ` ` `$sum` `= ` `$number` `[` `$i` `] - ` `'0'` `;` ` ` `if` `(` `$number` `[` `$i` `] == ` `'9'` `) ` `$count` `++;` ` ` `// One by one choose every character` ` ` `// as an ending character` ` ` `for` `(` `$j` `= ` `$i` `+ 1; ` `$j` `< ` `$n` `; ` `$j` `++)` ` ` `{` ` ` ` ` `// Add current digit to sum,` ` ` `// if sum becomes multiple of 5` ` ` `// then increment count. Let us` ` ` `// do modular arithmetic to` ` ` `// avoid overflow for big strings` ` ` `$sum` `= (` `$sum` `+ ` `$number` `[` `$j` `] - ` `'0'` `) % 9;` ` ` `if` `(` `$sum` `== 0)` ` ` `$count` `++;` ` ` `}` ` ` `}` ` ` `return` `$count` `;` `}` ` ` `// Driver Code` ` ` `echo` `count9s(` `"4189"` `),` `"\n"` `;` ` ` `echo` `count9s(` `"1809"` `);` ` ` `// This code is contributed by ajit` `?>` |

## Javascript

`<script>` `// JavaScript program to count substrings` `// with recursive sum equal to 9` ` ` `function` `count9s(number){` ` ` `// To store result` ` ` `let count = 0;` ` ` `let n = (number.length);` ` ` `// Consider every character as beginning of substring` ` ` `for` `(let i = 0; i < n; i++)` ` ` `{` ` ` `//sum of digits in current substring` ` ` `let sum = number[i] - ` `'0'` `; ` ` ` `if` `(number[i] == ` `'9'` `){ count++;}` ` ` `// One by one choose every character` ` ` `// as an ending character` ` ` `for` `(let j = i+1; j < n; j++)` ` ` `{` ` ` `// Add current digit to sum,` ` ` `// if sum becomes multiple of 5` ` ` `// then increment count.` ` ` `// Let us do modular arithmetic to` ` ` `// avoid overflow for big strings` ` ` `sum = (sum + number[j] - ` `'0'` `)%9;` ` ` `if` `(sum == 0){` ` ` `count++;` ` ` `}` ` ` `}` ` ` `}` ` ` `return` `count;` ` ` `}` ` ` `// driver program to test above function` ` ` ` ` `document.write( count9s(` `"4189"` `) );` ` ` `document.write(` `"</br>"` `);` ` ` `document.write( count9s(` `"1809"` `));` ` ` `</script>` |

**Output**

3 5

Time complexity of the above program is O(n^{2}). Please let me know if there is a better solution.

Given a number as a string, find the number of contiguous subsequences which recursively add up to 9 | Set 2