Bitwise OR of Adjacent Elements

Bitwise OR of Adjacent Elements - Problem

Given an array nums of length n, return an array answer of length n - 1 such that answer[i] = nums[i] | nums[i + 1] where | is the bitwise OR operation.

The bitwise OR operation combines bits from two numbers: if either bit is 1, the result bit is 1; if both bits are 0, the result bit is 0.

Input & Output

Example 1 — Basic Case

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

› Output: [3,3]

💡 Note: For adjacent pairs: 1 | 2 = 3 (binary: 01 | 10 = 11), 2 | 3 = 3 (binary: 10 | 11 = 11)

Example 2 — Different Values

$ Input: nums = [5,3,7,1]

› Output: [7,7,7]

💡 Note: 5 | 3 = 7, 3 | 7 = 7, 7 | 1 = 7. All pairs result in 7.

Example 3 — Minimum Array

$ Input: nums = [8,4]

› Output: [12]

💡 Note: Only one pair: 8 | 4 = 12 (binary: 1000 | 0100 = 1100)

Constraints

2 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

This problem requires a single pass through the array to compute bitwise OR of adjacent pairs. The key insight is that bitwise OR combines bits where any 1 bit produces 1 in the result. Best approach uses O(n) time and O(1) extra space.

Common Approaches

✓ Optimized Single Pass

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

For this problem, there's no more optimal solution than the single pass approach. Each adjacent pair must be processed exactly once, making O(n) time complexity optimal.

Single Pass

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

The straightforward approach iterates through the array once, computing the bitwise OR of each adjacent pair nums[i] | nums[i+1] and storing the result.

Optimized Single Pass — Algorithm Steps

Step 1: Initialize result array
Step 2: Single loop through adjacent pairs
Step 3: Apply bitwise OR operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

Array with adjacent pairs identified

Functional Map

Apply OR operation via mapping

Result

Direct output generation

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize - 1;
    int* answer = (int*)malloc((*returnSize) * sizeof(int));
    // Optimized: single loop with direct assignment
    for (int i = 0; i < numsSize - 1; i++) {
        answer[i] = nums[i] | nums[i + 1];
    }
    return answer;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must visit each of n-1 adjacent pairs exactly once

✓ Linear Growth

Space Complexity

O(1)

Only constant extra space beyond output array

✓ Linear Space

12.5K Views

Medium Frequency

~8 min Avg. Time

456 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

Optimized Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler