Maximum OR - Practice Coding Problems

Maximum OR - Problem

You're given an array of integers and a limited number of doubling operations. Your goal is to strategically apply these operations to maximize the bitwise OR of all elements in the array.

In each operation, you can choose any element and multiply it by 2 (which is equivalent to left-shifting its bits). You have at most k operations to work with.

Example: Given nums = [12, 9] and k = 1, you could double 12 to get 24, resulting in 24 | 9 = 25, or double 9 to get 18, resulting in 12 | 18 = 30. The optimal choice gives you 30.

The key insight is that bitwise OR combines all the set bits from different numbers, so you want to maximize the highest bits possible.

Input & Output

example_1.py — Basic Case

$ Input: nums = [12, 9], k = 1

› Output: 30

💡 Note: We can apply the operation to nums[1] to make nums = [12, 18]. The maximum OR is 12 | 18 = 30.

example_2.py — Multiple Operations

$ Input: nums = [8, 1, 2], k = 2

› Output: 35

💡 Note: We can apply the operations twice to nums[0] to make nums = [32, 1, 2]. The maximum OR is 32 | 1 | 2 = 35.

example_3.py — Single Element

$ Input: nums = [7], k = 3

› Output: 56

💡 Note: With only one element, we apply all operations to it: 7 * 2^3 = 7 * 8 = 56.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 15
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Analyze Impact

For each tower, calculate what the skyline would look like if you used all doubling stones on it

Use Shortcuts

Use prefix and suffix skylines to avoid recalculating the entire view each time

Find Optimal

The tower that produces the highest combined skyline wins

Key Takeaway

🎯 Key Insight: Concentrating all k operations on a single element maximizes the OR result because it creates the highest possible bit positions, and OR operations preserve all existing bits while adding the new high-order bits.

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses prefix and suffix OR arrays to efficiently test concentrating all k operations on each element. The key insight is that it's always better to concentrate all operations on a single element rather than distribute them, as this maximizes the highest bit positions in the final OR result.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Prefix/Suffix Arrays (Optimal)	O(n)	O(n)	Use prefix and suffix OR arrays to efficiently test concentrating all operations on each element
Brute Force (Try All Distributions)	O((k+n)^n)	O(k)	Try all possible ways to distribute k operations among array elements

Greedy with Prefix/Suffix Arrays (Optimal) — Algorithm Steps

Build prefix OR array: prefix[i] = nums[0] | nums[1] | ... | nums[i]
Build suffix OR array: suffix[i] = nums[i] | nums[i+1] | ... | nums[n-1]
For each position i, calculate what happens if we apply all k operations to nums[i]
Use prefix[i-1] | (nums[i] * 2^k) | suffix[i+1] to get the result efficiently
Return the maximum result across all positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix

Create prefix[i] = nums[0] | nums[1] | ... | nums[i]

Build Suffix

Create suffix[i] = nums[i] | nums[i+1] | ... | nums[n-1]

Test Each Position

For each i, calculate prefix[i-1] | (nums[i] * 2^k) | suffix[i+1]

Find Maximum

Return the maximum OR value found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

long long maximumOr(int* nums, int numsSize, int k) {
    if (numsSize == 1) {
        return (long long)nums[0] * (1LL << k);
    }
    
    // Build prefix OR array
    long long* prefix = malloc(numsSize * sizeof(long long));
    prefix[0] = nums[0];
    for (int i = 1; i < numsSize; i++) {
        prefix[i] = prefix[i-1] | nums[i];
    }
    
    // Build suffix OR array
    long long* suffix = malloc(numsSize * sizeof(long long));
    suffix[numsSize-1] = nums[numsSize-1];
    for (int i = numsSize-2; i >= 0; i--) {
        suffix[i] = suffix[i+1] | nums[i];
    }
    
    long long maxOr = 0;
    
    // Try concentrating all operations on each element
    for (int i = 0; i < numsSize; i++) {
        long long currentOr = (long long)nums[i] * (1LL << k);
        
        // Add prefix OR (elements before i)
        if (i > 0) {
            currentOr |= prefix[i-1];
        }
        
        // Add suffix OR (elements after i)
        if (i < numsSize-1) {
            currentOr |= suffix[i+1];
        }
        
        if (currentOr > maxOr) {
            maxOr = currentOr;
        }
    }
    
    free(prefix);
    free(suffix);
    return maxOr;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build prefix array, single pass for suffix array, single pass to test each position

✓ Linear Growth

Space Complexity

O(n)

Space for prefix and suffix arrays

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

827 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy with Prefix/Suffix Arrays (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler