Count the Number of Beautiful Subarrays - Practice Coding Problems

Count the Number of Beautiful Subarrays - Problem

Count the Number of Beautiful Subarrays

You are given a 0-indexed integer array nums. Your task is to find all beautiful subarrays - contiguous subsequences where you can make all elements equal to zero using a special bit manipulation operation.

The operation allows you to:
• Choose any two different indices i and j in the current subarray
• Select a bit position k where both nums[i] and nums[j] have their k-th bit set to 1
• Subtract 2^k from both numbers simultaneously

A subarray is beautiful if you can reduce all its elements to zero using this operation any number of times. Note that subarrays with all elements initially zero are automatically beautiful.

Goal: Return the total count of beautiful subarrays in the given array.

Key Insight: This problem is secretly about XOR operations! A subarray can be reduced to all zeros if and only if the XOR of all its elements equals zero.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Beautiful subarrays are [4,2,1,3] (XOR = 4⊕2⊕1⊕3 = 0) and [2,1,3] (XOR = 2⊕1⊕3 = 0). The key insight is that these subarrays can be reduced to all zeros using the bit manipulation operations.

example_2.py — All Zeros

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

› Output: 0

💡 Note: No subarray has XOR equal to 0. For example: [1] has XOR=1, [10] has XOR=10, [4] has XOR=4, [1,10] has XOR=11, [10,4] has XOR=14, [1,10,4] has XOR=15. None can be made all zeros.

example_3.py — Single Element Zero

$ Input: nums = [0]

› Output: 1

💡 Note: The single subarray [0] is beautiful since it's already all zeros and no operations are needed.

Visualization

Tap to expand

Understanding the Visualization

Understand XOR

XOR operation: same bits cancel (1⊕1=0, 0⊕0=0), different bits remain (1⊕0=1)

Prefix XOR Insight

If prefix_xor[i] = prefix_xor[j], then subarray (i,j] has XOR = 0

Hash Table Optimization

Store frequency of each prefix XOR value seen so far

Count Beautiful Subarrays

For each position, add the frequency of current prefix XOR to result

Key Takeaway

🎯 Key Insight: Beautiful subarrays are those with XOR = 0. Use prefix XOR and hash table to find them efficiently in O(n) time!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n different prefix XOR values

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
All subarrays are contiguous sequences
XOR operation is associative and commutative

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses the key insight that a subarray is beautiful if and only if its XOR equals zero. We can solve this efficiently using prefix XOR and a hash table. For each position, if we've seen the current prefix XOR before, it means there are subarrays ending at this position with zero XOR. The algorithm runs in O(n) time and O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray and compute its XOR to see if it equals zero
One-Pass Hash Table with Prefix XOR (Optimal)	O(n)	O(n)	Use prefix XOR and hash table to count subarrays with zero XOR in single pass

Brute Force (Check All Subarrays) — Algorithm Steps

Iterate through all possible starting positions i
For each starting position, iterate through all possible ending positions j
Calculate XOR of elements from index i to j
If XOR equals 0, increment the beautiful subarray count
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position i=0

Check all subarrays starting from index 0

End Position j varies

For each start, try all possible end positions

Calculate XOR

Compute XOR of all elements in current subarray

Check if Beautiful

If XOR equals 0, increment counter

Code -

solution.c — C

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

int beautifulSubarrays(int* nums, int numsSize) {
    int count = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int xorSum = 0;
            // Calculate XOR of subarray from i to j
            for (int k = i; k <= j; k++) {
                xorSum ^= nums[k];
            }
            
            // If XOR is 0, subarray is beautiful
            if (xorSum == 0) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int size = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        nums[size++] = num;
        if (getchar() == '\n') break;
    }
    
    printf("%d\n", beautifulSubarrays(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n) for start position, O(n) for end position, and O(n) for XOR calculation

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track indices and running calculations

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
All subarrays are contiguous sequences
XOR operation is associative and commutative

28.4K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler