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++ 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 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 |
# 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# 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 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 ?> |
<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> |
3
Time Complexity: O(n2), 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++ 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 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));
}
} |
# 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# 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 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 |
Number of sub strings : 9
Time Complexity: O(n2)
Auxiliary Space: O(k)