Count of sub-strings that are divisible by K

• Difficulty Level : Easy
• Last Updated : 15 Nov, 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 kint 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 codeint main(){    string str = "33445";    int len = str.length();    int k = 11;    cout << countSubStr(str, len, k);     return 0;}

Java

 // Java implementation of above approachclass 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 kdef 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 codeif __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 approachusing 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



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 approachimport 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 = 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));             // convert 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

My Personal Notes arrow_drop_up