Largest Combination With Bitwise AND Greater Than Zero

Largest Combination With Bitwise AND Greater Than Zero - Problem

The bitwise AND of an array nums is the bitwise AND of all integers in nums.

For example, for nums = [1, 5, 3], the bitwise AND is equal to 1 & 5 & 3 = 1.
Also, for nums = [7], the bitwise AND is 7.

You are given an array of positive integers candidates. Compute the bitwise AND for all possible combinations of elements in the candidates array.

Return the size of the largest combination of candidates with a bitwise AND greater than 0.

Input & Output

Example 1 — Basic Case

$ Input: candidates = [16,17,71,62,12,24,14]

› Output: 4

💡 Note: The combination [16,17,62,24] has a bitwise AND where bit 4 is set in all numbers, giving AND = 16 > 0. Bit position 4 appears in exactly 4 numbers, which is the maximum across all bit positions.

Example 2 — Small Array

$ Input: candidates = [8,8]

› Output: 2

💡 Note: Both numbers are identical, so we can pick both and their AND = 8 > 0.

Example 3 — No Common Bits

$ Input: candidates = [1,2,4,8]

› Output: 1

💡 Note: Each number has a unique bit set, so maximum combination size with AND > 0 is 1.

Constraints

1 ≤ candidates.length ≤ 10⁵
1 ≤ candidates[i] ≤ 10⁷

Visualization

Tap to expand

Asked in

f Meta 25 G Google 15

The key insight is that for a combination to have AND > 0, all numbers must share at least one common bit position. By counting how many numbers have each bit position set, we find the maximum possible combination size. Best approach uses bit manipulation in O(n) time and O(1) space.

Common Approaches

✓ Bit Manipulation - Count Bit Positions

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

The key insight is that for AND to be > 0, at least one bit position must be 1 in ALL selected numbers. Count occurrences of each bit position and return the maximum count.

Brute Force - Generate All Combinations

⏱️ Time: O(n × 2^n) Space: O(1)

Try every possible subset of candidates, compute their bitwise AND, and track the largest size with AND > 0. This explores all 2^n combinations.

Bit Manipulation - Count Bit Positions — Algorithm Steps

For each bit position (0 to 23), count how many candidates have that bit set
The maximum count across all bit positions is our answer
This works because the largest valid combination shares the most common bit

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Each Bit

For each number, check which bit positions are set

Count Occurrences

Count how many numbers have each bit position set

Find Maximum

Return the bit position with maximum count

Code -

solution.c — C

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

int solution(int* candidates, int n) {
    // Count occurrences of each bit position (0-23 for 32-bit integers)
    int bitCount[24] = {0};
    
    for (int i = 0; i < n; i++) {
        int num = candidates[i];
        for (int bit = 0; bit < 24; bit++) {
            if (num & (1 << bit)) {
                bitCount[bit]++;
            }
        }
    }
    
    // Return maximum count across all bit positions
    int maxCount = 0;
    for (int i = 0; i < 24; i++) {
        if (bitCount[i] > maxCount) {
            maxCount = bitCount[i];
        }
    }
    
    return maxCount;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Simple JSON array parsing
    int candidates[100];
    int n = 0;
    char* token = strtok(line + 1, ",]"); // Skip '['
    while (token != NULL) {
        candidates[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(candidates, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, checking 24 bit positions per number

✓ Linear Growth

Space Complexity

O(1)

Fixed size array of 24 counters for bit positions

✓ Linear Space

28.5K Views

Medium Frequency

~15 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

Bit Manipulation - Count Bit Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler