Count of sub-strings that are divisible by K

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach
  
// Function to return the count of sub-strings
// of str that are divisible by k
function countSubStr($str, $len, $k)
{
    $count = 0;
  
    for ($i = 0; $i < $len; $i++) 
    {
        $n = 0;
  
        // Take all sub-strings starting from i
        for ($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
$str = "33445";
$len = strlen($str);
$k = 11;
echo countSubStr($str, $len, $k);
  
// This code is contributed 
// by Shivi_Aggarwal
?>

chevron_right


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

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program for above approach
import java.util.*;
public class Main 
{
    
  // Program to count number of subtrings
  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 subtrings
    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));
  }
}

chevron_right


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.




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.