Find the Divisibility Array of a String - Practice Coding Problems

Find the Divisibility Array of a String - Problem

You are given a string word consisting of digits and a positive integer m. Your task is to create a divisibility array that tells you whether each prefix of the string is divisible by m.

For each position i in the string, you need to check if the number formed by characters from index 0 to i is divisible by m. If it is, set div[i] = 1, otherwise set div[i] = 0.

Example: If word = "998244353" and m = 3, then:
• Prefix "9" → 9 % 3 = 0 → div[0] = 1
• Prefix "99" → 99 % 3 = 0 → div[1] = 1
• Prefix "998" → 998 % 3 = 2 → div[2] = 0

The challenge is handling very large numbers that can't fit in standard integer types!

Input & Output

example_1.py — Basic Case

$ Input: word = "998244353", m = 3

› Output: [1, 1, 0, 0, 0, 1, 1, 0, 0]

💡 Note: Checking each prefix: "9"(9%3=0✓), "99"(99%3=0✓), "998"(998%3=2✗), "9982"(9982%3=1✗), "99824"(99824%3=1✗), "998244"(998244%3=0✓), "9982443"(9982443%3=0✓), "99824435"(99824435%3=1✗), "998244353"(998244353%3=2✗)

example_2.py — All Divisible

$ Input: word = "1010", m = 10

› Output: [0, 1, 0, 1]

💡 Note: Prefixes: "1"(1%10=1✗), "10"(10%10=0✓), "101"(101%10=1✗), "1010"(1010%10=0✓)

example_3.py — Single Digit

$ Input: word = "5", m = 5

› Output: [1]

💡 Note: Only one prefix "5", and 5%5=0, so result is [1]

Constraints

1 ≤ word.length ≤ 10⁵
word consists of digits only
1 ≤ m ≤ 10⁹
Important: The number represented by word can be extremely large and may not fit in standard integer types

Visualization

Tap to expand

Understanding the Visualization

Start Fresh

Begin with remainder = 0, like resetting our special calculator

Add New Digit

For each digit, calculate: remainder = (remainder * 10 + digit) % m

Check Division

If remainder equals 0, the current prefix is perfectly divisible

Continue Rolling

The remainder carries forward, maintaining our running calculation

Key Takeaway

🎯 Key Insight: By maintaining only the remainder instead of the full number, we can handle arbitrarily large inputs while keeping constant space and linear time complexity!

Asked in

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

The optimal solution uses modular arithmetic to efficiently track remainders without converting large numbers. Key insight: (a*10 + b) % m = ((a%m)*10 + b) % m allows us to process each digit in O(1) time, achieving O(n) overall complexity while handling arbitrarily large numbers.

Common Approaches

Approach	Time	Space	Notes
✓ Modular Arithmetic (Optimal)	O(n)	O(n)	Use modular arithmetic to track remainder without converting large numbers
Brute Force (Convert Each Prefix)	O(n²)	O(n)	Convert each prefix substring to integer and check divisibility directly

Modular Arithmetic (Optimal) — Algorithm Steps

Initialize remainder = 0
For each digit in the string:
Calculate new remainder = (remainder * 10 + digit) % m
If remainder == 0, set div[i] = 1, else div[i] = 0
Continue with updated remainder

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with remainder = 0

Process Digit

remainder = (remainder * 10 + digit) % m

Check Divisibility

If remainder == 0, the prefix is divisible

Continue

Use updated remainder for next iteration

Code -

solution.c — C

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

int* divisibilityArray(char* word, int m, int* returnSize) {
    int n = strlen(word);
    int* div = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    int remainder = 0;
    
    for (int i = 0; i < n; i++) {
        int digit = word[i] - '0';
        remainder = (remainder * 10 + digit) % m;
        div[i] = (remainder == 0) ? 1 : 0;
    }
    
    return div;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant time per character

✓ Linear Growth

Space Complexity

O(n)

Only space needed is for the result array

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

850 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler