Skip to content
Related Articles

Related Articles

Improve Article

Count of Substrings having Sum equal to their Length

  • Difficulty Level : Easy
  • Last Updated : 19 May, 2021

Given a numeric string str, the task is to calculate the number of substrings with the sum of digits equal to their length.

Examples:

Input: str = “112112” 
Output: 6 
Explanation: 
Substrings “1”, “1”, “11”, “1”, “1”, “11” satisfy the given condition.
Input: str = “1101112” 
Output: 12

Naive Approach: The simplest solution is to generate all substrings of the given string and for each substring, check if its sum is equal to its length or not. For each substring found to be true, increase count. 
Time Complexity: O(N3) 
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized using a Hashmap and keep updating the count of substrings in the Hashmap and print the required count at the end.

Below is the implementation of the above approach:



C++




// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number of
// substrings with sum equal to length
int countSubstrings(string s, int n)
{
 
    int count = 0, sum = 0;
 
    // Stores the count of substrings
    unordered_map<int, int> mp;
    mp[0]++;
 
    for (int i = 0; i < n; ++i) {
 
        // Add character to sum
        sum += (s[i] - '0');
 
        // Add count of substrings to result
        count += mp[sum - (i + 1)];
 
        // Increase count of subarrays
        ++mp[sum - (i + 1)];
    }
 
    // Return count
    return count;
}
 
// Driver Code
int main()
{
    string str = "112112";
    int n = str.length();
    cout << countSubstrings(str, n) << endl;
 
    return 0;
}
Java



// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Function to count the number of
// subStrings with sum equal to length
static int countSubStrings(String s, int n)
{
    int count = 0, sum = 0;
 
    // Stores the count of subStrings
    HashMap<Integer,
            Integer> mp = new HashMap<Integer,
                                      Integer>();
    mp.put(0, 1);
 
    for(int i = 0; i < n; ++i)
    {
         
        // Add character to sum
        sum += (s.charAt(i)- '0');
 
        // Add count of subStrings to result
        count += mp.containsKey(sum - (i + 1)) == true ?
                         mp.get(sum - (i + 1)) : 0;
 
        // Increase count of subarrays
        if(!mp.containsKey(sum - (i + 1)))
                    mp.put(sum - (i + 1), 1);
        else
            mp.put(sum - (i + 1),
            mp.get(sum - (i + 1)) + 1);
    }
 
    // Return count
    return count;
}
 
// Driver Code
public static void main(String[] args)
{
    String str = "112112";
    int n = str.length();
     
    System.out.print(countSubStrings(str, n) + "\n");
}
}
 
// This code is contributed by Amit Katiyar
Python3



# Python3 program to implement
# the above approach
from collections import defaultdict
 
# Function to count the number of
# substrings with sum equal to length
def countSubstrings(s, n):
     
    count, sum = 0, 0
     
    # Stores the count of substrings
    mp = defaultdict(lambda : 0)
    mp[0] += 1
     
    for i in range(n):
         
        # Add character to sum
        sum += ord(s[i]) - ord('0')
         
        # Add count of substrings to result
        count += mp[sum - (i + 1)]
         
        # Increase count of subarrays
        mp[sum - (i + 1)] += 1
         
    # Return count
    return count
 
# Driver code
str = '112112'
n = len(str)
 
print(countSubstrings(str, n))
 
# This code is contributed by Stuti Pathak
C#



// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to count the number of
// subStrings with sum equal to length
static int countSubStrings(String s, int n)
{
    int count = 0, sum = 0;
 
    // Stores the count of subStrings
    Dictionary<int,
               int> mp = new Dictionary<int,
                                        int>();
    mp.Add(0, 1);
 
    for(int i = 0; i < n; ++i)
    {
         
        // Add character to sum
        sum += (s[i]- '0');
 
        // Add count of subStrings to result
        count += mp.ContainsKey(sum - (i + 1)) == true ?
                             mp[sum - (i + 1)] : 0;
 
        // Increase count of subarrays
        if(!mp.ContainsKey(sum - (i + 1)))
                    mp.Add(sum - (i + 1), 1);
        else
            mp[sum - (i + 1)] = mp[sum - (i + 1)] + 1;
    }
 
    // Return count
    return count;
}
 
// Driver Code
public static void Main(String[] args)
{
    String str = "112112";
    int n = str.Length;
     
    Console.Write(countSubStrings(str, n) + "\n");
}
}
 
// This code is contributed by Rohit_ranjan
Javascript



<script>
 
// Javascript Program to implement
// the above approach
 
// Function to count the number of
// substrings with sum equal to length
function countSubstrings(s, n)
{
 
    var count = 0, sum = 0;
 
    // Stores the count of substrings
    var mp = new Map();
 
    if(mp.has(0))
        mp.set(0, mp.get(0)+1)
    else
        mp.set(0, 1);
 
    for (var i = 0; i < n; ++i) {
 
        // Add character to sum
        sum += (s[i].charCodeAt(0) - '0'.charCodeAt(0));
 
        // Add count of substrings to result
        if(mp.has(sum - (i + 1)))
            count += mp.get(sum - (i + 1));
 
        // Increase count of subarrays
        if(mp.has(sum - (i + 1)))
            mp.set(sum - (i + 1), mp.get(sum - (i + 1))+1)
        else
            mp.set(sum - (i + 1), 1)
    }
 
    // Return count
    return count;
}
 
// Driver Code
var str = "112112";
var n = str.length;
document.write( countSubstrings(str, n));
 
</script>
Output: 
6
 
Time Complexity: O(N) 
Auxiliary Space: O(N)
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.



My Personal Notes
arrow_drop_up
Previous
Smallest Subarray with Sum K from an Array
Next

Maximize count of elements reaching the end of an Array
Recommended Articles
Page :
Count of pairs in given range having their ratio equal to ratio of product of their digits
08, Sep 21
Maximum sum of a subsequence having difference between their indices equal to the difference between their values
17, Jun 21
Count of pairs in a given range with sum of their product and sum equal to their concatenated number
14, Jun 20
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Count pairs in an array having sum of elements with their respective sum of digits equal
10, Aug 21
Count ways to split a Binary String into three substrings having equal count of zeros
09, Sep 20
Lexicographically smallest permutation of a string that can be reduced to length K by removing K-length prefixes from palindromic substrings of length 2K
11, Nov 20
Count pairs from an array having product of their sum and difference equal to 0
09, Oct 20
Count pairs from an array having product of their sum and difference equal to 1
12, Oct 20
Count ways to split array into two subsets having difference between their sum equal to K
09, Jun 21
Count pairs from an array having sum of twice of their AND and XOR equal to K
01, Feb 21
Count pairs up to N having sum equal to their XOR
02, Jun 21
Possible values of Q such that, for any value of R, their product is equal to X times their sum
09, Aug 20
Check if all substrings of length K of a Binary String has equal count of 0s and 1s
08, Sep 20
Count of palindromes that can be obtained by concatenating equal length prefix and substrings
15, Jan 21
Split a given string into substrings of length K with equal sum of ASCII values
25, Jun 20
Count of integers in given range having their last K digits are equal
12, Aug 21
Count pairs of nodes having minimum distance between them equal to the difference of their distances from root
23, Feb 21
Count pairs from 1 to N such that their Sum is divisible by their XOR
17, Mar 20
Count of binary strings of length N having equal count of 0's and 1's
15, Jul 20
Count of subarrays having sum equal to its length
19, Aug 20
Generate an N-length array having equal count and sum of elements of both parities
01, Feb 21
Count N-length arrays of made up of elements not exceeding 2^K - 1 having maximum sum and Bitwise AND equal to 0
23, Jul 21
Count of subarrays having sum equal to its length | Set 2
27, Oct 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
durgeshkumar30508
@durgeshkumar30508
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox