Find all indices of a given element in sorted form of given Array

Given an array arr[] of integers of size N and a target value val. Your task is to find the indices of val in the array after sorting the array in increasing order.

Note: The indices must be in increasing order.

Examples: 

Input: arr = [1, 2, 5, 2, 3], val = 2
Output: 1 2
Explanation: After sorting, arr[] becomes [1, 2, 2, 3, 5]. The indices where arr[i] = 2 are 1 and 2. As the indices should be in increasing order, that's why they are   (1, 2) and not (2, 1)

Input: arr = [1, 2, 5, 2, 3], val = 6
Output: []
Explanation: After sorting, nums is [1, 2, 2, 3, 5]. The value 6 is not present in the array. 

Naive Approach: The concept of this approach is based on sorting. The array is sorted in increasing order. Then the sorted array is traversed. While traversing the array if any value matches the target, that index is added to the answer list. After the iteration is complete the answer list is returned.
Time Complexity: O(N*logN)
Auxiliary Space: O(1)

Efficient Approach: This approach is based on the observation of a sorted array. In an array which is sorted in increasing order all the elements before val are less than val. So, to get the indices of val in a sorted array, instead of performing sort operation, we can simply count the elements less than val. If the count is x then val will start from x-th index (because of 0-based indexing). Follow the steps mentioned below: 

• Traverse the array. Use variables to store the count of elements less than val (smallCount) and elements having a value same as val (sameCount).
• If the value of an element is less than val increment smallCount by one.
• If the value is same as val increment sameCount by one.
• After traversal is complete, the indices will start from smallCount and end at (smallCount+sameCount-1)

Below is the implementation of the above approach:

// C++ implementation of the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find indices
// of val in array after sorting
vector<int> targetIndices(vector<int>& nums,
                          int val)
{
    int count_less = 0;
    int count_target = 0;

    // Loop to count smaller elements and val
    for (auto& it : nums) {
        if (it == val)
            count_target++;
        if (it < val)
            count_less++;
    }

    // List to store indices
    vector<int> ans;
    while (count_target--) {
        ans.push_back(count_less++);
    }
    return ans;
}

// Driver code
int main()
{
    vector<int> nums{ 1, 2, 5, 2, 3 };
    int val = 2;
    vector<int> ans = targetIndices(nums, val);

    // Loop to print indices
    for (int i = 0; i < ans.size(); i++) {
        cout << ans[i] << " ";
    }
    return 0;
}

// Java implementation of the above approach
import java.util.*;
public class GFG {

    // Function to find indices
    // of val in array after sorting
    static List<Integer> targetIndices(int[] nums, int val)
    {
        int count_less = 0;
        int count_target = 0;

        // Loop to count smaller elements and val
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == val)
                count_target++;
            if (nums[i] < val)
                count_less++;
        }

        // List to store indices
        List<Integer> ans = new ArrayList<Integer>();
        while (count_target > 0) {
            ans.add(count_less++);
            count_target--;
        }
        return ans;
    }

    // Driver code
    public static void main(String args[])
    {
        int[] nums = { 1, 2, 5, 2, 3 };
        int val = 2;
        List<Integer> ans = targetIndices(nums, val);

        // Loop to print indices
        for (int i = 0; i < ans.size(); i++) {
            System.out.print(ans.get(i) + " ");
        }
    }
}

// This code is contributed by Samim Hossain Mondal.

# Python implementation of the above approach

# Function to find indices
# of val in array after sorting


def targetIndices(nums, val):
    count_less = 0
    count_target = 0

    # Loop to count smaller elements and val
    for i in range(len(nums)):
        if (nums[i] == val):
            count_target += 1
        if (nums[i] < val):
            count_less += 1

    # List to store indices
    ans = []
    while (count_target):
        ans.append(count_less)
        count_less += 1
        count_target -= 1
    return ans


# Driver code
nums = [1, 2, 5, 2, 3]
val = 2
ans = targetIndices(nums, val)

# Loop to print indices
for i in range(len(ans)):
    print(ans[i], end=" ")

# This code is contributed by Saurabh Jaiswal

// C# implementation of the above approach
using System;
using System.Collections;
using System.Collections.Generic;

class GFG {

    // Function to find indices
    // of val in array after sorting
    static ArrayList targetIndices(int[] nums, int val)
    {
        int count_less = 0;
        int count_target = 0;

        // Loop to count smaller elements and val
        for (int i = 0; i < nums.Length; i++) {
            if (nums[i] == val)
                count_target++;
            if (nums[i] < val)
                count_less++;
        }

        // List to store indices
        ArrayList ans = new ArrayList();
        while (count_target > 0) {
            ans.Add(count_less++);
            count_target--;
        }
        return ans;
    }

    // Driver code
    public static void Main()
    {
        int[] nums = { 1, 2, 5, 2, 3 };
        int val = 2;
        ArrayList ans = targetIndices(nums, val);

        // Loop to print indices
        for (int i = 0; i < ans.Count; i++) {
            Console.Write(ans[i] + " ");
        }
    }
}

// This code is contributed by Samim Hossain Mondal.

<script>
// Javascript implementation of the above approach

// Function to find indices
// of val in array after sorting
function targetIndices(nums, val)
{
    let count_less = 0;
    let count_target = 0;

    // Loop to count smaller elements and val
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] == val)
            count_target++;
        if (nums[i] < val)
            count_less++;
    }

    // List to store indices
    let ans = [];
    while (count_target--) {
        ans.push(count_less++);
    }
    return ans;
}

// Driver code
let nums = [ 1, 2, 5, 2, 3 ];
let val = 2;
let ans = targetIndices(nums, val);

    // Loop to print indices
    for (let i = 0; i < ans.length; i++) {
        document.write(ans[i] + " ");
    }
    
// This code is contributed by Samim Hossain Mondal.
</script>

1 2 

Time Complexity: O(N)
Auxiliary Space: O(1)