Maximum OR

Maximum OR - Problem

You are given a 0-indexed integer array nums of length n and an integer k. In an operation, you can choose an element and multiply it by 2.

Return the maximum possible value of nums[0] | nums[1] | ... | nums[n - 1] that can be obtained after applying the operation on nums at most k times.

Note that a | b denotes the bitwise OR between two integers a and b.

Input & Output

Example 1 — Basic Case

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

› Output: 15

💡 Note: We can apply operations on nums[0] twice: 3 → 6 → 12. Then nums becomes [12,2,1] and the OR is 12|2|1 = 15.

Example 2 — Single Element

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

› Output: 16

💡 Note: With only one element, apply all operations: 2 → 4 → 8 → 16. The OR is just 16.

Example 3 — Zero Operations

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

› Output: 7

💡 Note: No operations allowed, so OR is 7|3|5 = 7.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 15

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Meta 32 M Microsoft 28

The key insight is that to maximize bitwise OR, we should concentrate all k operations on a single element to maximize the highest possible bit. The optimal approach uses prefix and suffix OR arrays to efficiently test each position. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(n^k × n) Space: O(k)

Generate all possible ways to distribute k multiplications among array elements. For each distribution, calculate the resulting OR value and keep track of the maximum.

Greedy with Prefix/Suffix Optimization

⏱️ Time: O(n) Space: O(n)

Use prefix and suffix OR arrays to efficiently calculate what the total OR would be if we apply all k operations to each specific element. This avoids recalculating OR for unchanged elements.

Brute Force - Try All Combinations — Algorithm Steps

Generate all ways to distribute k operations
For each distribution, apply operations and calculate OR
Return maximum OR found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all ways to apply k operations

Calculate OR

For each combination, compute bitwise OR

Find Maximum

Return the highest OR value found

Code -

solution.c — C

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

long long maxOr = 0;

void backtrack(int operationsLeft, long long* currentNums, int n) {
    if (operationsLeft == 0) {
        long long currentOr = 0;
        for (int i = 0; i < n; i++) {
            currentOr |= currentNums[i];
        }
        if (currentOr > maxOr) {
            maxOr = currentOr;
        }
        return;
    }
    
    for (int i = 0; i < n; i++) {
        long long* newNums = malloc(n * sizeof(long long));
        memcpy(newNums, currentNums, n * sizeof(long long));
        newNums[i] *= 2;
        backtrack(operationsLeft - 1, newNums, n);
        free(newNums);
    }
}

long long solution(int* nums, int n, int k) {
    maxOr = 0;
    long long* longNums = malloc(n * sizeof(long long));
    for (int i = 0; i < n; i++) {
        longNums[i] = nums[i];
    }
    backtrack(k, longNums, n);
    free(longNums);
    return maxOr;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%lld\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k × n)

n^k ways to distribute operations, O(n) to calculate OR for each

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth for generating combinations

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler