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: 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++
#include <bits/stdc++.h>
using namespace std;
int countSubStr(string str, int len, int k)
{
int count = 0;
for ( int i = 0; i < len; i++)
{
int n = 0;
for ( int j = i; j < len; j++)
{
n = n * 10 + (str[j] - '0' );
if (n % k == 0)
count++;
}
}
return count;
}
int main()
{
string str = "33445" ;
int len = str.length();
int k = 11;
cout << countSubStr(str, len, k);
return 0;
}
|
Java
class GFG
{
static int countSubStr(String str, int len, int k)
{
int count = 0 ;
for ( int i = 0 ; i < len; i++)
{
int n = 0 ;
for ( int j = i; j < len; j++)
{
n = n * 10 + (str.charAt(j) - '0' );
if (n % k == 0 )
count++;
}
}
return count;
}
public static void main(String []args)
{
String str = "33445" ;
int len = str.length();
int k = 11 ;
System.out.println(countSubStr(str, len, k));
}
}
|
Python3
def countSubStr( str , l, k):
count = 0
for i in range (l):
n = 0
for j in range (i, l, 1 ):
n = n * 10 + ( ord ( str [j]) - ord ( '0' ))
if (n % k = = 0 ):
count + = 1
return count
if __name__ = = '__main__' :
str = "33445"
l = len ( str )
k = 11
print (countSubStr( str , l, k))
|
C#
using System;
class GFG
{
static int countSubStr(String str, int len, int k)
{
int count = 0;
for ( int i = 0; i < len; i++)
{
int n = 0;
for ( int j = i; j < len; j++)
{
n = n * 10 + (str[j] - '0' );
if (n % k == 0)
count++;
}
}
return count;
}
public static void Main()
{
String str = "33445" ;
int len = str.Length;
int k = 11;
Console.WriteLine(countSubStr(str, len, k));
}
}
|
PHP
<?php
function countSubStr( $str , $len , $k )
{
$count = 0;
for ( $i = 0; $i < $len ; $i ++)
{
$n = 0;
for ( $j = $i ; $j < $len ; $j ++)
{
$n = $n * 10 + ( $str [ $j ] - '0' );
if ( $n % $k == 0)
$count ++;
}
}
return $count ;
}
$str = "33445" ;
$len = strlen ( $str );
$k = 11;
echo countSubStr( $str , $len , $k );
?>
|
Javascript
<script>
function countSubStr(str, len, k)
{
let count = 0;
for (let i = 0; i < len; i++)
{
let n = 0;
for (let j = i; j < len; j++)
{
n = n * 10 + (str[j].charCodeAt() -
'0' .charCodeAt());
if (n % k == 0)
count++;
}
}
return count;
}
let str = "33445" ;
let len = str.length;
let k = 11;
document.write(countSubStr(str, len, k));
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
int divisible(string s, int k)
{
int num_of_substrings = 0;
int rem[k];
memset (rem, 0, sizeof (rem));
rem[0] = 1;
string curr = "" ;
for ( int i = s.length() - 1; i >= 0; i--) {
curr = s[i] + curr;
int num = stoi(curr);
num_of_substrings += rem[num % k];
rem[num % k]++;
}
return num_of_substrings;
}
int main()
{
string s = "111111" ;
int k = 11;
cout << "Number of sub strings : " << divisible(s, k)
<< endl;
return 0;
}
|
Java
import java.util.*;
public class Main
{
public static int Divisible(String s,
int k)
{
int num_of_substrings = 0 ;
int rem[] = new int [k];
rem[ 0 ] = 1 ;
StringBuffer curr = new StringBuffer();
for ( int i = s.length() - 1 ; i >= 0 ; i--)
{
curr.insert( 0 , s.charAt(i));
long num = Long.parseLong(curr.
toString());
num_of_substrings += rem[( int )num % k];
rem[( int )num % k]++;
}
return num_of_substrings;
}
public static void main(String args[])
{
String s = "111111" ;
int k = 11 ;
System.out.println( "Number of sub strings : "
+ Divisible(s, k));
}
}
|
Python3
def divisible(s, k):
num_of_substrings = 0
rem = [ 0 ] * k
rem[ 0 ] = 1
curr = ""
for i in range ( len (s) - 1 , - 1 , - 1 ):
curr = s[i] + curr
num = int (curr)
num_of_substrings + = rem[num % k]
rem[num % k] + = 1
return num_of_substrings
s = "111111"
k = 11
print ( "Number of sub strings : " , divisible(s, k))
|
C#
using System;
using System.Text;
public class GFG
{
public static int Divisible( string s,
int k)
{
int num_of_substrings = 0;
int [] rem = new int [k];
rem[0] = 1;
StringBuilder curr = new StringBuilder();
for ( int i = s.Length - 1; i >= 0; i--)
{
curr.Insert(0, s[i]);
long num = Convert.ToInt64(Convert.ToString(curr));
num_of_substrings += rem[( int )num % k];
rem[( int )num % k]++;
}
return num_of_substrings;
}
public static void Main( string [] args)
{
string s = "111111" ;
int k = 11;
Console.WriteLine( "Number of sub strings : "
+ Divisible(s, k));
}
}
|
Javascript
function divisible(s, k) {
let num_of_substrings = 0;
let rem = new Array(k).fill(0);
rem[0] = 1;
let curr = "" ;
for (let i = s.length - 1; i >= 0; i--) {
curr = s[i] + curr;
let num = parseInt(curr);
num_of_substrings += rem[num % k];
rem[num % k] += 1;
}
return num_of_substrings;
}
let s = "111111" ;
let k = 11;
console.log( "Number of sub strings : " , divisible(s, k));
|
Output
Number of sub strings : 9
Time Complexity: O(n2)
Auxiliary Space: O(k)
Last Updated :
03 Apr, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...