Open in App
Not now

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

• Last Updated : 16 Mar, 2023

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
Related Articles