Largest Combination With Bitwise AND Greater Than Zero

Largest Combination With Bitwise AND Greater Than Zero - Problem

You're given an array of positive integers called candidates. Your task is to find the largest possible combination (subset) of these numbers such that their bitwise AND is greater than zero.

The bitwise AND of an array is calculated by performing the AND operation on all integers in the array:

For [1, 5, 3]: 1 & 5 & 3 = 1 (result > 0 ✓)
For [7]: the bitwise AND is simply 7 (result > 0 ✓)
For [2, 4]: 2 & 4 = 0 (result = 0 ✗)

Goal: Return the size of the largest combination where the bitwise AND result is greater than 0.

Key Insight: For a bitwise AND to be greater than 0, at least one bit position must be 1 in all numbers of the combination!

Input & Output

example_1.py — Basic case

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

› Output: 4

💡 Note: The largest combination is [16, 17, 62, 24] with bitwise AND = 16 > 0. All four numbers share bit position 4.

example_2.py — Simple case

$ Input: [8, 8]

› Output: 2

💡 Note: Both numbers are identical, so their AND = 8 > 0. We can take both numbers.

example_3.py — Single element

$ Input: [1]

› Output: 1

💡 Note: With only one element, the largest (and only) combination has size 1.

Visualization

Tap to expand

Understanding the Visualization

Identify Skills

Each bit position represents a different skill

Count Per Skill

Count how many people have each skill

Find Best Team

The skill with the most people gives us the largest team

Key Takeaway

🎯 Key Insight: Instead of trying all team combinations, just find the most popular skill!

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max_val))

We check each number against each bit position. With max value 10^7, we need ~24 bit checks per number

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant-size array for bit counts (max 32 elements)

✓ Linear Space

Constraints

1 ≤ candidates.length ≤ 10⁵
1 ≤ candidates[i] ≤ 10⁷
All candidates are positive integers

Asked in

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

The optimal solution uses bit counting - instead of checking all combinations, we count how many numbers share each bit position. The maximum count gives us the largest valid combination, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Combinations)	O(2^n * n)	O(1)	Generate all possible combinations and check which ones have AND > 0
Bit Counting (Optimal)	O(n × log(max_val))	O(1)	Count frequency of each bit position and return the maximum count

Brute Force (Check All Combinations) — Algorithm Steps

Generate all possible non-empty combinations using bit manipulation or recursion
For each combination, calculate the bitwise AND of all elements
If the AND result is greater than 0, update the maximum size
Return the maximum size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible subsets using bit masks

Calculate AND

Compute bitwise AND for each combination

Track Maximum

Keep track of largest valid combination size

Code -

solution.c — C

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

int largestCombination(int* candidates, int n) {
    int maxSize = 0;
    
    // Check all non-empty combinations
    for (int mask = 1; mask < (1 << n); mask++) {
        int combination[1000];
        int combSize = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                combination[combSize++] = candidates[i];
            }
        }
        
        // Calculate AND of current combination
        int currentAnd = combination[0];
        for (int i = 1; i < combSize; i++) {
            currentAnd &= combination[i];
        }
        
        // Update max size if AND > 0
        if (currentAnd > 0 && combSize > maxSize) {
            maxSize = combSize;
        }
    }
    
    return maxSize;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n combinations, each taking O(n) time to compute AND

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track current combination and max size

✓ Linear Space

Constraints

1 ≤ candidates.length ≤ 10⁵
1 ≤ candidates[i] ≤ 10⁷
All candidates are positive integers

24.5K Views

Medium Frequency

~15 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler