Binary Prefix Divisible By 5 - Practice Coding Problems

Binary Prefix Divisible By 5 - Problem

You are given a binary array nums (containing only 0s and 1s). Your task is to check each binary prefix of this array to see if it represents a number divisible by 5.

More specifically, for each index i, we define x_i as the decimal number whose binary representation is formed by the subarray nums[0..i] (from most-significant-bit to least-significant-bit).

Example: If nums = [1,0,1], then:
• x_0 = 1 (binary "1")
• x_1 = 2 (binary "10")
• x_2 = 5 (binary "101")

Return an array of booleans answer where answer[i] is true if x_i is divisible by 5, and false otherwise.

Challenge: The binary numbers can become extremely large, so you'll need to use modular arithmetic to solve this efficiently!

Input & Output

example_1.py — Basic Case

$ Input: nums = [0,1,1]

› Output: [true,false,false]

💡 Note: Binary prefixes: "0" (0), "01" (1), "011" (3). Only 0 is divisible by 5.

example_2.py — Contains Divisible by 5

$ Input: nums = [1,1,1]

› Output: [false,false,false]

💡 Note: Binary prefixes: "1" (1), "11" (3), "111" (7). None are divisible by 5.

example_3.py — Multiple Matches

$ Input: nums = [0,1,1,1,1,1]

› Output: [true,false,false,false,true,false]

💡 Note: Prefixes: "0"(0)✓, "01"(1), "011"(3), "0111"(7), "01111"(15)✓, "011111"(31). Values 0 and 15 are divisible by 5.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
The binary numbers can become extremely large (up to 10⁵ bits)

Visualization

Tap to expand

Understanding the Visualization

Initialize Register

Start with remainder = 0, ready to process binary digits

Process Each Digit

For each new bit, update: remainder = (remainder × 2 + bit) % 5

Check Divisibility

If remainder = 0, the current prefix is divisible by 5!

Continue Processing

Remainder stays between 0-4, no overflow possible

Key Takeaway

🎯 Key Insight: By using modular arithmetic, we transform an overflow-prone problem into a simple, bounded calculation that works for any input size.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal solution uses modular arithmetic to track only the remainder when each binary prefix is divided by 5. Instead of computing potentially huge decimal values, we update: remainder = (remainder * 2 + current_bit) % 5. This keeps all values bounded between 0-4, preventing integer overflow while maintaining O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Convert Each Prefix)	O(n²)	O(1)	Convert each binary prefix to decimal and check divisibility by 5
Modular Arithmetic (Optimal)	O(n)	O(1)	Use modular arithmetic to track only the remainder when divided by 5

Brute Force (Convert Each Prefix) — Algorithm Steps

Iterate through each index i from 0 to n-1
For each i, convert binary prefix nums[0..i] to decimal
Check if the decimal number is divisible by 5
Store the result in answer array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first bit

nums[0] = 1, decimal = 1

Add second bit

nums[0:1] = [1,0], decimal = 2

Add third bit

nums[0:2] = [1,0,1], decimal = 5

Code -

solution.c — C

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

bool* findNumsAppeasedByFive(int* nums, int numsSize, int* returnSize) {
    bool* result = (bool*)malloc(numsSize * sizeof(bool));
    *returnSize = numsSize;
    
    for (int i = 0; i < numsSize; i++) {
        // Convert binary prefix to decimal
        long long decimalValue = 0;
        for (int j = 0; j <= i; j++) {
            decimalValue = decimalValue * 2 + nums[j];
        }
        
        // Check if divisible by 5
        result[i] = (decimalValue % 5 == 0);
    }
    
    return result;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    
    scanf("%c", &c); // read '['
    while (scanf("%d%c", &nums[size], &c)) {
        size++;
        if (c == ']') break;
    }
    
    int returnSize;
    bool* result = findNumsAppeasedByFive(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%s", result[i] ? "true" : "false");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we potentially process up to n bits to convert to decimal

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for conversion, excluding output array

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Brute Force (Convert Each Prefix) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler