Check If All 1's Are at Least Length K Places Away

Check If All 1's Are at Least Length K Places Away - Problem

Array Easy

Given a binary array nums and an integer k, determine if all the 1s in the array are positioned such that they are at least k places away from each other.

In other words, for any two 1s at indices i and j, the absolute difference |i - j| should be greater than or equal to k.

Goal: Return true if the spacing condition is satisfied, false otherwise.

Example: In array [1,0,0,0,1,0,0,1] with k=3, the 1s are at indices 0, 4, and 7. The distances are 4-0=4 ≥ 3 and 7-4=3 ≥ 3, so return true.

Input & Output

example_1.py — Basic Valid Case

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

› Output: true

💡 Note: The 1s are at indices 0, 4, and 7. Distance between 0 and 4 is 4≥3, distance between 4 and 7 is 3≥3. All conditions satisfied.

example_2.py — Invalid Case

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

› Output: false

💡 Note: The 1s are at indices 0, 3, and 5. Distance between 3 and 5 is only 2, but we need at least 2. Since 2 is not > 2, this fails.

example_3.py — Single Element

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

› Output: true

💡 Note: With only one 1 in the array, there are no pairs to check, so the condition is automatically satisfied.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ k ≤ nums.length
nums[i] is 0 or 1

Visualization

Tap to expand

Understanding the Visualization

Start Walking

Begin at the start of the line with no previous person seen

Find First Person

Record the position when we encounter the first person

Check Next Person

When we find another person, measure distance from the last one

Validate Distance

Ensure the distance meets the minimum requirement

Key Takeaway

🎯 Key Insight: We only need to track the most recent 1's position - no need to store all positions or check all pairs!

Asked in

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

The optimal solution uses a single-pass approach with O(1) space complexity. By tracking only the last seen position of a 1, we can validate the k-distance constraint efficiently in O(n) time without storing all positions.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(m²)	O(m)	Find all 1s and check distance between every pair
One-Pass Optimal Solution	O(n)	O(1)	Track the last seen 1 and check distance in single pass

Brute Force (Check All Pairs) — Algorithm Steps

Iterate through array to find all indices containing 1s
Store these indices in a separate list
For each pair of indices, calculate the absolute difference
If any pair has distance < k, return false
If all pairs satisfy the condition, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All 1s

Scan array to collect indices of all 1s

Compare Pairs

Check distance between every pair of 1s

Validate Distance

Ensure each pair is at least k places apart

Code -

solution.c — C

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

bool kLengthApart(int* nums, int numsSize, int k) {
    int onesIndices[numsSize];
    int onesCount = 0;
    
    // Find all indices with 1s
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 1) {
            onesIndices[onesCount++] = i;
        }
    }
    
    // Check all pairs
    for (int i = 0; i < onesCount; i++) {
        for (int j = i + 1; j < onesCount; j++) {
            if (onesIndices[j] - onesIndices[i] < k) {
                return false;
            }
        }
    }
    
    return true;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²)

where m is the number of 1s in the array. We check all pairs of 1s.

✓ Linear Growth

Space Complexity

O(m)

to store the indices of all 1s in a separate list

✓ Linear Space

26.8K Views

Medium Frequency

~12 min Avg. Time

892 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 (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler