Skip to content
Related Articles

Related Articles

Improve Article

Count of sub-strings that are divisible by K

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

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 <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;
}

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




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

Javascript




<script>
 
// Javascript implementation of above approach
 
// Function to return the count of sub-strings
// of str that are divisible by k
function countSubStr(str, len, k)
{
    let count = 0;
   
    for(let i = 0; i < len; i++)
    {
        let n = 0;
   
        // Take all sub-strings starting from i
        for(let j = i; j < len; j++)
        {
            n = n * 10 + (str[j].charCodeAt() -
                             '0'.charCodeAt());
   
            // If current sub-string is
            // divisible by k
            if (n % k == 0)
                count++;
        }
    }
   
    // Return the required count
    return count;
}
 
// Driver code
let str = "33445";
let len = str.length;
let k = 11;
 
document.write(countSubStr(str, len, k));
 
// This code is contributed by mukesh07
 
</script>
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
Recommended Articles
Page :