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

• Difficulty Level : Medium
• Last Updated : 11 Oct, 2021

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 = 88
Output: Yes 8
Explanation: 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 = 6
Output: No
Explanation: 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 elementsX 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.
• 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 ``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 comparisons``        ``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 "` `+ Comparisons);``        ``}``        ``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 comparisons``    ``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 comparisons``    ``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

 ``

Output:

`Yes 8`

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

My Personal Notes arrow_drop_up