Ones and Zeroes - Practice Coding Problems

Ones and Zeroes - Problem

You're building the ultimate collection of binary strings, but there's a catch - you have limited resources! Given an array of binary strings and two constraints (maximum m zeros and n ones), find the largest possible subset you can create.

The Challenge: Each binary string costs a certain number of 0's and 1's. Your goal is to select the maximum number of strings while staying within your budget of m zeros and n ones.

Example: With strings ["10", "0001", "111001", "1", "0"], m=5 zeros, and n=3 ones, you could select ["10", "0001", "1", "0"] (using 3 zeros and 3 ones) for a subset of size 4.

Input & Output

example_1.py — Basic Case

$ Input: strs = ["10","0001","111001","1","0"], m = 5, n = 3

› Output: 4

💡 Note: The largest subset is ["10", "0001", "1", "0"] which contains at most 5 zeros and 3 ones. String "111001" would exceed the ones limit.

example_2.py — Tight Constraints

$ Input: strs = ["10","0","1"], m = 1, n = 1

› Output: 2

💡 Note: We can choose ["0", "1"] using exactly 1 zero and 1 one, achieving the maximum possible size of 2.

example_3.py — All Same Strings

$ Input: strs = ["111","111","111"], m = 0, n = 2

› Output: 0

💡 Note: Each string needs 3 ones, but we only have budget for 2 ones. No strings can be selected.

Visualization

Tap to expand

Understanding the Visualization

Count Resources

Each string "costs" a certain number of 0s and 1s

DP Decision

For each string: include it (if affordable) or skip it

Optimal Choice

Take the maximum between including vs excluding each string

Build Solution

Final answer is dp[length][m][n] - max strings with given constraints

Key Takeaway

🎯 Key Insight: Transform the problem into a 2D knapsack where each string has dual costs. Use DP to build optimal solutions incrementally, ensuring we never exceed our zero/one budgets.

Time & Space Complexity

Time Complexity

⏱️

O(len × m × n)

We fill a 3D table of size len × m × n, each cell taking O(1) time

✓ Linear Growth

Space Complexity

O(len × m × n)

3D DP table to store all possible states

⚡ Linearithmic Space

Constraints

1 ≤ strs.length ≤ 600
1 ≤ strs[i].length ≤ 100
strs[i] consists only of digits '0' and '1'
1 ≤ m, n ≤ 100

Asked in

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

This is a classic 2D Knapsack Problem where each string has two costs (zeros and ones). The optimal approach uses Dynamic Programming with state dp[i][j][k] representing the maximum strings using first i strings with ≤j zeros and ≤k ones. Can be space-optimized to O(m×n) by using only 2D array since we only need previous row.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (3D Knapsack)	O(len × m × n)	O(len × m × n)	Use 3D DP to track maximum strings for each (strings_considered, zeros_used, ones_used) state

Dynamic Programming (3D Knapsack) — Algorithm Steps

Count zeros and ones in each string
Create 3D DP table: dp[strings][zeros][ones]
For each string, decide whether to include it or not
Take maximum of including vs excluding current string
Return dp[len][m][n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Table

Create 3D table dp[strings][zeros][ones]

Fill Base Cases

Set dp[0][j][k] = 0 for all j, k (no strings = 0 count)

Process Each String

For each string, decide include vs exclude

Take Maximum

Choose better option: dp[i-1][j][k] vs dp[i-1][j-zeros][k-ones]+1

Code -

solution.c — C

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

typedef struct {
    int zeros;
    int ones;
} Count;

Count countZerosOnes(char* s) {
    Count count = {0, 0};
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] == '0') count.zeros++;
        else count.ones++;
    }
    return count;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

int findMaxForm(char** strs, int strsSize, int m, int n) {
    // Allocate 3D DP array
    int*** dp = (int***)malloc((strsSize + 1) * sizeof(int**));
    for (int i = 0; i <= strsSize; i++) {
        dp[i] = (int**)malloc((m + 1) * sizeof(int*));
        for (int j = 0; j <= m; j++) {
            dp[i][j] = (int*)calloc(n + 1, sizeof(int));
        }
    }
    
    // Precompute counts
    Count* counts = (Count*)malloc(strsSize * sizeof(Count));
    for (int i = 0; i < strsSize; i++) {
        counts[i] = countZerosOnes(strs[i]);
    }
    
    for (int i = 1; i <= strsSize; i++) {
        int zeros = counts[i - 1].zeros;
        int ones = counts[i - 1].ones;
        
        for (int j = 0; j <= m; j++) {
            for (int k = 0; k <= n; k++) {
                // Don't include current string
                dp[i][j][k] = dp[i - 1][j][k];
                
                // Include current string if possible
                if (j >= zeros && k >= ones) {
                    dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - zeros][k - ones] + 1);
                }
            }
        }
    }
    
    int result = dp[strsSize][m][n];
    
    // Free memory
    for (int i = 0; i <= strsSize; i++) {
        for (int j = 0; j <= m; j++) {
            free(dp[i][j]);
        }
        free(dp[i]);
    }
    free(dp);
    free(counts);
    
    return result;
}

int main() {
    char* strs[] = {"10", "0001", "111001", "1", "0"};
    int result = findMaxForm(strs, 5, 5, 3);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(len × m × n)

We fill a 3D table of size len × m × n, each cell taking O(1) time

✓ Linear Growth

Space Complexity

O(len × m × n)

3D DP table to store all possible states

⚡ Linearithmic Space

Constraints

1 ≤ strs.length ≤ 600
1 ≤ strs[i].length ≤ 100
strs[i] consists only of digits '0' and '1'
1 ≤ m, n ≤ 100

67.2K Views

High Frequency

~25 min Avg. Time

1.8K 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

Dynamic Programming (3D Knapsack) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler