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

Last Updated : 31 Mar, 2022

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 2^A[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]
X² 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).
7²= 49 , which is equal to (110001)₂ , 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. 2^a-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 = 2^a– 1 , then X * X = (2^a– 1) * (2^a– 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 <bits/stdc++.h>
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

<script>
        // JavaScript code for the 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
        function check(N, A) {
 
            // sorting the given array
            A.sort();
 
            // iterating through the array
            for (let 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
        let N = 4;
        let A = [4, 2, 3, 1];
        let answer = check(N, A);
        if (answer == true) {
            document.write("YES");
        }
        else {
            document.write("NO");
        }
 
   // This code is contributed by Potta Lokesh
    </script>