# Solving Leetcode Interviews in Seconds with AI: Find All Good Indices


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2420" 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 of size n and a positive integer k. We call an index i in the range k <= i < n - k good if the following conditions are satisfied:  The k elements that are just before the index i are in non-increasing order. The k elements that are just after the index i are in non-decreasing order.  Return an array of all good indices sorted in increasing order.   Example 1:  Input: nums = [2,1,1,1,3,4,1], k = 2 Output: [2,3] Explanation: There are two good indices in the array: - Index 2. The subarray [2,1] is in non-increasing order, and the subarray [1,3] is in non-decreasing order. - Index 3. The subarray [1,1] is in non-increasing order, and the subarray [3,4] is in non-decreasing order. Note that the index 4 is not good because [4,1] is not non-decreasing. Example 2:  Input: nums = [2,1,1,2], k = 2 Output: [] Explanation: There are no good indices in this array.    Constraints:  n == nums.length 3 <= n <= 105 1 <= nums[i] <= 106 1 <= k <= n / 2  

	# Explanation
	Here's the breakdown of the approach and the Python code:

*   **High-Level Approach:**
    *   Precompute two boolean arrays: `non_increasing` and `non_decreasing`. `non_increasing[i]` will be true if the `k` elements before index `i+k` are non-increasing, and `non_decreasing[i]` will be true if the `k` elements after index `i` are non-decreasing.
    *   Iterate through the possible good indices (from `k` to `n - k - 1`) and check if both `non_increasing[i-k]` and `non_decreasing[i]` are true.
    *   Collect the good indices into a result list and return it.

*   **Complexity:**
    *   Runtime: O(n)
    *   Storage: O(n)

	
	# Code
	```python
	def goodIndices(nums, k):
    n = len(nums)
    non_increasing = [True] * n
    non_decreasing = [True] * n

    # Calculate non_increasing
    for i in range(k, n):
        if nums[i-1] < nums[i]:
            non_increasing[i] = False
        else:
            non_increasing[i] = non_increasing[i-1]
            
    # Calculate non_decreasing (from right to left)
    for i in range(n - k - 1, -1, -1):
        if nums[i+1] < nums[i]:
            non_decreasing[i] = False
        else:
            non_decreasing[i] = non_decreasing[i+1]

    result = []
    for i in range(k, n - k):
        if non_increasing[i] and non_decreasing[i]:
            result.append(i)

    return result
	```