Given an array where difference between adjacent elements is 1, write an algorithm to search for an element in the array and return the position of the element (return the first occurrence).

**Examples :**

Let element to be searched be x Input: arr[] = {8, 7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3} x = 3 Output: Element 3 found at index 7 Input: arr[] = {1, 2, 3, 4, 5, 4} x = 5 Output: Element 5 found at index 4

A **Simple Approach** is to traverse the given array one by one and compare every element with given element ‘x’. If matches, then return index.

The above solution can be **Optimized **using the fact that difference between all adjacent elements is 1. The idea is to start comparing from the leftmost element and find the difference between current array element and x. Let this difference be ‘diff’. From the given property of array, we always know that x must be at-least ‘diff’ away, so instead of searching one by one, we jump ‘diff’.

Thanks to RajnishKrJha for suggesting this solution.

Below is the implementation of above idea.

## C++

`// C++ program to search an element in an array where ` `// difference between all elements is 1 ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// x is the element to be searched in arr[0..n-1] ` `int` `search(` `int` `arr[], ` `int` `n, ` `int` `x) ` `{ ` ` ` `// Traverse the given array starting from ` ` ` `// leftmost element ` ` ` `int` `i = 0; ` ` ` `while` `(i<n) ` ` ` `{ ` ` ` `// If x is found at index i ` ` ` `if` `(arr[i] == x) ` ` ` `return` `i; ` ` ` ` ` `// Jump the difference between current ` ` ` `// array element and x ` ` ` `i = i + ` `abs` `(arr[i]-x); ` ` ` `} ` ` ` ` ` `cout << ` `"number is not present!"` `; ` ` ` `return` `-1; ` `} ` ` ` `// Driver program to test above function ` `int` `main() ` `{ ` ` ` `int` `arr[] = {8 ,7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3 }; ` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]); ` ` ` `int` `x = 3; ` ` ` `cout << ` `"Element "` `<< x << ` `" is present at index "` ` ` `<< search(arr,n,3); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to search an element in an ` `// array where difference between all ` `// elements is 1 ` ` ` `import` `java.io.*; ` ` ` `class` `GFG { ` ` ` ` ` `// x is the element to be searched ` ` ` `// in arr[0..n-1] ` ` ` `static` `int` `search(` `int` `arr[], ` `int` `n, ` `int` `x) ` ` ` `{ ` ` ` ` ` `// Traverse the given array starting ` ` ` `// from leftmost element ` ` ` `int` `i = ` `0` `; ` ` ` `while` `(i < n) ` ` ` `{ ` ` ` ` ` `// If x is found at index i ` ` ` `if` `(arr[i] == x) ` ` ` `return` `i; ` ` ` ` ` `// Jump the difference between current ` ` ` `// array element and x ` ` ` `i = i + Math.abs(arr[i]-x); ` ` ` `} ` ` ` ` ` `System.out.println (` `"number is not"` `+ ` ` ` `" present!"` `); ` ` ` ` ` `return` `-` `1` `; ` ` ` `} ` ` ` ` ` `// Driver program to test above function ` ` ` `public` `static` `void` `main (String[] args) { ` ` ` ` ` `int` `arr[] = {` `8` `,` `7` `, ` `6` `, ` `7` `, ` `6` `, ` `5` `, ` `4` `, ` `3` `, ` ` ` `2` `, ` `3` `, ` `4` `, ` `3` `}; ` ` ` `int` `n = arr.length; ` ` ` `int` `x = ` `3` `; ` ` ` `System.out.println(` `"Element "` `+ x + ` ` ` `" is present at index "` ` ` `+ search(arr,n,` `3` `)); ` ` ` `} ` `} ` ` ` `//This code is contributed by vt_m. ` |

*chevron_right*

*filter_none*

## Python 3

`# Python 3 program to search an element ` `# in an array where difference between ` `# all elements is 1 ` ` ` `# x is the element to be searched in ` `# arr[0..n-1] ` `def` `search(arr, n, x): ` ` ` ` ` `# Traverse the given array starting ` ` ` `# from leftmost element ` ` ` `i ` `=` `0` ` ` `while` `(i < n): ` ` ` ` ` `# If x is found at index i ` ` ` `if` `(arr[i] ` `=` `=` `x): ` ` ` `return` `i ` ` ` ` ` `# Jump the difference between ` ` ` `# current array element and x ` ` ` `i ` `=` `i ` `+` `abs` `(arr[i] ` `-` `x) ` ` ` ` ` `print` `(` `"number is not present!"` `) ` ` ` `return` `-` `1` ` ` `# Driver program to test above function ` `arr ` `=` `[` `8` `,` `7` `, ` `6` `, ` `7` `, ` `6` `, ` `5` `, ` `4` `, ` `3` `, ` `2` `, ` `3` `, ` `4` `, ` `3` `] ` `n ` `=` `len` `(arr) ` `x ` `=` `3` `print` `(` `"Element"` `, x , ` `" is present at index "` `, ` ` ` `search(arr,n,` `3` `)) ` ` ` `# This code is contributed by Smitha ` |

*chevron_right*

*filter_none*

## C#

`// C# program to search an element ` `// in an array where difference ` `// between all elements is 1 ` `using` `System; ` ` ` `public` `class` `GFG ` `{ ` ` ` ` ` `// in arr[0..n-1] ` ` ` `static` `int` `search(` `int` `[]arr, ` `int` `n, ` ` ` `int` `x) ` ` ` `{ ` ` ` ` ` `// Traverse the given array starting ` ` ` `// from leftmost element ` ` ` `int` `i = 0; ` ` ` `while` `(i < n) ` ` ` `{ ` ` ` ` ` `// If x is found at index i ` ` ` `if` `(arr[i] == x) ` ` ` `return` `i; ` ` ` ` ` `// Jump the difference between ` ` ` `// current array element and x ` ` ` `i = i + Math.Abs(arr[i] - x); ` ` ` `} ` ` ` ` ` `Console.WriteLine (` `"number is not"` `+ ` ` ` `" present!"` `); ` ` ` ` ` `return` `-1; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` ` ` `int` `[]arr = {8 ,7, 6, 7, 6, 5, ` ` ` `4,3, 2, 3, 4, 3 }; ` ` ` `int` `n = arr.Length; ` ` ` `int` `x = 3; ` ` ` `Console.WriteLine(` `"Element "` `+ x + ` ` ` `" is present at index "` ` ` `+ search(arr, n, 3)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Sam007 ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP program to search an ` `// element in an array where ` `// difference between all ` `// elements is 1 ` ` ` `// x is the element to be ` `// searched in arr[0..n-1] ` `function` `search(` `$arr` `, ` `$n` `, ` `$x` `) ` `{ ` ` ` `// Traverse the given array ` ` ` `// starting from leftmost ` ` ` `// element ` ` ` `$i` `= 0; ` ` ` `while` `(` `$i` `< ` `$n` `) ` ` ` `{ ` ` ` `// If x is found at index i ` ` ` `if` `(` `$arr` `[` `$i` `] == ` `$x` `) ` ` ` `return` `$i` `; ` ` ` ` ` `// Jump the difference ` ` ` `// between current ` ` ` `// array element and x ` ` ` `$i` `= ` `$i` `+ ` `abs` `(` `$arr` `[` `$i` `] - ` `$x` `); ` ` ` `} ` ` ` ` ` `echo` `"number is not present!"` `; ` ` ` `return` `-1; ` `} ` ` ` `// Driver Code ` `$arr` `= ` `array` `(8 ,7, 6, 7, 6, 5, ` ` ` `4, 3, 2, 3, 4, 3); ` `$n` `= sizeof(` `$arr` `); ` `$x` `= 3; ` `echo` `"Element "` `, ` `$x` `, ` `" is present "` `, ` ` ` `"at index "` `, search(` `$arr` `, ` `$n` `, 3); ` ` ` `// This code is contributed ` `// by nitin mittal. ` `?> ` |

*chevron_right*

*filter_none*

**Output :**

Element 3 is present at index 7

**Searching in an array where adjacent differ by at most k**

This article is contributed by **Rishabh**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

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:

- Efficient search in an array where difference between adjacent is 1
- Maximize sum of given array by rearranging array such that the difference between adjacent elements is atmost 1
- Kth array element after M replacements of array elements by XOR of adjacent pairs
- Sort elements of an array in increasing order of absolute difference of adjacent elements
- Repeatedly search an element by doubling it after every successful search
- Maximise sum of absolute difference between adjacent elements in Array with sum K
- Minimize the maximum difference between adjacent elements in an array
- Maximum sum in an array such that every element has exactly one adjacent element to it
- Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
- Cost of rearranging the array such that no element exceeds the sum of its adjacent elements
- Maximum sum of Array formed by replacing each element with sum of adjacent elements
- Shuffle the position of each Array element by swapping adjacent elements
- Minimize sum of adjacent difference with removal of one element from array
- Maximum length subarray with difference between adjacent elements as either 0 or 1
- Cost of creating smallest subsequence with sum of difference between adjacent elements maximum
- Count of array elements which is smaller than both its adjacent elements
- Minimum absolute difference of adjacent elements in a circular array
- Sort array such that absolute difference of adjacent elements is in increasing order
- Rearrange array such that difference of adjacent elements is in descending order
- Missing occurrences of a number in an array such that maximum absolute difference of adjacent elements is minimum