GeeksforGeeks App
Open App
Browser
Continue

# Find X in range [1, N] of bit size A[i] such that X^2’s bit size is not present in Array

Given an array A of N integers, where:

• Each element of array represents the bit size of an imaginary unsigned integer datatype.
• If ith imaginary datatype has a size of A[i] bits, then it can store integers from size 0 to 2A[i]-1.

The task is to check if there exist some integer X, such that:

• X is in range 1 to N
• X can fit in a datatype of bit size A[i]
• X2 does not fit in any other distinct datatype of bit size A[j] (A[i] < A[j]), not even with leading zeroes.

Examples:

Input: N = 4 , A = {4, 2, 3, 1}
Output: YES
Explanation: Let X = 7. Now, 7 = (111)2.
Clearly, 7 fits in 3 bits (3 is present in given array).
72 = 49 , which is equal to (110001)2 , which clearly doesn’t fits in 4 bits .

Input: N = 3 , A = {16, 64, 32}
Output: NO

Approach: The idea is to check if there is a pair (a, b) in the array, such that for the pair, there exist an integer X that fits in a bits and X*X does not fits in b bits.

Observations:

The best candidate for X is the largest possible number that fits in a bits. (i.e. 2a-1). The reason being that it increases the possibility of existence of such b, such that X*X does not fit in b bits.

If an integer X = 2a – 1 , then X * X = (2a – 1) * (2a – 1) , which would require 2*a  bits to be stored.

So, for each element A[i], it would be sufficient to check if smallest element greater than it is less than 2 * A[i] or not.

Based on above observation, following approach can be used to solve the problem:

• Sort the given array.
• Iterate through the array and check if any element is less than twice of its previous element.
• If so, return true.
• If iteration completes without returning true, then return false.

Following is the code based on above approach:

## C++

 `// C++ code for above approach` `#include ``using` `namespace` `std;` `// Function to check if there exist``// an integer X, such that X fits in bits``// represented by some array element and``// X*X does not fit in bits represented``// by some other element``bool` `check(``int` `N, ``int` `A[])``{` `    ``// sorting the given array``    ``sort(A, A + N);` `    ``// iterating through the array``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``// If an element is equal to the``        ``// last element simply skip that``        ``// case and continue the iteration``        ``// as the task is to find two``        ``// distinct integers such that``        ``// X fits in one them and``        ``// X*X does not fit in other``        ``if` `(A[i] == A[i - 1]) {``            ``continue``;``        ``}` `        ``// If the value of an element is``        ``// less than twice of its``        ``// previous element, that means``        ``// X would fit in previous element bits,``        ``// but X*X would not fit in current``        ``// element bits``        ``if` `(A[i] < 2 * A[i - 1]) {``            ``return` `true``;``        ``}``    ``}` `    ``// return false if iterations completes``    ``return` `false``;``}` `// Driver Code``int` `main()``{``    ``int` `N = 4;``    ``int` `A[] = { 4, 2, 3, 1 };``    ``bool` `answer = check(N, A);``    ``if` `(answer == ``true``) {``        ``cout << ``"YES"``;``    ``}``    ``else` `{``        ``cout << ``"NO"``;``    ``}``}`

## Java

 `// JAVA code for above approach``import` `java.util.*;``class` `GFG``{` `  ``// Function to check if there exist``  ``// an integer X, such that X fits in bits``  ``// represented by some array element and``  ``// X*X does not fit in bits represented``  ``// by some other element``  ``public` `static` `boolean` `check(``int` `N, ``int` `A[])``  ``{` `    ``// sorting the given array``    ``Arrays.sort(A);` `    ``// iterating through the array``    ``for` `(``int` `i = ``1``; i < N; i++) {` `      ``// If an element is equal to the``      ``// last element simply skip that``      ``// case and continue the iteration``      ``// as the task is to find two``      ``// distinct integers such that``      ``// X fits in one them and``      ``// X*X does not fit in other``      ``if` `(A[i] == A[i - ``1``]) {``        ``continue``;``      ``}` `      ``// If the value of an element is``      ``// less than twice of its``      ``// previous element, that means``      ``// X would fit in previous element bits,``      ``// but X*X would not fit in current``      ``// element bits``      ``if` `(A[i] < ``2` `* A[i - ``1``]) {``        ``return` `true``;``      ``}``    ``}` `    ``// return false if iterations completes``    ``return` `false``;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String args[])``  ``{``    ``int` `N = ``4``;``    ``int` `A[] = ``new` `int``[] { ``4``, ``2``, ``3``, ``1` `};``    ``boolean` `answer = check(N, A);``    ``if` `(answer == ``true``) {``      ``System.out.print(``"YES"``);``    ``}``    ``else` `{``      ``System.out.print(``"NO"``);``    ``}``  ``}``}` `// This code is contributed by Taranpreet`

## Python3

 `# Python code for above approach` `# Function to check if there exist``# an integer X, such that X fits in bits``# represented by some array element and``# X*X does not fit in bits represented``# by some other element``def` `check(N, A):` `    ``# sorting the given array``    ``A.sort()` `    ``# iterating through the array``    ``for` `i ``in` `range``(``1``,N):` `        ``# If an element is equal to the``        ``# last element simply skip that``        ``# case and continue the iteration``        ``# as the task is to find two``        ``# distinct integers such that``        ``# X fits in one them and``        ``# X*X does not fit in other``        ``if` `(A[i] ``=``=` `A[i ``-` `1``]):``            ``continue` `        ``# If the value of an element is``        ``# less than twice of its``        ``# previous element, that means``        ``# X would fit in previous element bits,``        ``# but X*X would not fit in current``        ``# element bits``        ``if` `(A[i] < ``2` `*` `A[i ``-` `1``]):``            ``return` `True` `    ``# return false if iterations completes``    ``return` `False` `# Driver Code``N ``=` `4``A ``=` `[ ``4``, ``2``, ``3``, ``1` `]``answer ``=` `check(N, A)``if` `(answer ``=``=` `True``):``    ``print``(``"YES"``)``else``:``    ``print``(``"NO"``)``    ` `# This code is contributed by shinjanpatra`

## C#

 `// C# code for above approach``using` `System;` `public` `class` `GFG{` `  ``// Function to check if there exist``  ``// an integer X, such that X fits in bits``  ``// represented by some array element and``  ``// X*X does not fit in bits represented``  ``// by some other element``  ``static` `bool` `check(``int` `N, ``int``[] A)``  ``{` `    ``// sorting the given array``    ``Array.Sort(A);` `    ``// iterating through the array``    ``for` `(``int` `i = 1; i < N; i++) {` `      ``// If an element is equal to the``      ``// last element simply skip that``      ``// case and continue the iteration``      ``// as the task is to find two``      ``// distinct integers such that``      ``// X fits in one them and``      ``// X*X does not fit in other``      ``if` `(A[i] == A[i - 1]) {``        ``continue``;``      ``}` `      ``// If the value of an element is``      ``// less than twice of its``      ``// previous element, that means``      ``// X would fit in previous element bits,``      ``// but X*X would not fit in current``      ``// element bits``      ``if` `(A[i] < 2 * A[i - 1]) {``        ``return` `true``;``      ``}``    ``}` `    ``// return false if iterations completes``    ``return` `false``;``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main (){` `    ``int` `N = 4;``    ``int``[] A = { 4, 2, 3, 1 };``    ``bool` `answer = check(N, A);``    ``if` `(answer == ``true``) {``      ``Console.Write(``"YES"``);``    ``}``    ``else` `{``      ``Console.Write(``"NO"``);``    ``}``  ``}``}` `// This code is contributed by hrithikgarg03188.`

## Javascript

 ``

Output

`YES`

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

My Personal Notes arrow_drop_up