Longest Binary Subsequence Less Than or Equal to K

Longest Binary Subsequence Less Than or Equal to K - Problem

Problem: You're given a binary string s and a positive integer k. Your task is to find the longest subsequence from the string that, when interpreted as a binary number, has a value less than or equal to k.

Key Points:
• A subsequence maintains the original order but can skip characters
• Leading zeros are allowed (e.g., "001" is valid)
• Empty subsequence equals 0
• You want the maximum length subsequence that stays ≤ k

Example: For s = "1001101" and k = 10, the subsequence "1010" (value 10) has length 4, which might be optimal.

Input & Output

example_1.py — Basic Case

$ Input: ["1001101", 10]

› Output: 5

💡 Note: We can select subsequence "00101" which equals binary 101 = 5 in decimal. This gives us length 5 and stays within k=10.

example_2.py — All Zeros

$ Input: ["00001111", 5]

› Output: 6

💡 Note: We can take all zeros (4) plus two rightmost ones "000011" = binary 11 = 3 ≤ 5, giving length 6.

example_3.py — Small k

$ Input: ["1111", 1]

› Output: 1

💡 Note: k=1, so we can only take one rightmost '1' to get binary "1" = 1, giving length 1.

Constraints

1 ≤ s.length ≤ 1000
s consists only of 0s and 1s
1 ≤ k ≤ 10⁹
The subsequence can have leading zeros
Empty subsequence is considered to equal 0

Visualization

Tap to expand

Understanding the Visualization

Position Powers

Each position represents a power of 2: rightmost is 2⁰=1, next is 2¹=2, etc.

Zero Cost

Zeros at any position contribute 0 to the total value

Greedy Selection

Select ones from right to left to minimize their contribution

Optimal Result

This greedy strategy always produces the maximum length valid subsequence

Key Takeaway

🎯 Key Insight: In binary representation, position determines exponential contribution (2⁰, 2¹, 2², ...). Greedily selecting ones from right-to-left minimizes the total value while maximizing subsequence length.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 15

The optimal greedy approach works by recognizing that zeros are free (contribute 0 to binary value) and ones should be selected from right to left (lowest to highest powers of 2). This gives us O(n) time complexity and maximizes the subsequence length while staying within the limit k.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n)	O(1)	Greedily select zeros and ones from right to left to minimize binary value
Brute Force (Generate All Subsequences)	O(2^n × n)	O(n)	Generate all possible subsequences and find the longest valid one

Greedy Approach (Optimal) — Algorithm Steps

Count all zeros - they can always be included
Traverse the string from right to left to process ones
For each '1', calculate its contribution (2^position)
Include the '1' only if total value remains ≤ k
Return the total count of included characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Zeros

All zeros can be included (contribute 0 to value)

Process from Right

Start from rightmost position (lowest power of 2)

Check Each One

Include '1' if it doesn't exceed k

Return Total

Sum of zeros and selected ones

Code -

solution.c — C

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

int longestSubsequence(char* s, int k) {
    int zeros = 0;
    int n = strlen(s);
    
    // Count zeros
    for (int i = 0; i < n; i++) {
        if (s[i] == '0') zeros++;
    }
    
    int ones = 0;
    long long currentValue = 0;
    long long power = 1;
    
    // Process ones from right to left
    for (int i = n - 1; i >= 0; i--) {
        if (s[i] == '1') {
            if (currentValue + power <= k) {
                currentValue += power;
                ones++;
            }
            power *= 2;
            if (power > k) break;
        }
    }
    
    return zeros + ones;
}

int main() {
    char s[1000];
    int k;
    scanf("[\"%[^\"]\", %d]", s, &k);
    printf("%d\n", longestSubsequence(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count and evaluate characters

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and current value

✓ Linear Space

21.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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler