Count of sub-strings that are divisible by K

Last Updated : 03 Apr, 2023

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: 3
Sub-strings that are divisible by 11 are “33”, “44” and “3344”

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

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

Time Complexity: O(n²), where n is the length of the given string.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Efficient Approach :

The idea is to 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 the above idea.

C++

// C++ program to count number of substrings
// divisible by k.
#include <bits/stdc++.h>
using namespace std;
 
int divisible(string s, int k)
{
   
  // To count substrings
  int num_of_substrings = 0;
 
  // To store the remainders
  int rem[k];
  memset(rem, 0, sizeof(rem));
  rem[0] = 1;
  string curr = "";
 
  // Iterate from len(s) - 1 to 0
  for (int i = s.length() - 1; i >= 0; i--) {
 
    // To calculate suffix string
    curr = s[i] + curr;
 
    // Convert to number
    int num = stoi(curr);
    num_of_substrings += rem[num % k];
 
    // Keep track of visited remainders
    rem[num % k]++;
  }
 
  // Return number of substrings
  return num_of_substrings;
}
 
// Driver code
int main()
{
  string s = "111111";
  int k = 11;
  cout << "Number of sub strings : " << divisible(s, k)
    << endl;
  return 0;
}

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

Python3

# Python program for the above approach
def divisible(s, k):
    # To count substrings
    num_of_substrings = 0
 
    # To store the remainders
    rem = [0] * k
    rem[0] = 1
    curr = ""
 
    # Iterate from len(s) - 1 to 0
    for i in range(len(s) - 1, -1, -1):
        # to Calculate suffix string
        curr = s[i] + curr
 
        # convert to number
        num = int(curr)
        num_of_substrings += rem[num % k]
 
        # Keep track of visited remainders
        rem[num % k] += 1
 
    # Return number of substrings
    return num_of_substrings
 
# Driver Code
s = "111111"
k = 11
 
# Function Call
print("Number of sub strings : ", divisible(s, k))
 
# This code is contributed by Prince Kumar

C#

// C# Program for above approach
 
using System;
using System.Text;
 
public class GFG 
{
   
  // 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;
    StringBuilder curr = new StringBuilder();
     
    // Iterate from s.length() - 1 to 0
    for (int i = s.Length - 1; i >= 0; i--) 
    {
       
      // to Calculate suffix string
      curr.Insert(0, s[i]);
       
      // convert to number
      long num = Convert.ToInt64(Convert.ToString(curr));
      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
    Console.WriteLine("Number of sub strings : "
                       + Divisible(s, k));
  }
}
 
 
// This code is contributed by phasing17

Javascript

// JavaScript implementation of the approach
function divisible(s, k) {
  // To count substrings
  let num_of_substrings = 0;
 
  // To store the remainders
  let rem = new Array(k).fill(0);
  rem[0] = 1;
  let curr = "";
 
  // Iterate from len(s) - 1 to 0
  for (let i = s.length - 1; i >= 0; i--) {
    // to Calculate suffix string
    curr = s[i] + curr;
 
    // convert to number
    let num = parseInt(curr);
    num_of_substrings += rem[num % k];
 
    // Keep track of visited remainders
    rem[num % k] += 1;
  }
 
  // Return number of substrings
  return num_of_substrings;
}
 
// Driver Code
let s = "111111";
let k = 11;
 
// Function Call
console.log("Number of sub strings : ", divisible(s, k));
 
 
// This code is contributed by codebraxnzt

Output

Number of sub strings : 9

Time Complexity: O(n²)
Auxiliary Space: O(k)

Largest right circular cone that can be inscribed within a sphere which is inscribed within a cube

Mukund Agarwal

Improve

Article Tags :

Practice Tags :

Strings

Count of sub-strings that are divisible by K

C++

Java

Python3

C#

PHP

Javascript

C++

Java

Python3

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?