Longest Binary Subsequence Less Than or Equal to K

Longest Binary Subsequence Less Than or Equal to K - Problem

You are given a binary string s and a positive integer k.

Return the length of the longest subsequence of s that makes up a binary number less than or equal to k.

Note:

The subsequence can contain leading zeroes.
The empty string is considered to be equal to 0.
A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.

Input & Output

Example 1 — Basic Case

$ Input: s = "1001", k = 9

› Output: 4

💡 Note: The longest subsequence is "1001" which equals 9 in decimal (1×8 + 0×4 + 0×2 + 1×1 = 9), and 9 ≤ 9, so length is 4.

Example 2 — Limited by k

$ Input: s = "111", k = 5

› Output: 2

💡 Note: We can take all characters to form "111" = 7, but 7 > 5. We need to find the longest subsequence ≤ 5. The best strategy is to take the rightmost ones first (lowest powers): we can take "11" (last two characters) = 3 ≤ 5, giving us length 2.

Example 3 — All Zeros

$ Input: s = "000", k = 5

› Output: 3

💡 Note: All zeros can be taken since "000" = 0 ≤ 5, giving us length 3.

Constraints

1 ≤ s.length ≤ 1000
s consists only of '0' and '1'
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Meta 18

The key insight is to use a greedy approach: take all zeros first (they don't increase the binary value), then greedily add ones while keeping the total value ≤ k. Best approach is the optimized greedy method that processes characters left to right. Time: O(n), Space: O(1)

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force - Try All Subsequences

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

Generate every possible subsequence of the binary string, convert each to a decimal number, check if it's ≤ k, and track the maximum length among valid subsequences.

Greedy Approach

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

Take all zeros from the string first (they don't increase the value), then greedily add ones from left to right as long as the resulting number stays ≤ k.

Optimized Greedy with Bit Counting

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

Take all zeros first, then process ones from left to right (maintaining subsequence order) and add each one if the resulting value stays ≤ k.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare_desc(const void* a, const void* b) {
    int ia = *(const int*)a;
    int ib = *(const int*)b;
    return ib - ia;  // Descending order
}

int solution(char* s, int k) {
    int len = strlen(s);
    
    if (k == 0) {
        int zeros = 0;
        for (int i = 0; i < len; i++) {
            if (s[i] == '0') zeros++;
        }
        return zeros;
    }
    
    int zeros = 0;
    int ones[1000];  // Array to store powers of ones
    int ones_count = 0;
    
    // Count zeros and collect positions/powers of ones
    for (int i = 0; i < len; i++) {
        if (s[i] == '0') {
            zeros++;
        } else {
            ones[ones_count++] = len - 1 - i;  // Power of 2
        }
    }
    
    // Sort ones by their power (highest first for greedy selection)
    qsort(ones, ones_count, sizeof(int), compare_desc);
    
    int current_value = 0;
    int selected_ones = 0;
    
    // Greedily add ones while staying within k
    for (int i = 0; i < ones_count; i++) {
        int power = ones[i];
        int value_to_add = 1 << power;  // 2^power
        
        if (current_value + value_to_add <= k) {
            current_value += value_to_add;
            selected_ones++;
        } else {
            break;
        }
    }
    
    return zeros + selected_ones;
}

int main() {
    char s[1001];
    int k;
    
    // Read inputs
    if (fgets(s, sizeof(s), stdin)) {
        // Remove newline if present
        int len = strlen(s);
        if (len > 0 && s[len-1] == '\n') {
            s[len-1] = '\0';
        }
    }
    scanf("%d", &k);
    
    // Call solution and print result
    int result = solution(s, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium 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