Find All K-Distant Indices in an Array - Practice Coding Problems

Find All K-Distant Indices in an Array - Problem

You're given a 0-indexed integer array nums and two integers key and k. Your task is to find all indices that are "close enough" to any occurrence of the key value.

An index i is considered k-distant if there exists at least one index j where:

nums[j] == key (j points to our target value)
|i - j| <= k (i is within k positions of j)

Goal: Return a list of all k-distant indices sorted in increasing order.

Example: If nums = [3,4,9,1,3,9,5], key = 9, and k = 1, then indices 2 and 5 contain the value 9. The k-distant indices are [1,2,3,4,5,6] because they're all within distance 1 of either index 2 or 5.

Input & Output

example_1.py — Basic case

$ Input: nums = [3,4,9,1,3,9,5], key = 9, k = 1

› Output: [1,2,3,4,5,6]

💡 Note: The key 9 appears at indices 2 and 5. Index 1 is k-distant because |1-2| = 1 ≤ k. Index 2 is k-distant because it contains the key. Index 3 is k-distant because |3-2| = 1 ≤ k. Index 4 is k-distant because |4-5| = 1 ≤ k. Index 5 is k-distant because it contains the key. Index 6 is k-distant because |6-5| = 1 ≤ k. Index 0 is not k-distant because |0-2| = 2 > k and |0-5| = 5 > k.

example_2.py — No overlapping coverage

$ Input: nums = [2,2,2,2], key = 2, k = 2

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

💡 Note: Every element is the key value 2, so all indices are k-distant by definition. Since each index contains the key, the distance from any index to itself is 0, which is ≤ k = 2.

example_3.py — Large distance

$ Input: nums = [1,1000,1,1000], key = 1000, k = 0

› Output: [1,3]

💡 Note: The key 1000 appears at indices 1 and 3. With k = 0, only indices that exactly contain the key are k-distant. Therefore, only indices 1 and 3 qualify as k-distant indices.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
key is an integer from the range [1, 1000]
0 ≤ k ≤ nums.length

Visualization

Tap to expand

Understanding the Visualization

Identify Radio Towers

Find all positions where towers (key values) are located

Calculate Coverage Zones

Each tower broadcasts k miles in both directions

Mark Signal Reception

Any mile marker within range receives the signal

Collect All Covered Areas

Gather all positions that receive at least one signal

Key Takeaway

🎯 Key Insight: Instead of checking each position's distance to every tower, find towers and immediately expand their coverage zones - this eliminates redundant distance calculations and achieves optimal performance.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a coverage expansion approach with O(n + m*k) time complexity. When a key is found, immediately mark all indices within k distance as valid, eliminating redundant calculations and achieving maximum efficiency through single-pass processing.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Key Positions	O(n + m*log(m))	O(m)	Find all key positions first, then use two pointers to efficiently determine k-distant indices
Brute Force (Nested Loops)	O(n²)	O(1)	For each index, check all other indices to see if any contain the key within distance k
Optimal Single Pass (Coverage Expansion)	O(n + m*k)	O(n)	Find each key and immediately mark all indices within its k-distance range as valid

Two Pointers with Key Positions — Algorithm Steps

Find and store all indices where nums[i] == key
Initialize result list and two pointers (left=0, right=0)
For each index i from 0 to n-1:
Use two pointers to find the closest key positions
If minimum distance to any key <= k, add i to result
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Key Positions

Collect all indices where the key value appears

Binary Search

For each index, use binary search to find closest key

Check Distance

If distance <= k, add index to result

Code -

solution.c — C

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

int* findKDistantIndices(int* nums, int numsSize, int key, int k, int* returnSize) {
    int* keyPositions = malloc(numsSize * sizeof(int));
    int keyCount = 0;
    
    // Find all key positions
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == key) {
            keyPositions[keyCount++] = i;
        }
    }
    
    int* result = malloc(numsSize * sizeof(int));
    *returnSize = 0;
    
    if (keyCount == 0) {
        free(keyPositions);
        return result;
    }
    
    for (int i = 0; i < numsSize; i++) {
        int minDistance = 1000000;
        
        // Find minimum distance to any key
        for (int j = 0; j < keyCount; j++) {
            int distance = abs(i - keyPositions[j]);
            if (distance < minDistance) {
                minDistance = distance;
            }
        }
        
        if (minDistance <= k) {
            result[(*returnSize)++] = i;
        }
    }
    
    free(keyPositions);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m*log(m))

O(n) to find keys and check indices, O(m*log(m)) for binary search where m is number of keys

⚡ Linearithmic

Space Complexity

O(m)

Extra space needed to store all key positions

✓ Linear Space

28.7K Views

Medium Frequency

~15 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

Two Pointers with Key Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler