Given K and a binary number, check if there exists k consecutive 1’s in the binary number. Examples:
Input: binary number = 101010101111
k = 4
Output: yes
Explanation: at the last 4 index there exists 4 consecutive 1’sInput: binary number = 11100000 k=5
Output: no
Explanation: There is a maximum of 3 consecutive 1’s in the given binary.
Approach: Create a new string with k 1’s. Using if condition check if there is new in s. In python if new in s: checks if there is any existence if new in s, hence returns true if there is else it returns a false. Below is the Python implementation of the above approach:
# Python program to check if there # is k consecutive 1's in a binary number # function to check if there are k # consecutive 1's def check(s,k):
# form a new string of k 1's
new = "1" * k
# if there is k 1's at any position
if new in s:
print "yes"
else :
print "no"
# driver code s = "10101001111"
k = 4
check(s, k) |
yes
Time Complexity : O(N)
Auxiliary Space : O(1)
Approach : Using find() method
# Python program to check if there # is k consecutive 1's in a binary number s = "10101001111"
k = 4
res = "NO"
if (s.find( "1" * k) ! = - 1 ):
res = "YES"
print (res)
|
YES
Time complexity: O(n), where n is the length of s.
Auxiliary space: O(1), as we are only using a constant amount of memory for the string s, the integer k, and the string res.
Another approach to solve this problem is to use a sliding window approach. In this approach, we can check for the presence of k consecutive 1’s by considering a window of size k and sliding it through the entire binary number.
Here is an example of how this approach can be implemented in Python:
def check_consecutive_ones(s, k):
for i in range ( len (s) - k + 1 ):
if all (s[i + j] = = "1" for j in range (k)):
return True
return False
s = "10101001111"
k = 4
if check_consecutive_ones(s, k):
print ( "Yes" )
else :
print ( "No" )
|
Yes
This approach uses a for loop to iterate through each possible starting index of a sequence of k 1’s in the binary string and then checks if all the subsequent characters in the string at those indices are 1’s using the all() function. If any sequence of k 1’s is found, the function returns True, otherwise, it returns False.
The time complexity of the check_consecutive_ones() function is O(n*k), where n is the length of the input string. This is because the function involves iterating through all the characters in the string and checking if there is a consecutive subsequence of k ones.
The Auxiliary Space of the check_consecutive_ones() function is O(k), The all() function returns True if all the elements in an iterable are True, and False otherwise.
Approach : Using replace() and len() methods
# Python program to check if there # is k consecutive 1's in a binary number s = "10101001111"
k = 4
a = "1" * k
res = "NO"
b = s.replace(a,"")
if ( len (b)! = len (s)):
res = "YES"
print (res)
|
YES
Time Complexity : O(N)
Auxiliary Space : O(N)
Approach : Using operator.contains() method
Check whether k consecutive 1’s are present in given binary string using operator.contains() method
# Python program to check if there # is k consecutive 1's in a binary number s = "10101001111"
k = 4
a = "1" * k
res = "NO"
import operator
if operator.contains(s,a):
res = "YES"
print (res)
|
YES
Time Complexity : O(N) where N is the length of s.
Auxiliary Space : O(1) as we are only using a constant amount of memory for the string s, the integer k, and the string res
Approach: Using a regular expression
- Imports the re module
- Sets the input binary string and the number of consecutive 1’s to check using tuple unpacking
- Searches for a pattern of k consecutive 1’s in the binary string using a regular expression with the re.search() function
- Sets the result to “YES” if the pattern is found, and “NO” if it is not, using a ternary operator
- Prints the result to the console.
import re
# Input binary string and number of consecutive 1's to check s = "10101001111"
k = 4
# Create regular expression pattern to match k consecutive 1's pattern = '1{' + str (k) + '}'
# Initialize result to "NO" res = "NO"
# Search for pattern in binary string if re.search(pattern, s):
# If pattern is found, set result to "YES"
res = "YES"
# Output the result print (res)
|
YES
Time Complexity: O(N) where N is the length of s.
Auxiliary Space: O(N) because the regular expression pattern is created based on the input value of k,.