Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2311.html

2311. Longest Binary Subsequence Less Than or Equal to K

  • Difficulty: Medium.
  • Related Topics: String, Dynamic Programming, Greedy, Memoization.
  • Similar Questions: Maximum Binary String After Change.

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.

  Example 1:

Input: s = "1001010", k = 5
Output: 5
Explanation: The longest subsequence of s that makes up a binary number less than or equal to 5 is "00010", as this number is equal to 2 in decimal.
Note that "00100" and "00101" are also possible, which are equal to 4 and 5 in decimal, respectively.
The length of this subsequence is 5, so 5 is returned.

Example 2:

Input: s = "00101001", k = 1
Output: 6
Explanation: "000001" is the longest subsequence of s that makes up a binary number less than or equal to 1, as this number is equal to 1 in decimal.
The length of this subsequence is 6, so 6 is returned.

  Constraints:

  • 1 <= s.length <= 1000

  • s[i] is either '0' or '1'.

  • 1 <= k <= 109

Solution (Java, C++, Python)

  • class Solution {
        public int longestSubsequence(String s, int k) {
            int res = 0;
            int cost = 1;
            int n = s.length();
            for (int i = n - 1; i >= 0; i--) {
                if (s.charAt(i) == '0' || cost <= k) {
                    k -= cost * (s.charAt(i) - '0');
                    ++res;
                }
                if (cost <= k) {
                    cost *= 2;
                }
            }
            return res;
        }
    }
    
    ############
    
    class Solution {
        public int longestSubsequence(String s, int k) {
            int ans = 0, v = 0;
            for (int i = s.length() - 1; i >= 0; --i) {
                if (s.charAt(i) == '0') {
                    ++ans;
                } else if (ans < 30 && (v | 1 << ans) <= k) {
                    v |= 1 << ans;
                    ++ans;
                }
            }
            return ans;
        }
    }
    
  • class Solution:
        def longestSubsequence(self, s: str, k: int) -> int:
            ans = v = 0
            for c in s[::-1]:
                if c == "0":
                    ans += 1
                elif ans < 30 and (v | 1 << ans) <= k:
                    v |= 1 << ans
                    ans += 1
            return ans
    
    ############
    
    # 2311. Longest Binary Subsequence Less Than or Equal to K
    # https://leetcode.com/problems/longest-binary-subsequence-less-than-or-equal-to-k
    
    class Solution:
        def longestSubsequence(self, s: str, k: int) -> int:
            n = len(s)
            res = s.count("0")
            val = 0
            base = 1
            
            for x in s[::-1]:
                if val + base > k: break
                    
                if x == "1":
                    res += 1
                    val += base
                
                base *= 2
            
            return res
            
    
    
  • class Solution {
    public:
        int longestSubsequence(string s, int k) {
            int ans = 0, v = 0;
            for (int i = s.size() - 1; ~i; --i) {
                if (s[i] == '0') {
                    ++ans;
                } else if (ans < 30 && (v | 1 << ans) <= k) {
                    v |= 1 << ans;
                    ++ans;
                }
            }
            return ans;
        }
    };
    
  • func longestSubsequence(s string, k int) (ans int) {
    	for i, v := len(s)-1, 0; i >= 0; i-- {
    		if s[i] == '0' {
    			ans++
    		} else if ans < 30 && (v|1<<ans) <= k {
    			v |= 1 << ans
    			ans++
    		}
    	}
    	return
    }
    
  • function longestSubsequence(s: string, k: number): number {
        let ans = 0;
        for (let i = s.length - 1, v = 0; ~i; --i) {
            if (s[i] == '0') {
                ++ans;
            } else if (ans < 30 && (v | (1 << ans)) <= k) {
                v |= 1 << ans;
                ++ans;
            }
        }
        return ans;
    }
    
    
  • /**
     * @param {string} s
     * @param {number} k
     * @return {number}
     */
    var longestSubsequence = function (s, k) {
        let ans = 0;
        for (let i = s.length - 1, v = 0; ~i; --i) {
            if (s[i] == '0') {
                ++ans;
            } else if (ans < 30 && (v | (1 << ans)) <= k) {
                v |= 1 << ans;
                ++ans;
            }
        }
        return ans;
    };
    
    

Explain:

nope.

Complexity:

  • Time complexity : O(n).
  • Space complexity : O(n).

All Problems

All Solutions