Find All K-Distant Indices in an Array

Find All K-Distant Indices in an Array - Problem

You are given a 0-indexed integer array nums and two integers key and k.

A k-distant index is an index i of nums for which there exists at least one index j such that |i - j| <= k and nums[j] == key.

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

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Key 4 appears at indices 1 and 4. For k=1: index 1 covers [0,1,2], index 4 covers [3,4,5]. Together they cover all indices.

Example 2 — Sparse Keys

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

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

💡 Note: Key 2 appears at every index. With k=2, every position is within distance 2 of multiple key occurrences.

Example 3 — No Key Found

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

› Output: []

💡 Note: Key 4 does not appear in the array, so no indices are k-distant.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
1 ≤ key ≤ 1000
0 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

M Microsoft 15 G Google 12

The key insight is that each occurrence of the key value creates a coverage zone of radius k. The optimal approach uses range merging to efficiently handle overlapping coverage areas. Time: O(n), Space: O(m) where m is the number of key occurrences.

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Dfs

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n²) Space: O(1)

Iterate through each index in the array and check if there exists any index containing the key value within distance k. If found, add the current index to the result.

Range Merging

⏱️ Time: O(n) Space: O(m)

For each key occurrence, calculate its coverage range [max(0, pos-k), min(n-1, pos+k)]. Since we need all indices in sorted order, we can merge overlapping ranges to avoid duplicates efficiently.

Two-Pass Optimization

⏱️ Time: O(n × m) Space: O(m)

First pass identifies all positions where the key occurs. Second pass iterates through the array and for each position, checks only the known key positions to see if any are within distance k.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int main() {
    char line[1000000];
    static int nums[100000];
    static int result[100000];
    int numsSize = 0;
    int key, k;
    
    // Read array
    fgets(line, sizeof(line), stdin);
    
    // Parse array [a,b,c,...] or []
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Skip whitespace
    while (*ptr && (*ptr == ' ' || *ptr == '\t')) ptr++;
    
    if (*ptr != ']') {
        while (*ptr) {
            // Skip whitespace and commas
            while (*ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == ',')) ptr++;
            
            if (*ptr == ']' || *ptr == '\0' || *ptr == '\n') break;
            
            // Parse number (handle negative numbers)
            int num = 0;
            int sign = 1;
            if (*ptr == '-') {
                sign = -1;
                ptr++;
            }
            
            while (*ptr >= '0' && *ptr <= '9') {
                num = num * 10 + (*ptr - '0');
                ptr++;
            }
            
            nums[numsSize++] = sign * num;
        }
    }
    
    // Read key
    scanf("%d", &key);
    
    // Read k
    scanf("%d", &k);
    
    // Find all k-distant indices
    int resultSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        bool isKDistant = false;
        
        // Check if there exists j such that |i - j| <= k and nums[j] == key
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] == key && abs(i - j) <= k) {
                isKDistant = true;
                break;
            }
        }
        
        if (isKDistant) {
            result[resultSize++] = i;
        }
    }
    
    // Output result
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

18.5K Views

Medium Frequency

~12 min Avg. Time

432 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