# Solving Leetcode Interviews in Seconds with AI: Find All K-Distant Indices in an Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2200" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.   Example 1:  Input: nums = [3,4,9,1,3,9,5], key = 9, k = 1 Output: [1,2,3,4,5,6] Explanation: Here, nums[2] == key and nums[5] == key. - For index 0, |0 - 2| > k and |0 - 5| > k, so there is no j where |0 - j| <= k and nums[j] == key. Thus, 0 is not a k-distant index. - For index 1, |1 - 2| <= k and nums[2] == key, so 1 is a k-distant index. - For index 2, |2 - 2| <= k and nums[2] == key, so 2 is a k-distant index. - For index 3, |3 - 2| <= k and nums[2] == key, so 3 is a k-distant index. - For index 4, |4 - 5| <= k and nums[5] == key, so 4 is a k-distant index. - For index 5, |5 - 5| <= k and nums[5] == key, so 5 is a k-distant index. - For index 6, |6 - 5| <= k and nums[5] == key, so 6 is a k-distant index. Thus, we return [1,2,3,4,5,6] which is sorted in increasing order.   Example 2:  Input: nums = [2,2,2,2,2], key = 2, k = 2 Output: [0,1,2,3,4] Explanation: For all indices i in nums, there exists some index j such that |i - j| <= k and nums[j] == key, so every index is a k-distant index.  Hence, we return [0,1,2,3,4].    Constraints:  1 <= nums.length <= 1000 1 <= nums[i] <= 1000 key is an integer from the array nums. 1 <= k <= nums.length  

	# Explanation
	Here's the breakdown of the solution:

*   **Identify Key Indices:** First, locate all indices `j` where `nums[j] == key`.
*   **Determine k-Distant Indices:** For each index `i` in `nums`, check if there exists a `j` (from the previous step) such that `abs(i - j) <= k`. If so, `i` is a k-distant index.
*   **Collect and Sort:** Gather all k-distant indices and sort them in increasing order.

*   **Runtime Complexity:** O(n*m), where n is the length of `nums` and m is the number of occurrences of `key` in `nums`. In worst case m can be n, so it can also be considered O(n^2)
    **Storage Complexity:** O(n), primarily for storing the result list.

	
	# Code
	```python
	def k_distant_indices(nums, key, k):
    """
    Finds and returns a list of k-distant indices in the given array.

    Args:
        nums: A list of integers.
        key: The integer to search for.
        k: The maximum distance allowed.

    Returns:
        A list of k-distant indices sorted in increasing order.
    """

    key_indices = []
    for i in range(len(nums)):
        if nums[i] == key:
            key_indices.append(i)

    distant_indices = []
    for i in range(len(nums)):
        for j in key_indices:
            if abs(i - j) <= k:
                distant_indices.append(i)
                break  # Once i is identified as distant, move on

    return sorted(list(set(distant_indices)))  # Remove duplicates and sort
	```