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

14 Dec, 2021
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 array in increasing order.
Note: The indices must be in increasing order.
Examples: 
Input: arr = [1, 2, 5, 2, 3], val = 2Output: 1 2Explanation: 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 = 6Output: []Explanation: After sorting, nums is [1, 2, 2, 3, 5]. The value 6 is not 
C++
Java
Python3
C#
Javascript
// C++ implementation of the above approach #include <bits/stdc++.h>using namespace std; // Function to find indices// of val in array after sortingvector<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 codeint 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 approachimport 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++) {            zz 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 sortingdef targetIndices(nums, val):     count_less = 0    count_target = 0     # Loop to count smaller elements and val    for it in nums:        if (it == val):            count_target += 1        if (it < val):            count_less += 1         # List to store indices    ans = []    while (count_target):        count_target -= 1        ans.append(count_less)        count_less += 1     return ans # Driver codeif __name__ == "__main__":     nums = [1, 2, 5, 2, 3]    val = 2    ans = targetIndices(nums, val)     # Loop to print indices    for i in range(0, len(ans)):        print(ans[i], end=" ")     # This code is contributed by rakeshsahni
// C# implementation of the above approachusing 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 sortingfunction 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 codelet 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>
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 in 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 observation of a sorted array. In an array which is sorted in increasing order all the elements before val is less than val. So, to get the indices of val in 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 count of elements less than val (smallCount) and elements having value same as val (sameCount).
If value of an element is less than val increment smallCount by one.
If 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++
Java
Python3
C#
Javascript
// C++ implementation of the above approach #include <bits/stdc++.h>using namespace std; // Function to find indices// of val in array after sortingvector<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 codeint 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 approachimport java.util.*;public class GFG{   // Function to find indices// of val in array after sortingstatic 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 codepublic 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++) {zz        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 sortingdef 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 codenums = [1, 2, 5, 2, 3]val = 2ans = targetIndices(nums, val) # Loop to print indicesfor i in range(len(ans)):    print(ans[i], end=" ") # This code is contributed by Saurabh Jaiswal
// C# implementation of the above approachusing System;using System.Collections;using System.Collections.Generic; class GFG{   // Function to find indices// of val in array after sortingstatic 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 codepublic 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 sortingfunction 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 codelet 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)
 
samim2000
_saurabh_jaiswal
rakeshsahni
Arrays
Sorting
Arrays
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Chocolate Distribution Problem
Reversal algorithm for array rotation
Window Sliding Technique
Next Greater Element
Find duplicates in O(n) time and O(1) extra space | Set 1