Number of Divisible Substrings - Practice Coding Problems

Number of Divisible Substrings - Problem

Imagine each letter of the alphabet has a secret numerical value: a=1, b=2, c=3, ..., z=26. Now here's the twist - a substring is considered "divisible" if the sum of its character values is perfectly divisible by its length!

For example, in the string "abc":

"a" has sum=1, length=1 → 1÷1=1 ✅ (divisible)
"ab" has sum=3, length=2 → 3÷2=1.5 ❌ (not divisible)
"abc" has sum=6, length=3 → 6÷3=2 ✅ (divisible)

Your mission: count how many substrings in the given string are divisible!

Remember: A substring is any contiguous sequence of characters, and we need to check every possible one.

Input & Output

example_1.py — Basic Case

$ Input: s = "abc"

› Output: 4

💡 Note: Character values: a=1, b=2, c=3. Divisible substrings: "a" (sum=1, len=1, 1%1=0), "abc" (sum=6, len=3, 6%3=0), "b" (sum=2, len=1, 2%1=0), "c" (sum=3, len=1, 3%1=0). Total: 4 substrings.

example_2.py — Single Character

$ Input: s = "a"

› Output: 1

💡 Note: Only one substring "a" with sum=1, length=1. Since 1%1=0, it's divisible. Result: 1.

example_3.py — No Divisible Substrings

$ Input: s = "bb"

› Output: 2

💡 Note: Character values: b=2. Substrings: "b" (sum=2, len=1, 2%1=0) appears twice, "bb" (sum=4, len=2, 4%2=0). All are divisible. Result: 3.

Constraints

1 ≤ s.length ≤ 1000
s consists of only lowercase English letters
Each character maps to its position in alphabet (a=1, b=2, ..., z=26)

Visualization

Tap to expand

Understanding the Visualization

Assign Values

Each letter gets a value: a=1 pepperoni, b=2 mushrooms, c=3 olives

Check Slices

For each possible slice (substring), calculate total points

Test Divisibility

A slice is 'perfect' if total points ÷ number of toppings has no remainder

Count Perfect Slices

Sum up all the perfect slices found

Key Takeaway

🎯 Key Insight: Use running sums to avoid recalculating substring values, checking divisibility immediately as we extend each substring.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal approach uses a two-pointer technique with running sums to avoid redundant calculations. For each starting position, we maintain a running sum and check divisibility as we extend the substring. This reduces time complexity from O(n³) to O(n²) while using only O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Prefix Sum (Optimal)	O(n²)	O(n²)	Use prefix sums and modular arithmetic to count divisible substrings efficiently
Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible substring by calculating sum and length directly

Optimized with Prefix Sum (Optimal) — Algorithm Steps

Build prefix sum array where prefix[i] = sum of character values from 0 to i-1
For each ending position j, check all possible lengths
For length L, we need prefix[j+1] % L == prefix[j+1-L] % L
Use hash map to count occurrences of each (remainder, length) pair
Sum up all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix starting position

Choose a starting index and maintain running sum

Extend and check

Add next character and check divisibility immediately

Avoid recalculation

Reuse the running sum instead of recalculating

Move to next start

Reset sum and start from next position

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int countDivisibleSubstrings(char* s) {
    int n = strlen(s);
    int count = 0;
    
    // For each starting position
    for (int i = 0; i < n; i++) {
        int currentSum = 0;
        // For each ending position from this start
        for (int j = i; j < n; j++) {
            currentSum += s[j] - 'a' + 1;
            int length = j - i + 1;
            
            if (currentSum % length == 0) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char s[1001];
    scanf("%s", s);
    printf("%d\n", countDivisibleSubstrings(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each position, we check all possible lengths, giving O(n²) total operations

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash map can store up to O(n²) (remainder, length) pairs in worst case

⚠ Quadratic Space

23.7K Views

Medium Frequency

~18 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized with Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler