# Check if an element is present in an array using at most floor(N / 2) + 2 comparisons

Given an array **A[]** of size **N **and an integer **X**, the task is to check if **X** exists in **A[]** with no more than **floor(N/2) + 2** comparisons. **Note:** For any index **i**, **(i < N)** or **(A[i] == X)** are considered as separate comparisons.

**Examples:**

Input:A[] = {-3, 5, 11, 3, 100, 2, 88, 22, 7, 900, 23, 4, 1}, X = 88Output:Yes 8Explanation:X = 88 exists in the given array, A[]and is detected with 8 comparisons.

Input:A[]= {-3, 5, 11, 3, 100, 2, 88, 22, 7, 900, 23, 4, 1}, X = 6Output:NoExplanation:X = 6 doesn’t exist in the given array, A[].

**Approach:** Follow the steps to solve the problem:

- Initialize a variable, say
**T**as**1**, to store product of all array elements –**X**i.e**(A[i] – X)** - Initialize a variable, say
**comparisons**as**0**, to store the number of comparisons required. - Initialize pointer,
**i**as**0**to traverse the array. - If the value of N is odd, increment
**comparisons**by 1 because parity of N is checked and update**T**to**T * (A[0] – X)**and**i**to**1**. - Therefore, the number of elements in the range
**[i, N – 1]**i.e**N – i**is always even. - Traverse the array,
**A[]**in range**[i, N-1]**and perform the following steps:- Update the value of
**T**to**T * (A[i] – X) * (A[i + 1] – X)**. - Update
**i**to**i + 2**and increment**comparisons**by**1**because condition**i < N**is checked.

- Update the value of
- If the value of
**T**is**0**, increment**comparisons**by**1**because the equality of**T**is compared. Therefore,**X**exists in**A[]**and print**“Yes”**and number of**comparisons**. - Otherwise, Print
**“No”**as the result. - The algorithm guarantees that the number of
**comparisons â‰¤ floor(N / 2) + 2**.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check whether X` `// is present in the array A[]` `void` `findElement(` `int` `A[], ` `int` `N, ` `int` `X)` `{` ` ` `// Initialise a pointer` ` ` `int` `i = 0;` ` ` `// Store the number` ` ` `// of comparisons` ` ` `int` `Comparisons = 0;` ` ` `// Variable to store product` ` ` `int` `T = 1;` ` ` `string Found = ` `"No"` `;` ` ` `// Check is N is odd` ` ` `Comparisons++;` ` ` `if` `(N % 2 == 1) {` ` ` `// Update i and T` ` ` `i = 1;` ` ` `T *= (A[0] - X);` ` ` `}` ` ` `// Traverse the array` ` ` `for` `(; i < N; i += 2) {` ` ` `// Check if i < N` ` ` `Comparisons += 1;` ` ` `// Update T` ` ` `T *= (A[i] - X);` ` ` `T *= (A[i + 1] - X);` ` ` `}` ` ` `// Check if T is equal to 0` ` ` `Comparisons += 1;` ` ` `if` `(T == 0) {` ` ` `cout << ` `"Yes "` `<< Comparisons;` ` ` `}` ` ` `else` `{` ` ` `cout << ` `"No"` `;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given Input` ` ` `int` `A[] = { -3, 5, 11, 3, 100, 2, 88,` ` ` `22, 7, 900, 23, 4, 1 };` ` ` `int` `N = ` `sizeof` `(A) / ` `sizeof` `(A[0]);` ` ` `int` `X = 1;` ` ` `// Function Call` ` ` `findElement(A, N, X);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `public` `class` `GFG {` ` ` `// Function to check whether X` ` ` `// is present in the array A[]` ` ` `static` `void` `findElement(` `int` `[] A, ` `int` `N, ` `int` `X)` ` ` `{` ` ` `// Initialise a pointer` ` ` `int` `i = ` `0` `;` ` ` `// Store the number` ` ` `// of comparisions` ` ` `int` `Comparisons = ` `0` `;` ` ` `// Variable to store product` ` ` `int` `T = ` `1` `;` ` ` `// Check is N is odd` ` ` `Comparisons++;` ` ` `if` `(N % ` `2` `== ` `1` `) {` ` ` `// Update i and T` ` ` `i = ` `1` `;` ` ` `T *= (A[` `0` `] - X);` ` ` `}` ` ` `// Traverse the array` ` ` `for` `(; i < N; i += ` `2` `) {` ` ` `// Check if i < N` ` ` `Comparisons += ` `1` `;` ` ` `// Update T` ` ` `T *= (A[i] - X);` ` ` `T *= (A[i + ` `1` `] - X);` ` ` `}` ` ` `// Check if T is equal to 0` ` ` `Comparisons += ` `1` `;` ` ` `if` `(T == ` `0` `) {` ` ` `System.out.println(` `"Yes "` `+ Comparisions);` ` ` `}` ` ` `else` `{` ` ` `System.out.println(` `"No"` `);` ` ` `}` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `// Given Input` ` ` `// Given Input` ` ` `int` `[] A = { -` `3` `, ` `5` `, ` `11` `, ` `3` `, ` `100` `, ` `2` `, ` `88` `,` ` ` `22` `, ` `7` `, ` `900` `, ` `23` `, ` `4` `, ` `1` `};` ` ` `int` `N = A.length;` ` ` `int` `X = ` `1` `;` ` ` `// Function Call` ` ` `findElement(A, N, X);` ` ` `}` `}` `// This code is contributed by abhinavjain194` |

## Python3

`# Python 3 program for the above approach` `# Function to check whether X` `# is present in the array A[]` `def` `findElement(A, N, X):` ` ` ` ` `# Initialise a pointer` ` ` `i ` `=` `0` ` ` `# Store the number` ` ` `# of comparisions` ` ` `Comparisons ` `=` `0` ` ` `# Variable to store product` ` ` `T ` `=` `1` ` ` `Found ` `=` `"No"` ` ` `# Check is N is odd` ` ` `Comparisons ` `+` `=` `1` ` ` `if` `(N ` `%` `2` `=` `=` `1` `):` ` ` `# Update i and T` ` ` `i ` `=` `1` ` ` `T ` `*` `=` `(A[` `0` `] ` `-` `X)` ` ` `# Traverse the array` ` ` `while` `(i< N):` ` ` ` ` `# Check if i < N` ` ` `Comparisons ` `+` `=` `1` ` ` `# Update T` ` ` `T ` `*` `=` `(A[i] ` `-` `X)` ` ` `T ` `*` `=` `(A[i ` `+` `1` `] ` `-` `X)` ` ` `i ` `+` `=` `2` ` ` `# Check if T is equal to 0` ` ` `Comparisons ` `+` `=` `1` ` ` `if` `(T ` `=` `=` `0` `):` ` ` `print` `(` `"Yes"` `,Comparisons)` ` ` `else` `:` ` ` `print` `(` `"No"` `)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Given Input` ` ` `A ` `=` `[` `-` `3` `, ` `5` `, ` `11` `, ` `3` `, ` `100` `, ` `2` `, ` `88` `, ` `22` `, ` `7` `, ` `900` `, ` `23` `, ` `4` `, ` `1` `]` ` ` `N ` `=` `len` `(A)` ` ` `X ` `=` `1` ` ` `# Function Call` ` ` `findElement(A, N, X)` ` ` ` ` `# This code is contributed by bgangwar59.` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` ` ` `// Function to check whether X` `// is present in the array A[]` `static` `void` `findElement(` `int` `[] A, ` `int` `N, ` `int` `X)` `{` ` ` ` ` `// Initialise a pointer` ` ` `int` `i = 0;` ` ` `// Store the number` ` ` `// of comparisions` ` ` `int` `Comparisons = 0;` ` ` `// Variable to store product` ` ` `int` `T = 1;` ` ` `// Check is N is odd` ` ` `Comparisons++;` ` ` `if` `(N % 2 == 1)` ` ` `{` ` ` ` ` `// Update i and T` ` ` `i = 1;` ` ` `T *= (A[0] - X);` ` ` `}` ` ` `// Traverse the array` ` ` `for` `(; i < N; i += 2)` ` ` `{` ` ` ` ` `// Check if i < N` ` ` `Comparisons += 1;` ` ` `// Update T` ` ` `T *= (A[i] - X);` ` ` `T *= (A[i + 1] - X);` ` ` `}` ` ` `// Check if T is equal to 0` ` ` `Comparions += 1;` ` ` ` ` `if` `(T == 0)` ` ` `{` ` ` `Console.Write(` `"Yes "` `+ Comparisons);` ` ` `}` ` ` `else` ` ` `{` ` ` `Console.Write(` `"No"` `);` ` ` `}` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` ` ` `// Given Input` ` ` `int` `[] A = { -3, 5, 11, 3, 100, 2, 88,` ` ` `22, 7, 900, 23, 4, 1 };` ` ` `int` `N = A.Length;` ` ` `int` `X = 1;` ` ` `// Function Call` ` ` `findElement(A, N, X);` `}` `}` `// This code is contributed by ukasp` |

## Javascript

`<script>` `// JavaScript program for the above approach` `// Function to check whether X` `// is present in the array A[]` `function` `findElement(A, N, X)` `{` ` ` `// Initialise a pointer` ` ` `var` `i = 0;` ` ` `// Store the number` ` ` `// of comparisons` ` ` `var` `Comparisons = 0;` ` ` `// Variable to store product` ` ` `var` `T = 1;` ` ` `var` `Found = ` `"No"` `;` ` ` `// Check is N is odd` ` ` `Comparisons += 1;` ` ` `if` `(N % 2 == 1) {` ` ` `// Update i and T` ` ` `i = 1;` ` ` `T *= (A[0] - X);` ` ` `}` ` ` `// Traverse the array` ` ` `for` `(; i < N; i += 2) {` ` ` `// Check if i < N` ` ` `Comparisons += 1;` ` ` `// Update T` ` ` `T *= (A[i] - X);` ` ` `T *= (A[i + 1] - X);` ` ` `}` ` ` `// Check if T is equal to 0` ` ` `Comparisons += 1;` ` ` `if` `(T == 0) {` ` ` `document.write(` `"Yes "` `+ Comparisons);` ` ` `}` ` ` `else` `{` ` ` `document.write(` `"No"` `);` ` ` `}` `}` `// Driver Code` ` ` `// Given Input` ` ` `var` `A = [-3, 5, 11, 3, 100, 2, 88,` ` ` `22, 7, 900, 23, 4, 1];` ` ` `var` `N = A.length;` ` ` `var` `X = 1;` ` ` `// Function Call` ` ` `findElement(A, N, X);` `</script>` |

**Output:**

Yes 8

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**