Bitwise OR of Adjacent Elements - Practice Coding Problems

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

Understanding the Visualization

Input

Array of integers with adjacent pairs to combine

Process

Apply bitwise OR operation to each adjacent pair

Output

New array with OR results, length n-1

Key Takeaway

🎯 Key Insight: Bitwise OR produces 1 when either bit is 1, requiring only a single pass through adjacent pairs

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

Approach	Time	Space	Notes
✓ Single Pass	O(n)	O(1)	Iterate through array and compute bitwise OR of each adjacent pair
Optimized Single Pass	O(n)	O(1)	Same as brute force - single pass is already optimal for this problem

Single Pass — Algorithm Steps

Step 1: Create result array of size n-1
Step 2: For each index i from 0 to n-2, compute nums[i] | nums[i+1]
Step 3: Store result in answer[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Original array with adjacent pairs highlighted

Bitwise OR

Compute OR for each pair

Result

New array with OR results

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));
    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;
    
    // Parse array [1,2,3]
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]"); // Skip [
    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)

Single loop through n-1 adjacent pairs

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space (excluding 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

Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler