Search an element in an array where difference between adjacent elements is 1
Last Updated :
08 Oct, 2023
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 xInput: arr[] = {8, 7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3}
x = 3
Output: Element 3 found at index 7Input: 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'.
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;
}
// This code is contributed by Aditya Kumar (adityakumar129)
// C program to search an element in an array where
// difference between all elements is 1
#include <stdio.h>
#include <stdlib.h>
// 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);
}
printf("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;
printf("Element %d is present at index ",
search(arr, n, 3));
return 0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
// 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.
# 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
// 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
<script>
// Javascript 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
let 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);
}
document.write("number is not present!");
return -1;
}
// Driver program
let arr = [8 ,7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3 ];
let n = arr.length;
let x = 3;
document.write( "Element " + x + " is present at index "
+ search(arr,n,3));
// This code is contributed by jana_sayantan.
</script>
<?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.
?>
OutputElement 3 is present at index 7
Time Complexity: O(n)
Auxiliary Space: O(1)
Searching in an array where adjacent differ by at most k
Approach#2: Using linear search
The approach of this code is linear search. It iterates through the array and checks if the current element is equal to the target element. If the target element is found, it returns the index of that element. If the target element is not found, it returns -1.
Algorithm
1. Traverse through the array starting from the first element.
2. Compare each element with the given element x.
3. If the element is found, return its index.
4. If the end of array is reached and the element is not found, return -1
C++
#include <iostream>
using namespace std;
// Function to find the first index of the
// element x in the array arr[]
int search_element(int arr[], int n, int x)
{
for (int i = 0; i < n; i++) {
if (arr[i] == x) {
return i;
}
}
return -1;
}
// Driver Code
int main()
{
int arr[] = { 8, 7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3 };
int x = 3;
int n = sizeof(arr) / sizeof(arr[0]);
cout << search_element(arr, n, x) << endl;
return 0;
}
public class Main {
// Function to find the first index of the element x in the array arr[]
static int searchElement(int[] arr, int x) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == x) {
return i;
// Return the index when the element is found
}
}
return -1;
// Return -1 if the element is not found in the array
}
public static void main(String[] args) {
int[] arr = { 8, 7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3 };
int x = 3;
int result = searchElement(arr, x);
System.out.println(result);
// Print the result
}
}
def search_element(arr, x):
n = len(arr)
for i in range(n):
if arr[i] == x:
return i
return -1
arr = [8, 7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3]
x = 3
print(search_element(arr, x))
using System;
class Program
{
// Function to find the first index of the element x in the array arr[]
static int SearchElement(int[] arr, int x)
{
for (int i = 0; i < arr.Length; i++)
{
if (arr[i] == x)
{
return i;
// Return the index when the element is found
}
}
return -1;
// Return -1 if the element is not found in the array
}
static void Main(string[] args)
{
int[] arr = { 8, 7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3 };
int x = 3;
int result = SearchElement(arr, x);
Console.WriteLine(result);
// Print the result
}
}
function search_element(arr, x) {
// Get the length of the array
let n = arr.length;
// Iterate over the array and check if the element is equal to x
for (let i = 0; i < n; i++) {
if (arr[i] == x) {
return i;
}
}
// If the element is not found, return -1
return -1;
}
let arr = [8, 7, 6, 7, 6, 5, 4, 3, 2, 3, 4, 3];
let x = 3;
console.log(search_element(arr, x));
Time Complexity: O(n) where n is the length of the array.
Auxiliary Space: O(1)
Similar Reads
Efficient search in an array where difference between adjacent is 1
Given an array of n integers. Each array element is obtained by adding either +1 or -1 to previous element i.e absolute difference between any two consecutive elements is 1. The task is to search an element index with the minimum number of comparison (less than simple element by element search). If
5 min read
Minimize maximum difference between adjacent elements possible by removing a single array element
Given an sorted array arr[] consisting of N elements, the task is to find the minimum of all maximum differences between adjacent elements of all arrays obtained by removal of any single array element. Examples: Input: arr[ ] = { 1, 3, 7, 8}Output: 5Explanation:All possible arrays after removing a s
6 min read
Sort elements of an array in increasing order of absolute difference of adjacent elements
Given an array arr[], the task is to arrange the array in such a way that the absolute difference between the adjacent elements is in increasing order. Examples: Input: arr[] = {8, 1, 2, 3, 0} Output: 2 3 1 8 0 Explanation: |2-3| = 1, |3-1| = 2, |1-8| = 7, |8-0| = 8 The absolute difference between t
5 min read
Sort an Array based on the absolute difference of adjacent elements
Given an array arr[] containing N integers, the task is to rearrange all the elements of array such that absolute difference between consecutive elements of the array are sorted in increasing order.Examples Input: arr[] = { 5, -2, 4, 8, 6, 5 } Output: 5 5 6 4 8 -2 Explanation: |5 - 5| = 0 |5 - 6| =
7 min read
Minimum difference between adjacent elements of array which contain elements from each row of a matrix
Given a matrix of N rows and M columns, the task is to find the minimum absolute difference between any of the two adjacent elements of an array of size N, which is created by picking one element from each row of the matrix. Note the element picked from row 1 will become arr[0], element picked from
10 min read
Maximum difference between first and last indexes of an element in array
Given an array of n integers. The task is to find the difference of first and last index of each distinct element so as to maximize the difference. Examples: Input : {2, 1, 3, 4, 2, 1, 5, 1, 7} Output : 6 Element 1 has its first index = 1 and last index = 7 Difference = 7 - 1 = 6 Other elements have
6 min read
Generate N-size Array with equal difference of adjacent elements containing given numbers A and B
Given two natural numbers A and B (B >= A) and an integer N, your task is to generate an array of natural numbers in non-decreasing order, such that both A and B must be part of the array and the difference between every pair of adjacent elements is the same keeping the maximum element of the arr
8 min read
Queries to find minimum absolute difference between adjacent array elements in given ranges
Given an array arr[] consisting of N integers and an array query[] consisting of queries of the form {L, R}, the task for each query is to find the minimum of the absolute difference between adjacent elements over the range [L, R]. Examples: Input: arr[] = {2, 6, 1, 8, 3, 4}, query[] = {{0, 3}, {1,
15+ min read
Split array into K subarrays with minimum sum of absolute difference between adjacent elements
Given an array, arr[] of size N and an integer K, the task is to split the array into K subarrays minimizing the sum of absolute difference between adjacent elements of each subarray. Examples: Input: arr[] = {1, 3, -2, 5, -1}, K = 2Output: 13Explanation: Split the array into following 2 subarrays:
8 min read
Searching in an array where adjacent differ by at most k
A step array is an array of integers where each element has a difference of at most k with its neighbor. Given a key x, we need to find the index value of x if multiple-element exist to return the first occurrence of the key.Examples: Input : arr[] = {4, 5, 6, 7, 6} k = 1 x = 6 Output : 2 The first
7 min read