# Solving Leetcode Interviews in Seconds with AI: Find Target Indices After Sorting Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2089" 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 a target element target. A target index is an index i such that nums[i] == target. Return a list of the target indices of nums after sorting nums in non-decreasing order. If there are no target indices, return an empty list. The returned list must be sorted in increasing order.   Example 1:  Input: nums = [1,2,5,2,3], target = 2 Output: [1,2] Explanation: After sorting, nums is [1,2,2,3,5]. The indices where nums[i] == 2 are 1 and 2.  Example 2:  Input: nums = [1,2,5,2,3], target = 3 Output: [3] Explanation: After sorting, nums is [1,2,2,3,5]. The index where nums[i] == 3 is 3.  Example 3:  Input: nums = [1,2,5,2,3], target = 5 Output: [4] Explanation: After sorting, nums is [1,2,2,3,5]. The index where nums[i] == 5 is 4.    Constraints:  1 <= nums.length <= 100 1 <= nums[i], target <= 100  

	# Explanation
	*   **Counting Sort:** Leverage the constraint that `1 <= nums[i], target <= 100` to use counting sort, which is highly efficient for this bounded range. This avoids the O(n log n) complexity of general-purpose sorting algorithms.
*   **Index Reconstruction:** After sorting using counting sort, iterate through the sorted array and identify the indices where the element equals the target. Store these indices in a result list.
*   **Return Sorted Indices:** The result list inherently maintains increasing order because the iteration happens sequentially after the counting sort.

*   **Runtime Complexity:** O(n), where n is the length of `nums`. **Storage Complexity:** O(1), due to the constant size of the count array (size 101).

	
	# Code
	```python
	def targetIndices(nums, target):
    """
    Finds the target indices of nums after sorting nums in non-decreasing order.

    Args:
        nums: A list of integers.
        target: The target integer.

    Returns:
        A list of the target indices of nums after sorting nums in non-decreasing order.
    """

    counts = [0] * 101
    for num in nums:
        counts[num] += 1

    sorted_nums = []
    for i in range(1, 101):
        sorted_nums.extend([i] * counts[i])

    target_indices = []
    for i in range(len(sorted_nums)):
        if sorted_nums[i] == target:
            target_indices.append(i)

    return target_indices
	```