Count Substrings Divisible By Last Digit - Practice Coding Problems

Count Substrings Divisible By Last Digit - Problem

You are given a string s consisting only of digits. Your task is to find the number of substrings where each substring is divisible by its last (rightmost) digit.

Key Points:

Only consider substrings whose last digit is non-zero (since division by 0 is undefined)
A substring can have leading zeros - this is allowed
For example, in "123", the substring "12" should be checked if 12 is divisible by 2 (its last digit)

Example: Given s = "1248", the substring "124" ends with digit 4, so we check if 124 is divisible by 4. Since 124 ÷ 4 = 31 with no remainder, this substring counts toward our answer.

Input & Output

example_1.py — Basic Case

$ Input: s = "1248"

› Output: 7

💡 Note: Valid substrings: "1" (1÷1=1), "12" (12÷2=6), "124" (124÷4=31), "1248" (1248÷8=156), "2" (2÷2=1), "24" (24÷4=6), "248" (248÷8=31)

example_2.py — With Zeros

$ Input: s = "1230"

› Output: 3

💡 Note: Valid substrings: "1" (1÷1=1), "12" (12÷2=6), "123" (123÷3=41). Substrings ending with '0' are not considered since division by 0 is undefined.

example_3.py — Single Digit

$ Input: s = "5"

› Output: 1

💡 Note: Only one substring "5", and 5÷5=1, so it's valid.

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of digits (0-9)
No leading zeros constraint - substrings may have leading zeros

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Endings

Find positions with non-zero digits (these can be last digits)

Build Substrings

For each valid ending, build all possible substrings ending there

Check Divisibility

Use modular arithmetic to check if substring value is divisible by last digit

Count Valid Cases

Accumulate the count of all valid substrings

Key Takeaway

🎯 Key Insight: Use modular arithmetic to check divisibility efficiently without converting entire substrings to integers, avoiding overflow and improving performance.

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal approach uses modular arithmetic to efficiently check divisibility without integer overflow. Instead of converting substrings to integers, we maintain remainders as we build substrings character by character. This achieves O(n²) time complexity while avoiding the overhead of string-to-integer conversions and potential overflow issues.

Common Approaches

Approach	Time	Space	Notes
✓ Modular Arithmetic Optimization	O(n²)	O(1)	Use modular arithmetic to avoid integer overflow and improve efficiency
Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all substrings and check divisibility for each

Modular Arithmetic Optimization — Algorithm Steps

For each position j where s[j] != '0', let d = s[j]
For each starting position i <= j, build substring s[i:j+1]
Use modular arithmetic: remainder = (remainder * 10 + digit) % d
If remainder == 0, the substring is divisible by d
Count all such valid substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix End Position

For each position j with non-zero digit d

Build Backwards

Extend substring leftwards using modular arithmetic

Check Remainder

If remainder is 0, substring is divisible by d

Code -

solution.c — C

#include <math.h>

int countDivisibleSubstrings(char* s) {
    int count = 0;
    int n = strlen(s);
    
    for (int j = 0; j < n; j++) {
        if (s[j] != '0') {
            int d = s[j] - '0';
            int remainder = 0;
            
            for (int i = j; i >= 0; i--) {
                int digit = s[i] - '0';
                remainder = (remainder + digit * (int)pow(10, j - i)) % d;
                if (remainder == 0) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) for checking all substrings, but with efficient modular arithmetic operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for tracking remainders

✓ Linear Space

38.0K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Modular Arithmetic Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler