Bitwise OR of Adjacent Elements - Practice Coding Problems

Bitwise OR of Adjacent Elements - Problem

Given an array nums of integers with length n, your task is to create a new array that captures the bitwise relationships between adjacent elements.

Return an array answer of length n - 1 where each element answer[i] represents the bitwise OR operation between nums[i] and nums[i + 1].

The bitwise OR operation (|) combines bits from both numbers, resulting in 1 if either bit is 1, and 0 only when both bits are 0.

Example: If nums = [1, 2, 3], then:
• answer[0] = 1 | 2 = 3 (binary: 01 | 10 = 11)
• answer[1] = 2 | 3 = 3 (binary: 10 | 11 = 11)
• Result: [3, 3]

Input & Output

example_1.py — Basic Case

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

› Output: [3, 3]

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

example_2.py — Powers of 2

$ Input: nums = [4, 8, 16]

› Output: [12, 24]

💡 Note: 4 | 8 = 12 (binary: 100 | 1000 = 1100), 8 | 16 = 24 (binary: 1000 | 10000 = 11000)

example_3.py — Minimum Length

$ Input: nums = [5, 7]

› Output: [7]

💡 Note: Only one pair possible: 5 | 7 = 7 (binary: 101 | 111 = 111)

Constraints

2 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Array must have at least 2 elements

Visualization

Tap to expand

Understanding the Visualization

Initialize

Create result array of size n-1 and start with first pair

Process Pairs

For each adjacent pair, apply bitwise OR operation

Store Result

Add the OR result to the answer array

Continue

Move to next adjacent pair until all are processed

Key Takeaway

🎯 Key Insight: This is a simple linear scan problem - just iterate once through the array and apply the built-in OR operator to each adjacent pair. No complex algorithms needed!

Asked in

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

This problem has a straightforward single-pass solution with O(n) time complexity. Simply iterate through the array and compute the bitwise OR of each adjacent pair. The key insight is that bitwise OR is a built-in operation that doesn't require manual bit manipulation - just use nums[i] | nums[i+1] directly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n * log(max))	O(1)	Use nested loops to process each adjacent pair separately

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array of size n-1
For each position i from 0 to n-2
Use inner loop to simulate OR operation bit by bit
Store result in answer[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first pair

Take nums[0] and nums[1], initialize result = 0

Extract bits

Get least significant bit from both numbers

OR operation

If either bit is 1, set corresponding bit in result

Shift and repeat

Right shift both numbers and move to next bit position

Code -

solution.c — C

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = 0;
    if (numsSize < 2) return NULL;
    
    *returnSize = numsSize - 1;
    int* answer = (int*)malloc(*returnSize * sizeof(int));
    
    // Brute force with explicit bit manipulation
    for (int i = 0; i < numsSize - 1; i++) {
        int result = 0;
        int num1 = nums[i], num2 = nums[i + 1];
        int bitPos = 0;
        
        while (num1 > 0 || num2 > 0) {
            int bit1 = num1 & 1;
            int bit2 = num2 & 1;
            if (bit1 || bit2) {
                result |= (1 << bitPos);
            }
            num1 >>= 1;
            num2 >>= 1;
            bitPos++;
        }
        answer[i] = result;
    }
    
    return answer;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log(max))

O(n) for the main loop, O(log(max)) for bit-by-bit OR operation where max is the maximum number

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra space for temporary variables

✓ Linear Space

23.4K Views

Medium Frequency

~8 min Avg. Time

890 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler