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

• Difficulty Level : Easy
• Last Updated : 19 Jul, 2022

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++

 `// C++ implementation of the above approach` `#include ``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

 `// Java implementation of the above approach``import` `java.util.*;``public` `class` `GFG {` `    ``// Function to find indices``    ``// of val in array after sorting``    ``static` `List 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 ans = ``new` `ArrayList();``        ``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 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.`

## Python3

 `# 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#

 `// 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.`

## Javascript

 ``

Output

`1 2 `

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

My Personal Notes arrow_drop_up