Given an integer array **arr[]** of size **N**, and **Q** queries of the form of **{L, R, X}**, the task is to find the smallest index between **L** and **R** from the given array such that **arr[i] != X**. If no such index exists in array, print** -1**.

**Examples:**

Input:arr[] = {1, 2, 1, 1, 3, 5}, query[][] = {{0, 3, 1}, {1, 5, 2}, {2, 3, 1}}

Output:1

2

-1

Explanation:

The first index from 0 to 3 which does not contain 1 is 1

The first index from 1 to 5 which does not contain 2 is 2

All the indices from 2 to 3 contain 1. Hence, the answer is -1.

Input:arr[] = { 1, 2, 3, 2, 1, 1, 3, 5}, query[][] = { { 1, 4, 2 }, { 4, 5, 1 }, { 2, 3, 1 }, { 4, 6, 1 }}

Output:2

-1

2

6

**Naive Approach:**

Iterate over the range **[L, R]** for every query and check if any index exists which does not contain **X **. If such an index is found, print that index. Otherwise, print **-1**.

**Time Complexity:** O (N * Q)

**Auxiliary Space:** O (1)

**Efficient Approach:**

The above approach can be further optimized by precomputing and storing the index of the next element which is different from the current element, for every array element, which reduces computational complexity to O(1) for every query.

Follow the steps below to solve the problem:

- Create an auxiliary array
**nextpos[]**to store for every array element, the index of the next element which is different from the current element. - Now to process every query, firstly check if the value at index
**L**is not equal to**X**. If so, then the answer will be**L**. - Otherwise, it means that
**arr[L] = X**. In this case, we need to find the next index which has a value different from**arr[L]**. This can be obtained from**nextpos[L]**. - If
**nextpos[L]**is less than equal to**R**, then print nexpos[L]. - If neither of the above conditions are satisfied, then answer will be
**-1**.

**Illustration:**

arr[] = {1, 2, 1, 1, 3, 5}, query[][] = {{0, 3, 1}, {1, 5, 2}, {2, 3, 1}}

For the given arr[], nextpos[] array will be {1, 2, 4, 4, 5, 6}

For 1st Query: L = 0, R = 3, X = 1

arr[0] = 1 = X

nextpos[0] = 1( < 3)

Hence, the answer is 1.For the 2nd Query: L = 1, R = 5, X = 2

arr[1] = 2( = X)

nextpos[1] = 2( < 5)

Hence, the answer is 2.For the 3rd Query: L = 2, R = 3, X = 1

arr[2] = 1( = X)

nextpos[2] = 4( > R)

Hence, the answer is -1

Below is the implementation of the above approach:

## C++

`// C++ Program to find the smallest ` `// index in the array in the range ` `// [L, R] which does not contain X ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Precompute the index of next ` `// different element in the array ` `// for every array element ` `void` `precompute(` `int` `nextpos[], ` `int` `arr[], ` ` ` `int` `N) ` `{ ` ` ` `// Default value ` ` ` `nextpos[N - 1] = N; ` ` ` ` ` `for` `(` `int` `i = N - 2; i >= 0; i--) { ` ` ` ` ` `// Compute nextpos[i] using ` ` ` `// nextpos[i+1] ` ` ` `if` `(arr[i] == arr[i + 1]) ` ` ` `nextpos[i] = nextpos[i + 1]; ` ` ` `else` ` ` `nextpos[i] = i + 1; ` ` ` `} ` `} ` `// Function to return the smallest index ` `void` `findIndex(` `int` `query[][3], ` `int` `arr[], ` ` ` `int` `N, ` `int` `Q) ` `{ ` ` ` `// nextpos[i] will store the next ` ` ` `// position p where arr[p]!=arr[i] ` ` ` `int` `nextpos[N]; ` ` ` `precompute(nextpos, arr, N); ` ` ` ` ` `for` `(` `int` `i = 0; i < Q; i++) { ` ` ` `int` `l, r, x; ` ` ` `l = query[i][0]; ` ` ` `r = query[i][1]; ` ` ` `x = query[i][2]; ` ` ` ` ` `int` `ans = -1; ` ` ` ` ` `// If X is not present at l ` ` ` `if` `(arr[l] != x) ` ` ` `ans = l; ` ` ` ` ` `// Otherwise ` ` ` `else` `{ ` ` ` ` ` `// Find the index which ` ` ` `// stores a value different ` ` ` `// from X ` ` ` `int` `d = nextpos[l]; ` ` ` ` ` `// If that index is within ` ` ` `// the range ` ` ` `if` `(d <= r) ` ` ` `ans = d; ` ` ` `} ` ` ` `cout << ans << ` `"\n"` `; ` ` ` `} ` `} ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `N, Q; ` ` ` `N = 6; ` ` ` `Q = 3; ` ` ` `int` `arr[] = { 1, 2, 1, 1, 3, 5 }; ` ` ` `int` `query[Q][3] = { { 0, 3, 1 }, ` ` ` `{ 1, 5, 2 }, ` ` ` `{ 2, 3, 1 } }; ` ` ` ` ` `findIndex(query, arr, N, Q); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to find the smallest ` `// index in the array in the range ` `// [L, R] which does not contain X ` `class` `GFG{ ` ` ` `// Precompute the index of next ` `// different element in the array ` `// for every array element ` `static` `void` `precompute(` `int` `nextpos[], ` `int` `arr[], ` ` ` `int` `N) ` `{ ` ` ` ` ` `// Default value ` ` ` `nextpos[N - ` `1` `] = N; ` ` ` ` ` `for` `(` `int` `i = N - ` `2` `; i >= ` `0` `; i--) ` ` ` `{ ` ` ` ` ` `// Compute nextpos[i] using ` ` ` `// nextpos[i+1] ` ` ` `if` `(arr[i] == arr[i + ` `1` `]) ` ` ` `nextpos[i] = nextpos[i + ` `1` `]; ` ` ` `else` ` ` `nextpos[i] = i + ` `1` `; ` ` ` `} ` `} ` ` ` `// Function to return the smallest index ` `static` `void` `findIndex(` `int` `query[][], ` `int` `arr[], ` ` ` `int` `N, ` `int` `Q) ` `{ ` ` ` ` ` `// nextpos[i] will store the next ` ` ` `// position p where arr[p]!=arr[i] ` ` ` `int` `[]nextpos = ` `new` `int` `[N]; ` ` ` `precompute(nextpos, arr, N); ` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < Q; i++) ` ` ` `{ ` ` ` `int` `l, r, x; ` ` ` `l = query[i][` `0` `]; ` ` ` `r = query[i][` `1` `]; ` ` ` `x = query[i][` `2` `]; ` ` ` ` ` `int` `ans = -` `1` `; ` ` ` ` ` `// If X is not present at l ` ` ` `if` `(arr[l] != x) ` ` ` `ans = l; ` ` ` ` ` `// Otherwise ` ` ` `else` ` ` `{ ` ` ` ` ` `// Find the index which ` ` ` `// stores a value different ` ` ` `// from X ` ` ` `int` `d = nextpos[l]; ` ` ` ` ` `// If that index is within ` ` ` `// the range ` ` ` `if` `(d <= r) ` ` ` `ans = d; ` ` ` `} ` ` ` `System.out.print(ans + ` `"\n"` `); ` ` ` `} ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `N, Q; ` ` ` `N = ` `6` `; ` ` ` `Q = ` `3` `; ` ` ` ` ` `int` `arr[] = { ` `1` `, ` `2` `, ` `1` `, ` `1` `, ` `3` `, ` `5` `}; ` ` ` `int` `query[][] = { { ` `0` `, ` `3` `, ` `1` `}, ` ` ` `{ ` `1` `, ` `5` `, ` `2` `}, ` ` ` `{ ` `2` `, ` `3` `, ` `1` `} }; ` ` ` ` ` `findIndex(query, arr, N, Q); ` `} ` `} ` ` ` `// This code is contributed by Amit Katiyar ` |

*chevron_right*

*filter_none*

**Output:**

1 2 -1

**Time Complexity:** O(N)

**Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Sort Array such that smallest is at 0th index and next smallest it at last index and so on
- Check if every index i has an index j such that sum of elements in both directions are equal
- Number of permutations such that sum of elements at odd index and even index are equal
- Lexicographically Smallest Permutation of length N such that for exactly K indices, a[i] > a[i] + 1
- Order of indices which is lexicographically smallest and sum of elements is <= X
- Queries for elements having values within the range A to B in the given index range using Segment Tree
- Lexicographically smallest string which differs from given strings at exactly K indices
- Lexicographically smallest array formed by at most one swap for every pair of adjacent indices
- Count number of indices such that s[i] = s[i+1] : Range queries
- Largest subset having with sum less than equal to sum of respective indices
- Range sum queries for anticlockwise rotations of Array by K indices
- Count the pairs in an array such that the difference between them and their indices is equal
- Smallest index such that there are no 0 or 1 to its right
- Sum of elements till the smallest index such that there are no even numbers to its right
- Smallest index in the given array that satisfies the given condition
- Sort the array in a given index range
- Queries for bitwise AND in the index range [L, R] of the given array
- Queries for bitwise OR in the index range [L, R] of the given array
- Delete array element in given index range [L - R]
- Find element at given index after given range reversals

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.