Given two integers x and n, the task is to search for the first consecutive stream of 1s (in the x’s 32-bit binary representation) which is greater than or equal to n in length and return its position. If no such string exists then return -1.
Examples:
Input: x = 35, n = 2
Output: 31
Binary representation of 35 is 00000000000000000000000000100011 and two consecutive 1’s are present at position 31.
Input: x = 32, n = 3
Output: -1
32 = 00000000000000000000000000100000 in binary and it does not have a sub-string of 3 consecutive 1’s.
Approach: Use Bitwise operation to calculate the no. of leading zeros in the number and then use it to find the position from where we need to start searching for consecutive 1’s. Skip the search for leading zeros.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countLeadingZeros(int x)
{
unsigned y;
int n;
n = 32;
y = x >> 16;
if (y != 0) {
n = n - 16;
x = y;
}
y = x >> 8;
if (y != 0) {
n = n - 8;
x = y;
}
y = x >> 4;
if (y != 0) {
n = n - 4;
x = y;
}
y = x >> 2;
if (y != 0) {
n = n - 2;
x = y;
}
y = x >> 1;
if (y != 0)
return n - 2;
return n - x;
}
int FindStringof1s(unsigned x, int n)
{
int k, p;
p = 0;
while (x != 0) {
k = countLeadingZeros(x);
x = x << k;
p = p + k;
k = countLeadingZeros(~x);
if (k >= n)
return p + 1;
x = x << k;
p = p + k;
}
return -1;
}
int main()
{
int x = 35;
int n = 2;
cout << FindStringof1s(x, n);
}
|
Java
import java.io.*;
class GFG {
static int countLeadingZeros(int x)
{
int y;
int n;
n = 32;
y = x >> 16;
if (y != 0) {
n = n - 16;
x = y;
}
y = x >> 8;
if (y != 0) {
n = n - 8;
x = y;
}
y = x >> 4;
if (y != 0) {
n = n - 4;
x = y;
}
y = x >> 2;
if (y != 0) {
n = n - 2;
x = y;
}
y = x >> 1;
if (y != 0)
return n - 2;
return n - x;
}
static int FindStringof1s(int x, int n)
{
int k, p;
p = 0;
while (x != 0) {
k = countLeadingZeros(x);
x = x << k;
p = p + k;
k = countLeadingZeros(~x);
if (k >= n)
return p + 1;
x = x << k;
p = p + k;
}
return -1;
}
public static void main (String[] args) {
int x = 35;
int n = 2;
System.out.println(FindStringof1s(x, n));
}
}
|
C#
using System;
public class GFG{
static int countLeadingZeros(int x)
{
int y;
int n;
n = 32;
y = x >> 16;
if (y != 0) {
n = n - 16;
x = y;
}
y = x >> 8;
if (y != 0) {
n = n - 8;
x = y;
}
y = x >> 4;
if (y != 0) {
n = n - 4;
x = y;
}
y = x >> 2;
if (y != 0) {
n = n - 2;
x = y;
}
y = x >> 1;
if (y != 0)
return n - 2;
return n - x;
}
static int FindStringof1s(int x, int n)
{
int k, p;
p = 0;
while (x != 0) {
k = countLeadingZeros(x);
x = x << k;
p = p + k;
k = countLeadingZeros(~x);
if (k >= n)
return p + 1;
x = x << k;
p = p + k;
}
return -1;
}
static public void Main (){
int x = 35;
int n = 2;
Console.WriteLine (FindStringof1s(x, n));
}
}
|
Javascript
<script>
function countLeadingZeros(x) {
let y;
let n;
n = 32;
y = x >> 16;
if (y != 0) {
n = n - 16;
x = y;
}
y = x >> 8;
if (y != 0) {
n = n - 8;
x = y;
}
y = x >> 4;
if (y != 0) {
n = n - 4;
x = y;
}
y = x >> 2;
if (y != 0) {
n = n - 2;
x = y;
}
y = x >> 1;
if (y != 0)
return n - 2;
return n - x;
}
function FindStringof1s(x, n) {
let k, p;
p = 0;
while (x != 0) {
k = countLeadingZeros(x);
x = x << k;
p = p + k;
k = countLeadingZeros(~x);
if (k >= n)
return p + 1;
x = x << k;
p = p + k;
}
return -1;
}
let x = 35;
let n = 2;
document.write(FindStringof1s(x, n));
</script>
|
Approach: Using predefined functions
x can be converted to a binary string using in-built methods, such as bitset<32>(x).to_string() in C++ STL, bin() in Python3, Integer.toBinary() in Java . And, a string of n 1s can be constructed, whose index in the binary string can be located using predefined functions such as find in C++ STL, index in Python3 and indexOf() in Java.
This approach can be summarized to the following steps:
1. Form the binary string equivalent of the number using in-built methods, such as bitset<32>(x).to_string() in C++ STL, bin() in Python3, Integer.toBinary() in Java.
2. Then, build a string consisting of n 1s, using in-built methods, such as string (n, ‘1’) in C++ STL, ‘1’ * n in Python3, and “1”.repeat(n) in Java.
3. Then, find the index of the string of n 1s in the binary string using in-built methods such as .find() in C++ STL, index() in Python3 and indexOf() in Java.
C++
#include <bits/stdc++.h>
using namespace std;
int FindStringof1s(unsigned x, int n)
{
string bin = bitset<32>(x).to_string();
string ones(n, '1');
auto pos = bin.find(ones);
if (pos != string::npos)
return pos + 1;
return -1;
}
int main()
{
int x = 35;
int n = 2;
cout << FindStringof1s(x, n);
}
|
Java
import java.util.Arrays;
public class GFG {
public static int FindStringof1s(int x, int n) {
String bin = String.format("%32s", Integer.toBinaryString(x)).replace(' ', '0');
char[] onesArray = new char[n];
Arrays.fill(onesArray, '1');
String ones = new String(onesArray);
int pos = bin.indexOf(ones);
if (pos != -1)
return pos + 1;
return -1;
}
public static void main(String[] args) {
int x = 35;
int n = 2;
System.out.println(FindStringof1s(x, n));
}
}
|
Python3
def FindStringof1s(x, n):
bin_ = bin(x).zfill(32)
ones = n * "1"
if ones in bin_:
return bin_.index(ones) + 1
return -1;
x = 35
n = 2
print(FindStringof1s(x, n))
|
C#
using System;
public class GFG
{
public static int FindStringof1s(uint x, int n)
{
string bin = Convert.ToString(x, 2).PadLeft(32, '0');
string ones = new string('1', n);
int pos = bin.IndexOf(ones);
if (pos != -1)
return pos + 1;
return -1;
}
public static void Main()
{
uint x = 35;
int n = 2;
Console.WriteLine(FindStringof1s(x, n));
}
}
|
Javascript
function FindStringof1s(x, n) {
let bin = x.toString(2).padStart(32, '0');
let ones = '1'.repeat(n);
let pos = bin.indexOf(ones);
if (pos != -1)
return pos + 1;
return -1;
}
let x = 35;
let n = 2;
console.log(FindStringof1s(x, n));
|
Time Complexity: O(log n)
Auxiliary Space: O(1)