Count the Number of Beautiful Subarrays - Problem

You are given a 0-indexed integer array nums. In one operation, you can:

Choose two different indices i and j such that 0 <= i, j < nums.length.
Choose a non-negative integer k such that the kth bit (0-indexed) in the binary representation of nums[i] and nums[j] is 1.
Subtract 2^k from nums[i] and nums[j].

A subarray is beautiful if it is possible to make all of its elements equal to 0 after applying the above operation any number of times (including zero).

Return the number of beautiful subarrays in the array nums.

A subarray is a contiguous non-empty sequence of elements within an array.

Note: Subarrays where all elements are initially 0 are considered beautiful, as no operation is needed.

Input & Output

Example 1 — Basic Case

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

› Output: 8

💡 Note: Beautiful subarrays: [4,2,4,2], [2,4], [4,2], [2,4,2,3,1], [2], [4], [2], [3,1]. All have XOR = 0, meaning all bits can be paired and eliminated.

Example 2 — Single Elements

$ Input: nums = [1,10,4]

› Output: 0

💡 Note: No subarrays have XOR = 0. Each single element has non-zero XOR, and combinations like [1,10], [10,4], [1,10,4] all have non-zero XOR.

Example 3 — All Zeros

$ Input: nums = [0,0,0]

› Output: 6

💡 Note: All subarrays are beautiful since they contain only zeros: [0], [0], [0], [0,0], [0,0], [0,0,0]. Each has XOR = 0.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

The key insight is that a subarray is beautiful if and only if its XOR equals 0, since the operation can eliminate pairs of identical bits. The optimal approach uses prefix XOR with hash map to find all subarrays with XOR = 0 in O(n) time. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Dp

⏱️ Time: N/A Space: N/A

Brute Force - Check All Subarrays

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

For each possible subarray, calculate its XOR. If XOR is 0, all bits are perfectly paired and can be eliminated, making the subarray beautiful.

Optimized - Running XOR

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

Instead of recalculating XOR for each subarray from scratch, maintain a running XOR as we extend the subarray. This reduces redundant calculations.

Prefix XOR with Hash Map

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

Key insight: A subarray [i,j] has XOR = 0 if and only if prefix_xor[j] = prefix_xor[i-1]. Use a hash map to count occurrences of each prefix XOR value.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int count = 0;
    
    // For each starting position
    for (int i = 0; i < n; i++) {
        int xor_val = 0;
        // Extend subarray from position i
        for (int j = i; j < n; j++) {
            xor_val ^= nums[j];  // Add current element to running XOR
            if (xor_val == 0) {   // Check if current subarray [i,j] is beautiful
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    
    // Parse JSON array format [1,2,3,4]
    if (strlen(line) > 1 && strncmp(line, "[]", 2) != 0) {
        char* ptr = line + 1; // skip opening bracket
        char* end;
        
        while (*ptr && *ptr != ']') {
            while (*ptr == ' ' || *ptr == ',') ptr++; // skip whitespace and commas
            if (*ptr == ']') break;
            
            nums[n] = (int)strtol(ptr, &end, 10);
            n++;
            ptr = end;
        }
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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