Description
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 <= 1000s[i] is either '0' or '1'.1 <= k <= 109
Solutions
Solution 1: Greedy
The longest binary subsequence must include all the 0s in the original string. On this basis, we traverse s from right to left. If we encounter a 1, we check if adding this 1 to the subsequence keeps the binary number v ≤ k.
The time complexity is O(n), where n is the length of the string s. The space complexity is O(1).
PythonJavaC++GoTypeScriptJavaScriptC#Rust
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(code-box)
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;
}
}(code-box)
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;
}
};(code-box)
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
}(code-box)
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;
}(code-box)
/**
* @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;
};(code-box)
public 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[i] == '0') {
++ans;
} else if (ans < 30 && (v | 1 << ans) <= k) {
v |= 1 << ans;
++ans;
}
}
return ans;
}
}(code-box)
impl Solution {
pub fn longest_subsequence(s: String, k: i32) -> i32 {
let mut ans = 0;
let mut v = 0;
let s = s.as_bytes();
for i in (0..s.len()).rev() {
if s[i] == b'0' {
ans += 1;
} else if ans < 30 && (v | (1 << ans)) <= k {
v |= 1 << ans;
ans += 1;
}
}
ans
}
}(code-box)
