Recursive program to find all Indices of a Number
Given an array arr of size N and an integer X. The task is to find all the indices of the integer X in the array
Examples:
Input: arr = {1, 2, 3, 2, 2, 5}, X = 2
Output: 1 3 4
Element 2 is present at indices 1, 3, 4 (0 based indexing)
Input: arr[] = {7, 7, 7}, X = 7
Output: 0 1 2
The iterative approach is simple, just traverse the given array and keep on storing the indices of the element in the another array.
Recursive approach:
- If the start index reaches the length of the array, then return empty array
- Else keep the first element of the array with yourself and pass the rest of the array to recursion.
- If the element at start index is not equal to x then just simply return the answer which came from recursion.
- Else if the element at start index is equal to x then shift the elements of the array (which is the answer of recursion) one step to the right and then put the start index in the front of the array (which came through recursion)
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int AllIndexesRecursive( int input[], int size,
int x, int output[])
{
if (size == 0) {
return 0;
}
int smallAns = AllIndexesRecursive(input + 1,
size - 1, x, output);
if (input[0] == x) {
for ( int i = smallAns - 1; i >= 0; i--) {
output[i + 1] = output[i] + 1;
}
output[0] = 0;
smallAns++;
}
else {
for ( int i = smallAns - 1; i >= 0; i--) {
output[i] = output[i] + 1;
}
}
return smallAns;
}
void AllIndexes( int input[], int n, int x)
{
int output[n];
int size = AllIndexesRecursive(input, n,
x, output);
for ( int i = 0; i < size; i++) {
cout << output[i] << " " ;
}
}
int main()
{
int arr[] = { 1, 2, 3, 2, 2, 5 }, x = 2;
int n = sizeof (arr) / sizeof (arr[0]);
AllIndexes(arr, n, x);
return 0;
}
|
Java
public class GFG {
public int [] AllIndexesRecursive( int input[],
int x, int start)
{
if (start == input.length) {
int [] ans = new int [ 0 ];
return ans;
}
int [] smallIndex = AllIndexesRecursive(input, x,
start + 1 );
if (input[start] == x) {
int [] myAns = new int [smallIndex.length + 1 ];
myAns[ 0 ] = start;
for ( int i = 0 ; i < smallIndex.length; i++) {
myAns[i + 1 ] = smallIndex[i];
}
return myAns;
}
else {
return smallIndex;
}
}
public int [] AllIndexes( int input[], int x)
{
return AllIndexesRecursive(input, x, 0 );
}
public static void main(String args[])
{
GFG g = new GFG();
int arr[] = { 1 , 2 , 3 , 2 , 2 , 5 }, x = 2 ;
int output[] = g.AllIndexes(arr, x);
for ( int i = 0 ; i < output.length; i++) {
System.out.print(output[i] + " " );
}
}
}
|
Python3
def AllIndexesRecursive( input , x, start):
if (start = = len ( input )):
ans = []
return ans
smallIndex = AllIndexesRecursive( input , x,
start + 1 )
if ( input [start] = = x):
myAns = [ 0 for i in range ( len (smallIndex) + 1 )]
myAns[ 0 ] = start
for i in range ( len (smallIndex)):
myAns[i + 1 ] = smallIndex[i]
return myAns
else :
return smallIndex
def AllIndexes( input , x):
return AllIndexesRecursive( input , x, 0 )
arr = [ 1 , 2 , 3 , 2 , 2 , 5 ]
x = 2
output = AllIndexes(arr, x)
for i in output:
print (i, end = " " )
|
C#
using System;
class GFG
{
public int [] AllIndexesRecursive( int []input,
int x, int start)
{
if (start == input.Length)
{
int [] ans = new int [0];
return ans;
}
int [] smallIndex = AllIndexesRecursive(input, x,
start + 1);
if (input[start] == x)
{
int [] myAns = new int [smallIndex.Length + 1];
myAns[0] = start;
for ( int i = 0; i < smallIndex.Length; i++)
{
myAns[i + 1] = smallIndex[i];
}
return myAns;
}
else
{
return smallIndex;
}
}
public int [] AllIndexes( int []input, int x)
{
return AllIndexesRecursive(input, x, 0);
}
public static void Main()
{
GFG g = new GFG();
int []arr = { 1, 2, 3, 2, 2, 5 };
int x = 2;
int []output = g.AllIndexes(arr, x);
for ( int i = 0; i < output.Length; i++)
{
Console.Write(output[i] + " " );
}
}
}
|
Javascript
<script>
function AllIndexesRecursive(input, x, start)
{
if (start == input.length)
{
let ans = new Array(0);
return ans;
}
let smallIndex = AllIndexesRecursive(input, x, start + 1);
if (input[start] == x)
{
let myAns = new Array(smallIndex.length + 1);
myAns[0] = start;
for (let i = 0; i < smallIndex.length; i++)
{
myAns[i + 1] = smallIndex[i];
}
return myAns;
}
else
{
return smallIndex;
}
}
function AllIndexes(input, x)
{
return AllIndexesRecursive(input, x, 0);
}
let arr = [ 1, 2, 3, 2, 2, 5 ];
let x = 2;
let output = AllIndexes(arr, x);
for (let i = 0; i < output.length; i++)
{
document.write(output[i] + " " );
}
</script>
|
Simpler Recursive approach: (Traversing from the End)
- If the last index reaches the length of the array, then return empty array
- Else reduce the last index and pass the whole array to recursion.
- If the element at the last index is not equal to x then just simply return the answer which came from recursion.
- Else if the element at the last index is equal to x then simply insert the last element at the last index into index pointed by ans.
This avoids the complication of shifting all the elements by one index and also incrementing all the elements in the output array.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int AllIndexesRecursive( int input[], int size,
int x, int output[])
{
if (size == 0)
return 0;
int smallAns = AllIndexesRecursive(input, size - 1, x, output);
if (input[size - 1] == x)
{
output[smallAns++] = size - 1;
}
return smallAns;
}
void AllIndexes( int input[], int n, int x)
{
int output[n];
int size = AllIndexesRecursive(input, n,
x, output);
for ( int i = 0; i < size; i++) {
cout << output[i] << " " ;
}
}
int main()
{
int arr[] = { 1, 2, 3, 2, 2, 5 }, x = 2;
int n = sizeof (arr) / sizeof (arr[0]);
AllIndexes(arr, n, x);
return 0;
}
|
Java
public class Main
{
static int AllIndexesRecursive( int [] input, int size, int x, int [] output)
{
if (size == 0 )
return 0 ;
int smallAns = AllIndexesRecursive(input, size - 1 , x, output);
if (input[size - 1 ] == x)
{
output[smallAns++] = size - 1 ;
}
return smallAns;
}
static void AllIndexes( int [] input, int n, int x)
{
int [] output = new int [n];
int size = AllIndexesRecursive(input, n, x, output);
for ( int i = 0 ; i < size; i++) {
System.out.print(output[i] + " " );
}
}
public static void main(String[] args) {
int [] arr = { 1 , 2 , 3 , 2 , 2 , 5 };
int x = 2 ;
int n = arr.length;
AllIndexes(arr, n, x);
}
}
|
Python3
def AllIndexesRecursive( Input , size, x, output):
if size = = 0 :
return 0
smallAns = AllIndexesRecursive( Input , size - 1 , x, output)
if Input [size - 1 ] = = x:
output[smallAns] = size - 1
smallAns + = 1
return smallAns
def AllIndexes( Input , n, x):
output = [ 0 ] * n
size = AllIndexesRecursive( Input , n, x, output)
for i in range (size):
print (output[i], " ", end = " ")
arr = [ 1 , 2 , 3 , 2 , 2 , 5 ]
x = 2
n = len (arr)
AllIndexes(arr, n, x)
|
C#
using System;
using System.Collections.Generic;
class GFG {
static int AllIndexesRecursive( int [] input, int size, int x, int [] output)
{
if (size == 0)
return 0;
int smallAns = AllIndexesRecursive(input, size - 1, x, output);
if (input[size - 1] == x)
{
output[smallAns++] = size - 1;
}
return smallAns;
}
static void AllIndexes( int [] input, int n, int x)
{
int [] output = new int [n];
int size = AllIndexesRecursive(input, n, x, output);
for ( int i = 0; i < size; i++) {
Console.Write(output[i] + " " );
}
}
static void Main() {
int [] arr = { 1, 2, 3, 2, 2, 5 };
int x = 2;
int n = arr.Length;
AllIndexes(arr, n, x);
}
}
|
Javascript
<script>
function AllIndexesRecursive(input, size, x, output)
{
if (size == 0)
return 0;
let smallAns = AllIndexesRecursive(input, size - 1, x, output);
if (input[size - 1] == x)
{
output[smallAns++] = size - 1;
}
return smallAns;
}
function AllIndexes(input, n, x)
{
let output = new Array(n);
let size = AllIndexesRecursive(input, n, x, output);
for (let i = 0; i < size; i++) {
document.write(output[i] + " " );
}
}
let arr = [ 1, 2, 3, 2, 2, 5 ];
let x = 2;
let n = arr.length;
AllIndexes(arr, n, x);
</script>
|
Last Updated :
30 Nov, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...