Number of Subarrays With AND Value of K - Practice Coding Problems

Number of Subarrays With AND Value of K - Problem

You are given an array of integers nums and a target integer k. Your mission is to find how many contiguous subarrays have a bitwise AND value that equals exactly k.

The bitwise AND operation combines all elements in a subarray using the & operator. For example, if we have a subarray [5, 3, 1], the bitwise AND would be 5 & 3 & 1 = 1.

Key insight: The AND operation is monotonic - adding more elements to a subarray can only make the AND result smaller or stay the same, never larger. This property is crucial for optimization!

Example: Given nums = [1, 1, 1] and k = 1, we have 6 valid subarrays: [1], [1], [1], [1,1], [1,1], and [1,1,1] - all have AND value of 1.

Input & Output

example_1.py — Simple Case

$ Input: nums = [1, 1, 1], k = 1

› Output: 6

💡 Note: All subarrays have AND value 1: [1], [1], [1], [1,1], [1,1], [1,1,1]. Total: 6 subarrays.

example_2.py — Mixed Values

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

› Output: 3

💡 Note: Valid subarrays: [1] (position 0), [1] (position 1), [1,1]. The subarray [1,1,2] has AND value 0, not 1.

example_3.py — No Valid Subarrays

$ Input: nums = [5, 3, 7], k = 2

› Output: 0

💡 Note: No subarray has AND value 2. Individual elements: 5, 3, 7. Pairs: 5&3=1, 3&7=3, 5&7=5. All three: 5&3&7=1.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i], k ≤ 10⁹
All integers fit in 32-bit representation
Subarrays must be contiguous

Visualization

Tap to expand

Understanding the Visualization

Enter the maze

Start with the first element as your signal strength

Apply filters

Each new element you encounter applies an AND filter

Track all paths

Maintain all possible signal strengths from different paths

Count target signals

Count how many paths produce exactly the target signal k

Optimize with insight

Use the fact that there are at most 32 distinct signal levels

Key Takeaway

🎯 Key Insight: The AND operation's monotonic property combined with the limited number of possible bit patterns (≤32) transforms an O(n²) problem into an efficient O(n × log(max_value)) solution.

Asked in

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

The optimal solution leverages the monotonic property of the AND operation - adding elements can only decrease or maintain AND values, never increase them. By tracking all possible AND values at each position (at most 32 due to bit limitations), we achieve O(n × log(max_value)) complexity instead of the naive O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Bit Manipulation (Optimal)	O(n * log(max_value))	O(log(max_value))	Track all possible AND values efficiently using the monotonic property
Brute Force (Check All Subarrays)	O(n²)	O(1)	Generate all possible subarrays and compute their AND values

Optimized Bit Manipulation (Optimal) — Algorithm Steps

Initialize an empty set to track (AND_value, count) pairs
For each element in the array:
Create a new set for the current position
Add the current element itself as a single-element subarray
For each previous AND value, compute new_value = prev_value & current_element
Accumulate counts for each distinct AND value
Count how many subarrays have AND value equal to k

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty set of AND values

Process first element

Add first element as single-element subarray

Extend subarrays

For each new element, combine with all previous AND values

Count matches

Count how many current AND values equal k

Update state

Current AND values become previous for next iteration

Code -

solution.c — C

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

#define MAXVAL 100000

int countSubarrays(int* nums, int numsSize, int k) {
    int count = 0;
    int prevAnds[MAXVAL + 1] = {0};
    int currAnds[MAXVAL + 1];
    
    for (int i = 0; i < numsSize; i++) {
        memset(currAnds, 0, sizeof(currAnds));
        
        // Single element subarray
        currAnds[nums[i]]++;
        
        // Extend all previous subarrays
        for (int j = 0; j <= MAXVAL; j++) {
            if (prevAnds[j] > 0) {
                int newAnd = j & nums[i];
                currAnds[newAnd] += prevAnds[j];
            }
        }
        
        // Add count of subarrays ending here with AND = k
        count += currAnds[k];
        
        memcpy(prevAnds, currAnds, sizeof(currAnds));
    }
    
    return count;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%d\n", countSubarrays(nums, n, k));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log(max_value))

For each element, we process at most log(max_value) distinct AND values (≤ 32 for 32-bit integers)

⚡ Linearithmic

Space Complexity

O(log(max_value))

We store at most 32 distinct AND values at any time

✓ Linear Space

26.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Optimized Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler