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

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

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

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

**Output**

1 2

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