Three Equal Parts - Practice Coding Problems

Three Equal Parts - Problem

Array Math Hard

Binary Division Challenge: Given a binary array consisting only of 0s and 1s, your task is to divide it into three non-empty parts such that all parts represent the same binary value.

You need to find indices [i, j] where i + 1 < j such that:
• First part: arr[0...i]
• Second part: arr[i+1...j-1]
• Third part: arr[j...end]

Key Points:
• Leading zeros are allowed (e.g., [0,1,1] and [1,1] both represent 3)
• All three parts must have the same binary value
• If impossible, return [-1, -1]

Example: [1,0,1,0,1] can be split as [1,0|1|0,1] where each part represents binary value 2.

Input & Output

example_1.py — Python

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

› Output: [0, 3]

💡 Note: Split into [0], [1,1], [0,1]. All represent binary value 0, 3, 1 respectively. Actually, this needs trailing zeros consideration: [0|11|01] doesn't work. Let's try [0,1|1|0,1] which gives values 1, 1, 1.

example_2.py — Python

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

› Output: [-1, -1]

💡 Note: Total of 4 ones cannot be divided evenly into 3 parts, so no solution exists.

example_3.py — Python

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

› Output: [0, 3]

💡 Note: Split into [1], [1,0], [0,1]. With proper handling of leading zeros, this becomes 1, 2, 1 which doesn't work. The actual split should consider the pattern structure.

Constraints

3 ≤ arr.length ≤ 3 × 10⁴
arr[i] is 0 or 1
Must return indices [i, j] where i + 1 < j

Visualization

Tap to expand

Understanding the Visualization

Count the Chips

Count total chocolate chips - if not divisible by 3, impossible

Find Pattern

Each piece needs exactly the same number of chips and same trailing pattern

Verify Match

Starting from first chip in each piece, verify identical patterns

Key Takeaway

🎯 Key Insight: Count total 1s first - if not divisible by 3, impossible. Otherwise, locate the pattern structure and verify each part matches exactly.

Asked in

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

The optimal solution uses mathematical analysis: count total 1s, check if divisible by 3, then find the pattern structure. Each part must have exactly ones/3 ones and match the trailing zero pattern. This avoids the O(n³) brute force approach and solves in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Splits)	O(n³)	O(1)	Try every possible way to split the array into three parts and check if they're equal
Mathematical Analysis (Optimal)	O(n)	O(1)	Use mathematical properties: count 1s, check divisibility, match patterns

Brute Force (Try All Splits) — Algorithm Steps

Try all possible positions i and j where i+1 < j
For each split, extract the three parts
Convert each part from binary array to integer value
Check if all three values are equal
Return the first valid split found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Split Position

Test each possible combination of split positions i and j

Convert to Binary

Convert each of the three parts to their binary values

Compare Values

Check if all three binary values are equal

Code -

solution.c — C

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

long long binaryToInt(int* arr, int start, int end) {
    long long result = 0;
    for (int i = start; i <= end; i++) {
        result = result * 2 + arr[i];
    }
    return result;
}

int* threeEqualParts(int* arr, int arrSize, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    for (int i = 0; i < arrSize - 2; i++) {
        for (int j = i + 2; j < arrSize; j++) {
            long long part1 = binaryToInt(arr, 0, i);
            long long part2 = binaryToInt(arr, i + 1, j - 1);
            long long part3 = binaryToInt(arr, j, arrSize - 1);
            
            if (part1 == part2 && part2 == part3) {
                result[0] = i;
                result[1] = j;
                return result;
            }
        }
    }
    
    result[0] = -1;
    result[1] = -1;
    return result;
}

int main() {
    int arr[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &arr[n], &c)) {
        n++;
        if (c == '\n') break;
    }
    
    int returnSize;
    int* result = threeEqualParts(arr, n, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) possible splits, each requiring O(n) time to convert binary to decimal

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

26.5K Views

Medium Frequency

~25 min Avg. Time

842 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 (Try All Splits) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler