Skip to content

3173. Bitwise OR of Adjacent Elements πŸ”’

Description

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.

 

Example 1:

Input: nums = [1,3,7,15]

Output: [3,7,15]

Example 2:

Input: nums = [8,4,2]

Output: [12,6]

Example 3:

Input: nums = [5,4,9,11]

Output: [5,13,11]

 

Constraints:

  • 2 <= nums.length <= 100
  • 0 <= nums[i] <= 100

Solutions

Solution 1: Iteration

Thinking

Entry \(i\) is \(nums[i]\lor nums[i+1]\) and does not depend on farther elements.

Each adjacent pair can be evaluated independently.

Map pairwise(nums) through OR to obtain an array of length \(n-1\).

We iterate through the first \(n - 1\) elements of the array. For each element, we calculate the bitwise OR value of it and its next element, and store the result in the answer array.

The time complexity is \(O(n)\), where \(n\) is the length of the array. Ignoring the space consumption of the answer array, the space complexity is \(O(1)\).

1
2
3
class Solution:
    def orArray(self, nums: List[int]) -> List[int]:
        return [a | b for a, b in pairwise(nums)]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution {
    public int[] orArray(int[] nums) {
        int n = nums.length;
        int[] ans = new int[n - 1];
        for (int i = 0; i < n - 1; ++i) {
            ans[i] = nums[i] | nums[i + 1];
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution {
public:
    vector<int> orArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n - 1);
        for (int i = 0; i < n - 1; ++i) {
            ans[i] = nums[i] | nums[i + 1];
        }
        return ans;
    }
};

1
2
3
4
5
6
func orArray(nums []int) (ans []int) {
    for i, x := range nums[1:] {
        ans = append(ans, x|nums[i])
    }
    return
}

1
2
3
function orArray(nums: number[]): number[] {
    return nums.slice(0, -1).map((v, i) => v | nums[i + 1]);
}

Comments