GeeksforGeeks App
Open App
Browser
Continue

# Check if each possible Subarray has a different bitwise OR value

Given an array X[] of length N, the task is to verify whether each possible subarray has a different bitwise OR value. If possible then return YES else NO

Examples:

Input: N = 2, X[] = {1, 2}
Output: YES
Explanation: All the possible sub-arrays are {1}, {2}, {1, 2} having OR values as 1, 2 and 3 respectively. All possible sub-arrays have different OR values. Therefore, output is YES.

Input: N = 4, X[]={5, 6, 3, 4}
Output: NO
Explanation: It can be verified that all the possible sub-arrays don’t have distinct bitwise OR value.

Approach: Implement the idea below to solve the problem

The problem is observation based and can be solved by using some bitwise concept observations. This problem requires HashSet data-structure.

Steps were taken to solve the problem:

• Create a boolean flag and initialize it as equal to false.
• If N ≥ 100, then output NO else follow the below-mentioned steps:
• Initialize the HashSet let’s say set.
• Run two nested loops for all the possible sub-arrays and initialize their OR value into the set.
• If set.size() == (N*(N+1)/2) then mark the flag as true else mark false.
• If the flag is true return YES else return NO.

Below is the code to implement the above approach:

## C++

 `// C++ code to implement the approach``#include ``using` `namespace` `std;` `// Function for verifying the array``string Is_Possible(``int` `N, ``long` `X[])``{` `    ``// Flag initialized for final output``    ``bool` `flag = ``false``;` `    ``// Condition at which array will``    ``// not be verified``    ``if` `(N >= 100)``        ``cout << ``"NO"` `<< endl;``    ``else` `{` `        ``// Set initialized``        ``set <``long``> s;` `        ``// Loop for initializing OR``        ``// values into Set``        ``for` `(``int` `i = 0; i < N; i++) {``            ``long` `x = 0;``            ``for` `(``int` `j = i; j < N; j++) {``                ``x = x | X[j];``                ``s.insert(x);``            ``}``        ``}` `        ``// Checking for the necessary``        ``// conditions and Marking``        ``// flag for output``        ``if` `(s.size() == (N * (N + 1) / 2))``            ``flag = ``true``;``        ``else``            ``flag = ``false``;``    ``}` `    ``// Returning answer as output``    ``return` `flag == ``true` `? ``"YES"` `: ``"NO"``;``}` `int` `main() {` `     ``// Input values``    ``int` `N = 2;``    ``long` `X[] = { 1, 2 };` `    ``// Function call``    ``cout << Is_Possible(N, X) << endl;``}`

## Java

 `// Java code to implement the approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `Main {` `    ``// Driver Function``    ``public` `static` `void` `main(String[] args)``        ``throws` `java.lang.Exception``    ``{``        ``// Input values``        ``int` `N = ``2``;``        ``long` `X[] = { ``1``, ``2` `};` `        ``// Function call``        ``System.out.println(Is_Possible(N, X));``    ``}` `    ``// Function for verifying the array``    ``static` `String Is_Possible(``int` `N, ``long` `X[])``    ``{` `        ``// Flag initialized for``        ``// final output``        ``boolean` `flag = ``false``;` `        ``// Condition at which array will``        ``// not be verified``        ``if` `(N >= ``100``)``            ``System.out.println(``"NO"``);``        ``else` `{` `            ``// HashSet initialized``            ``Set set = ``new` `HashSet<>();` `            ``// Loop for initializing OR``            ``// values into HashSet``            ``for` `(``int` `i = ``0``; i < N; i++) {``                ``long` `x = ``0``;``                ``for` `(``int` `j = i; j < N; j++) {``                    ``x = x | X[j];``                    ``set.add(x);``                ``}``            ``}` `            ``// Checking for the necessary``            ``// conditions and Marking``            ``// flag for output``            ``if` `(set.size() == (N * (N + ``1``) / ``2``))``                ``flag = ``true``;``            ``else``                ``flag = ``false``;``        ``}` `        ``// Returning answer as output``        ``return` `flag == ``true` `? ``"YES"` `: ``"NO"``;``    ``}``}`

## Python3

 `# Python code to implement the approach` `# Function for verifying the array``def` `Is_Possible(N, X):``    ` `    ``# Flag initialized for final output``    ``flag ``=` `False``    ` `    ``# Condition at which array will``    ``# not be verified``    ``if` `N >``=` `100``:``        ``return` `"NO"``    ``else``:``    ` `        ``# Set initialized``        ``s ``=` `set``()``    ` `        ``# Loop for initializing OR``        ``# values into Set``        ``for` `i ``in` `range``(N):``            ``x ``=` `0``            ``for` `j ``in` `range``(i, N):``                ``x ``=` `x | X[j]``                ``s.add(x)``    ` `        ``# Checking for the necessary``        ``# conditions and marking``        ``# flag for output``        ``if` `len``(s) ``=``=` `(N ``*` `(N ``+` `1``) ``/``/` `2``):``            ``flag ``=` `True``        ``else``:``            ``flag ``=` `False``    ` `    ``# Returning answer as output``    ``return` `"YES"` `if` `flag ``else` `"NO"``    ` `# Driver code``N ``=` `2``X ``=` `[``1``, ``2``]` `# Function call``print``(Is_Possible(N, X))` `# This code is contributed by prasad264`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `MainClass {` `    ``// Driver Function``    ``static` `void` `Main(``string``[] args) {``        ``// Input values``        ``int` `N = 2;``        ``long``[] X = ``new` `long``[] { 1, 2 };` `        ``// Function call``        ``Console.WriteLine(Is_Possible(N, X));``    ``}` `    ``// Function for verifying the array``    ``static` `string` `Is_Possible(``int` `N, ``long``[] X) {``        ``// Flag initialized for``        ``// final output``        ``bool` `flag = ``false``;` `        ``// Condition at which array will``        ``// not be verified``        ``if` `(N >= 100)``            ``Console.WriteLine(``"NO"``);``        ``else` `{` `            ``// HashSet initialized``            ``HashSet<``long``> ``set` `= ``new` `HashSet<``long``>();` `            ``// Loop for initializing OR``            ``// values into HashSet``            ``for` `(``int` `i = 0; i < N; i++) {``                ``long` `x = 0;``                ``for` `(``int` `j = i; j < N; j++) {``                    ``x = x | X[j];``                    ``set``.Add(x);``                ``}``            ``}` `            ``// Checking for the necessary``            ``// conditions and Marking``            ``// flag for output``            ``if` `(``set``.Count == (N * (N + 1) / 2))``                ``flag = ``true``;``            ``else``                ``flag = ``false``;``        ``}` `        ``// Returning answer as output``        ``return` `flag == ``true` `? ``"YES"` `: ``"NO"``;``    ``}``}`

## Javascript

 `// JavaScript code to implement the approach` `// Function for verifying the array``function` `Is_Possible(N, X)``{``    ``// Flag initialized for final output``    ``let flag = ``false``;` `    ``// Condition at which array will``    ``// not be verified``    ``if` `(N >= 100)``        ``console.log(``"NO"``);``    ``else` `{` `        ``// Set initialized``        ``const s = ``new` `Set();` `        ``// Loop for initializing OR``        ``// values into Set``        ``for` `(let i = 0; i < N; i++) {``            ``let x = 0;``            ``for` `(let j = i; j < N; j++) {``                ``x = x | X[j];``                ``s.add(x);``            ``}``        ``}` `        ``// Checking for the necessary``        ``// conditions and Marking``        ``// flag for output``        ``if` `(s.size == (N * (N + 1) / 2))``            ``flag = ``true``;``        ``else``            ``flag = ``false``;``    ``}` `    ``// Returning answer as output``    ``return` `flag == ``true` `? ``"YES"` `: ``"NO"``;``}` `// Input values``const N = 2;``const X = [ 1, 2 ];` `// Function call``console.log(Is_Possible(N, X));`

Output

`YES`

Time Complexity: O(N)
Auxiliary Space: O(N), As HashSet is used to store elements.

My Personal Notes arrow_drop_up