Bitwise OR of Adjacent Elements

Easy

Asked by:

31 views

Topics:

ArraysBit Manipulation

You are given an array of non-negative integers, nums. In one operation, you can choose two adjacent elements and replace them with their bitwise OR. Your task is to find the maximum possible value of the bitwise OR of all the elements in the array after performing any number of these operations.

For example, if nums = [1, 2, 3, 4, 5], you can choose to replace 1 and 2 with 1 | 2 = 3, so the array becomes [3, 3, 4, 5]. You can repeat this operation as many times as you want.

Example 1:

Input: nums = [1, 2, 3, 4, 5]
Output: 7
Explanation: One way to achieve this is:
- Replace 1 and 2 with (1 | 2) = 3.  nums becomes [3, 3, 4, 5].
- Replace 3 and 3 with (3 | 3) = 3.  nums becomes [3, 4, 5].
- Replace 3 and 4 with (3 | 4) = 7.  nums becomes [7, 5].
- Replace 7 and 5 with (7 | 5) = 7.  nums becomes [7].
Thus, the bitwise OR of all elements is 7.

Example 2:

Input: nums = [4, 6, 2]
Output: 6
Explanation: One way to achieve this is:
- Replace 4 and 6 with (4 | 6) = 6. nums becomes [6, 2].
- Replace 6 and 2 with (6 | 2) = 6. nums becomes [6].
Thus, the bitwise OR of all elements is 6.

Constraints:

1 <= nums.length <= 10⁵
0 <= nums[i] <= 10⁹

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What is the maximum size of the input array `nums`?
Can the input array `nums` contain negative integers?
What should I return if the input array `nums` is empty or null?
Are the integers in the input array 32-bit, or is there a different limit on their size?
Could you provide a couple of example inputs and their corresponding outputs to illustrate the expected behavior?

Brute Force Solution

Approach

The brute force method for this problem involves looking at all possible combinations of how the numbers can be combined with their neighbors. We calculate the result for each combination and then compare these results to find the one we want.

Here's how the algorithm would work step-by-step:

Consider each number in the list.
For each number, look at the number next to it and combine them using a special operation (the bitwise OR).
Replace the original number with this new combined value.
Now, do this for every pair of adjacent numbers in the list, one pair at a time.
Store all of the different lists you can create by combining adjacent numbers in all the possible ways.
Finally, go through all of the stored lists, and pick the one that best fits what we're looking for in the problem (for example, the list with the smallest sum).

Code Implementation

def bitwise_or_of_adjacent_elements_brute_force(numbers):
    # Handle edge case of empty list
    if not numbers:
        return 0

    modified_numbers = []
    # Iterate through the list to combine adjacent elements
    for index in range(len(numbers) - 1):
        # Calculate the bitwise OR of adjacent elements.
        bitwise_or_result = numbers[index] | numbers[index + 1]

        modified_numbers.append(bitwise_or_result)

    # Handle the case where the modified list is empty.
    if not modified_numbers:
        return 0

    final_result = 0
    # Accumulate the bitwise OR of the modified numbers.
    for number in modified_numbers:
        final_result |= number

    return final_result

Big(O) Analysis

Time Complexity

O(2^n) – The algorithm explores all possible combinations of performing a bitwise OR on adjacent elements. For an array of size n, each element can either be ORed with its neighbor or not, resulting in 2^(n-1) possible combinations (since there are n-1 adjacent pairs). Evaluating the result of each of these combinations takes O(n) time to create a new list and process it. Therefore, the overall time complexity is O(n * 2^(n-1)), which simplifies to O(2^n) as 2^(n-1) is proportional to 2^n and the multiplication factor of n becomes insignificant as n grows.

Space Complexity

O(2^N * N) – The algorithm stores all possible lists created by combining adjacent numbers using the bitwise OR operation. In the worst-case scenario, where each number can potentially be combined with its neighbor in different combinations, the number of possible lists grows exponentially with the input size N. Each of these lists also requires space proportional to N to store the combined values. Therefore, the auxiliary space is O(2^N * N), reflecting the exponential growth in the number of lists and the linear space required for each list.

Optimal Solution

Approach

The problem asks us to compute a new sequence where each element is the bitwise OR of adjacent elements in the original sequence. We can solve this efficiently by creating a new sequence and populating it based on this rule. This avoids unnecessary recalculations and directly computes the desired result.

Here's how the algorithm would work step-by-step:

Create a new, empty sequence that will hold our results. It should be the same length as the original sequence.
For each position in the new sequence (except the first and last), calculate the bitwise OR of the element at the same position in the original sequence and its neighbors.
Place the result of the bitwise OR operation in the corresponding position in the new sequence.
For the first position in the new sequence, calculate the bitwise OR of the first two numbers in the original sequence.
For the last position in the new sequence, calculate the bitwise OR of the last two numbers in the original sequence.
The new sequence now contains the bitwise OR of all adjacent elements.

Code Implementation

def bitwise_or_of_adjacent_elements(sequence_of_numbers):
    if not sequence_of_numbers:
        return []

    bitwise_or_result = sequence_of_numbers[0]
    # Calculate the bitwise OR of all elements.
    for number in sequence_of_numbers:
        bitwise_or_result |= number

    result_sequence = [bitwise_or_result] * len(sequence_of_numbers)
    # The result is a sequence where each element is the bitwise OR of all numbers.

    return result_sequence

Big(O) Analysis

Time Complexity

O(n) – The algorithm iterates through the input sequence once to create the output sequence. For each element in the input sequence of size n, it performs a constant number of bitwise OR operations involving adjacent elements. Therefore, the time complexity is directly proportional to the size of the input sequence, resulting in O(n) time complexity.

Space Complexity

O(N) – The algorithm creates a new sequence (list or array) to store the results of the bitwise OR operations. This new sequence has the same length as the original input sequence. Therefore, the auxiliary space required scales linearly with the input size N, where N is the number of elements in the original sequence, leading to a space complexity of O(N).

Edge Cases

Case	How to Handle
Null input array	Return an empty array or throw an IllegalArgumentException as appropriate for the language.
Empty input array	Return an empty array as there are no elements to process.
Input array with only one element	Return an array of size 1 where the only element is the bitwise OR of 0 and 0, which is 0.
Input array with two elements	Calculate result[0] as 0 \| nums[1] and result[1] as nums[0] \| 0.
Large input array (scalability)	Ensure the solution uses O(n) time and space to avoid timeouts with large inputs.
Input array contains only zeros	The result array will also contain only zeros, which is a valid outcome.
Input array contains maximum integer values	Ensure that bitwise OR operations do not cause integer overflow issues.
Array with all elements equal to the same value	The result array will contain the bitwise OR of 0 and that value, which will be that value.

Null input array

How to Handle:

Return an empty array or throw an IllegalArgumentException as appropriate for the language.

Empty input array

How to Handle:

Return an empty array as there are no elements to process.

Input array with only one element

How to Handle:

Return an array of size 1 where the only element is the bitwise OR of 0 and 0, which is 0.

Input array with two elements

How to Handle:

Calculate result[0] as 0 | nums[1] and result[1] as nums[0] | 0.

Large input array (scalability)

How to Handle:

Ensure the solution uses O(n) time and space to avoid timeouts with large inputs.

Input array contains only zeros

How to Handle:

The result array will also contain only zeros, which is a valid outcome.

Input array contains maximum integer values

How to Handle:

Ensure that bitwise OR operations do not cause integer overflow issues.

Array with all elements equal to the same value

How to Handle:

The result array will contain the bitwise OR of 0 and that value, which will be that value.