Related Articles

# Count of sub-strings that are divisible by K

• Difficulty Level : Easy
• Last Updated : 07 Sep, 2021

Given an integer K and a numeric string str (all the characters are from the range [‘0’, ‘9’]). The task is to count the number of sub-strings of str that are divisible by K.

Examples:

Input: str = “33445”, K = 11
Output:
Sub-strings that are divisible by 11 are “33”, “44” and “3344”

Input: str = “334455”, K = 11
Output:

Approach: Initialize count = 0. Take all the sub-strings of str and check whether they are divisible by K or not. If yes then update count = count + 1. Print the count in the end.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the count of sub-strings``// of str that are divisible by k``int` `countSubStr(string str, ``int` `len, ``int` `k)``{``    ``int` `count = 0;` `    ``for` `(``int` `i = 0; i < len; i++)``    ``{``        ``int` `n = 0;` `        ``// Take all sub-strings starting from i``        ``for` `(``int` `j = i; j < len; j++)``        ``{``            ``n = n * 10 + (str[j] - ``'0'``);` `            ``// If current sub-string is divisible by k``            ``if` `(n % k == 0)``                ``count++;``        ``}``    ``}` `    ``// Return the required count``    ``return` `count;``}` `// Driver code``int` `main()``{``    ``string str = ``"33445"``;``    ``int` `len = str.length();``    ``int` `k = 11;``    ``cout << countSubStr(str, len, k);` `    ``return` `0;``}`

## Java

 `// Java implementation of above approach``class` `GFG``{` `    ``// Function to return the count of sub-strings``    ``// of str that are divisible by k``    ``static` `int` `countSubStr(String str, ``int` `len, ``int` `k)``    ``{``        ``int` `count = ``0``;``    ` `        ``for` `(``int` `i = ``0``; i < len; i++)``        ``{``            ``int` `n = ``0``;``    ` `            ``// Take all sub-strings starting from i``            ``for` `(``int` `j = i; j < len; j++)``            ``{``                ``n = n * ``10` `+ (str.charAt(j) - ``'0'``);``    ` `                ``// If current sub-string is divisible by k``                ``if` `(n % k == ``0``)``                    ``count++;``            ``}``        ``}``    ` `        ``// Return the required count``        ``return` `count;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String []args)``    ``{``        ``String str = ``"33445"``;``        ``int` `len = str.length();``        ``int` `k = ``11``;``        ``System.out.println(countSubStr(str, len, k));``    ``}``}` `// This code is contributed by Ryuga`

## Python3

 `# Python 3 implementation of the approach` `# Function to return the count of sub-strings``# of str that are divisible by k``def` `countSubStr(``str``, l, k):``    ``count ``=` `0` `    ``for` `i ``in` `range``(l):``        ``n ``=` `0` `        ``# Take all sub-strings starting from i``        ``for` `j ``in` `range``(i, l, ``1``):``            ``n ``=` `n ``*` `10` `+` `(``ord``(``str``[j]) ``-` `ord``(``'0'``))` `            ``# If current sub-string is divisible by k``            ``if` `(n ``%` `k ``=``=` `0``):``                ``count ``+``=` `1``    ` `    ``# Return the required count``    ``return` `count` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``str` `=` `"33445"``    ``l ``=` `len``(``str``)``    ``k ``=` `11``    ``print``(countSubStr(``str``, l, k))` `# This code is contributed by``# Sanjit_Prasad`

## C#

 `// C# implementation of above approach``using` `System;` `class` `GFG``{` `    ``// Function to return the count of sub-strings``    ``// of str that are divisible by k``    ``static` `int` `countSubStr(String str, ``int` `len, ``int` `k)``    ``{``        ``int` `count = 0;``    ` `        ``for` `(``int` `i = 0; i < len; i++)``        ``{``            ``int` `n = 0;``    ` `            ``// Take all sub-strings starting from i``            ``for` `(``int` `j = i; j < len; j++)``            ``{``                ``n = n * 10 + (str[j] - ``'0'``);``    ` `                ``// If current sub-string is divisible by k``                ``if` `(n % k == 0)``                    ``count++;``            ``}``        ``}``    ` `        ``// Return the required count``        ``return` `count;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``String str = ``"33445"``;``        ``int` `len = str.Length;``        ``int` `k = 11;``        ``Console.WriteLine(countSubStr(str, len, k));``    ``}``}` `// This code is contributed by Code_Mech`

## PHP

 ``

## Javascript

 ``
Output
`3`

Efficient approach :

The idea is use a hashMap to store the remainders of each suffix of the string so that any suffix if it is already present int the hashmap then the substring between them is divisible by k.

Below is the implementation of above approach.

## Java

 `// Java Program for above approach``import` `java.util.*;``public` `class` `Main``{``  ` `  ``// Program to count number of substrings``  ``public` `static` `int` `Divisible(String s,``                                    ``int` `k)``  ``{` `    ``// To count substrings``    ``int` `num_of_substrings = ``0``;``    ` `    ``// To store the remainders``    ``int` `rem[] = ``new` `int``[k];``    ` `    ``rem[``0``] = ``1``;``    ``StringBuffer curr = ``new` `StringBuffer();``    ` `    ``// Iterate from s.length() - 1 to 0``    ``for` `(``int` `i = s.length() - ``1``; i >= ``0``; i--)``    ``{``      ` `      ``// to Calculate suffix string``      ``curr.insert(``0``, s.charAt(i));``      ` `      ``// cnvert to number``      ``long` `num = Long.parseLong(curr.``                                ``toString());``      ``num_of_substrings += rem[(``int``)num % k];``      ` `      ``// Keep track of visited remainders``      ``rem[(``int``)num % k]++;``    ``}``    ` `    ``// Return number of substrings``    ``return` `num_of_substrings;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String args[])``  ``{``    ``String s = ``"111111"``;``    ``int` `k = ``11``;``    ` `    ``// Function Call``    ``System.out.println(``"Number of sub strings : "``                       ``+ Divisible(s, k));``  ``}``}`
Output
`Number of sub strings : 9`

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up