# Find next greater element with no consecutive 1 in it’s binary representation

Last Updated : 19 Mar, 2022

Given Q queries where each query consists of an integer N and the task is to find the smallest integer greater than N such that there are no consecutive 1s in its binary representation.

Examples:

Input: Q[] = {4, 6}
Output:

8

Input: Q[] = {50, 23, 456}
Output:
64
32
512

Approach: Store all the numbers in a list whose binary representation does not contain consecutive 1s upto a fixed limit. Now for every given N, find the next greater element in the list generated previously using binary search.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `const` `int` `MAX = 100000;`   `// To store the pre-computed integers` `vector<``int``> v;`   `// Function that returns true if the` `// binary representation of x contains` `// consecutive 1s` `int` `consecutiveOnes(``int` `x)` `{`   `    ``// To store the previous bit` `    ``int` `p = 0;` `    ``while` `(x > 0) {`   `        ``// Check whether the previous bit` `        ``// and the current bit are both 1` `        ``if` `(x % 2 == 1 and p == 1)` `            ``return` `true``;`   `        ``// Update previous bit` `        ``p = x % 2;`   `        ``// Go to the next bit` `        ``x /= 2;` `    ``}` `    ``return` `false``;` `}`   `// Function to pre-compute the` `// valid numbers from 0 to MAX` `void` `preCompute()` `{` `    ``// Store all the numbers which do` `    ``// not have consecutive 1s` `    ``for` `(``int` `i = 0; i <= MAX; i++) {` `        ``if` `(!consecutiveOnes(i))` `            ``v.push_back(i);` `    ``}` `}`   `// Function to return the minimum` `// number greater than n which does` `// not contain consecutive 1s` `int` `nextValid(``int` `n)` `{` `    ``// Search for the next greater element` `    ``// with no consecutive 1s` `    ``int` `it = upper_bound(v.begin(),` `                         ``v.end(), n)` `             ``- v.begin();` `    ``int` `val = v[it];` `    ``return` `val;` `}`   `// Function to perform the queries` `void` `performQueries(``int` `queries[], ``int` `q)` `{` `    ``for` `(``int` `i = 0; i < q; i++)` `        ``cout << nextValid(queries[i]) << ``"\n"``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `queries[] = { 4, 6 };` `    ``int` `q = ``sizeof``(queries) / ``sizeof``(``int``);`   `    ``// Pre-compute the numbers` `    ``preCompute();`   `    ``// Perform the queries` `    ``performQueries(queries, q);`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG{` `    `  `static` `int` `MAX = ``100000``;`   `// To store the pre-computed integers ` `static` `ArrayList v = ``new` `ArrayList();`   `public` `static` `int` `upper_bound(ArrayList ar, ` `                              ``int` `k)` `{` `    ``int` `s = ``0``;` `    ``int` `e = ar.size();` `    `  `    ``while` `(s != e)` `    ``{` `        ``int` `mid = s + e >> ``1``;` `        `  `        ``if` `(ar.get(mid) <= k)` `        ``{` `            ``s = mid + ``1``;` `        ``}` `        ``else` `        ``{` `            ``e = mid;` `        ``}` `    ``}` `    `  `    ``if` `(s == ar.size())` `    ``{` `        ``return` `-``1``;` `    ``}` `    ``return` `s;` `}`   `// Function that returns true if the ` `// binary representation of x contains ` `// consecutive 1s` `static` `int` `consecutiveOnes(``int` `x)` `{` `    `  `    ``// To store the previous bit` `    ``int` `p = ``0``;` `    `  `    ``while` `(x > ``0``)` `    ``{` `        `  `        ``// Check whether the previous bit ` `        ``// and the current bit are both 1 ` `        ``if` `(x % ``2` `== ``1` `&& p == ``1``)` `        ``{` `            ``return` `1``;` `        ``}` `        `  `        ``// Update previous bit` `        ``p = x % ``2``;` `        `  `        ``// Go to the next bit` `        ``x /= ``2``; ` `    ``}` `    ``return` `0``;` `}`   `// Function to pre-compute the ` `// valid numbers from 0 to MAX ` `static` `void` `preCompute()` `{` `    `  `    ``// Store all the numbers which do ` `    ``// not have consecutive 1s ` `    ``for``(``int` `i = ``0``; i <= MAX; i++)` `    ``{` `        ``if` `(consecutiveOnes(i) == ``0``)` `        ``{` `            ``v.add(i);` `        ``}` `    ``}` `}`   `// Function to return the minimum ` `// number greater than n which does ` `// not contain consecutive 1s ` `static` `int` `nextValid(``int` `n)` `{` `    `  `    ``// Search for the next greater element ` `    ``// with no consecutive 1s ` `    ``int` `it = upper_bound(v,n);` `    ``int` `val = v.get(it);` `    ``return` `val;` `}`   `// Function to perform the queries ` `static` `void` `performQueries(``int` `queries[], ``int` `q)` `{` `    ``for``(``int` `i = ``0``; i < q; i++)` `    ``{` `        ``System.out.println(nextValid(queries[i]));` `    ``}` `}`   `// Driver code ` `public` `static` `void` `main(String[] args) ` `{` `    ``int` `queries[] = { ``4``, ``6` `};` `    ``int` `q = queries.length;` `    `  `    ``// Pre-compute the numbers ` `    ``preCompute();` `    `  `    ``// Perform the queries` `    ``performQueries(queries, q);` `}` `}`   `// This code is contributed by rag2127`

## Python3

 `# Python3 implementation of the approach` `from` `bisect ``import` `bisect_right as upper_bound`   `MAX` `=` `100000`   `# To store the pre-computed integers` `v ``=` `[]`   `# Function that returns true if the` `# binary representation of x contains` `# consecutive 1s` `def` `consecutiveOnes(x):`   `    ``# To store the previous bit` `    ``p ``=` `0` `    ``while` `(x > ``0``):`   `        ``# Check whether the previous bit` `        ``# and the current bit are both 1` `        ``if` `(x ``%` `2` `=``=` `1` `and` `p ``=``=` `1``):` `            ``return` `True`   `        ``# Update previous bit` `        ``p ``=` `x ``%` `2`   `        ``# Go to the next bit` `        ``x ``/``/``=` `2`   `    ``return` `False`   `# Function to pre-compute the` `# valid numbers from 0 to MAX` `def` `preCompute():` `    `  `    ``# Store all the numbers which do` `    ``# not have consecutive 1s` `    ``for` `i ``in` `range``(``MAX` `+` `1``):` `        ``if` `(consecutiveOnes(i) ``=``=` `0``):` `            ``v.append(i)`   `# Function to return the minimum` `# number greater than n which does` `# not contain consecutive 1s` `def` `nextValid(n):` `    `  `    ``# Search for the next greater element` `    ``# with no consecutive 1s` `    ``it ``=` `upper_bound(v, n)` `    ``val ``=` `v[it]` `    ``return` `val`   `# Function to perform the queries` `def` `performQueries(queries, q):` `    ``for` `i ``in` `range``(q):` `        ``print``(nextValid(queries[i]))`   `# Driver code` `queries ``=` `[``4``, ``6``]` `q ``=` `len``(queries)`   `# Pre-compute the numbers` `preCompute()`   `# Perform the queries` `performQueries(queries, q)`   `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `static` `int` `MAX = 100000;`   `// To store the pre-computed integers ` `static` `List<``int``> v = ``new` `List<``int``>();`   `static` `int` `upper_bound(List<``int``> ar, ``int` `k)` `{` `    ``int` `s = 0;` `    ``int` `e = ar.Count;` `    `  `    ``while` `(s != e)` `    ``{` `        ``int` `mid = s + e >> 1;` `     `  `        ``if` `(ar[mid] <= k)` `        ``{` `            ``s = mid + 1;` `        ``}` `        ``else` `        ``{` `            ``e = mid;` `        ``}` `    ``}` ` `  `    ``if` `(s == ar.Count)` `    ``{` `        ``return` `-1;` `    ``}` `    ``return` `s;` `}`   `// Function that returns true if the ` `// binary representation of x contains ` `// consecutive 1s` `static` `int` `consecutiveOnes(``int` `x)` `{` `    `  `    ``// To store the previous bit` `    ``int` `p = 0;` ` `  `    ``while` `(x > 0)` `    ``{` `        `  `        ``// Check whether the previous bit ` `        ``// and the current bit are both 1 ` `        ``if` `(x % 2 == 1 && p == 1)` `        ``{` `            ``return` `1;` `        ``}` `     `  `        ``// Update previous bit` `        ``p = x % 2;` `     `  `        ``// Go to the next bit` `        ``x /= 2; ` `    ``}` `    ``return` `0;` `}`   `// Function to pre-compute the ` `// valid numbers from 0 to MAX ` `static` `void` `preCompute()` `{` `    `  `    ``// Store all the numbers which do ` `    ``// not have consecutive 1s ` `    ``for``(``int` `i = 0; i <= MAX; i++)` `    ``{` `        ``if` `(consecutiveOnes(i) == 0)` `        ``{` `            ``v.Add(i);` `        ``}` `    ``}` `}`   `// Function to return the minimum ` `// number greater than n which does ` `// not contain consecutive 1s ` `static` `int` `nextValid(``int` `n)` `{` `    `  `    ``// Search for the next greater element ` `    ``// with no consecutive 1s ` `    ``int` `it = upper_bound(v, n);` `    ``int` `val = v[it];` `    ``return` `val;` `}`   `// Function to perform the queries ` `static` `void` `performQueries(``int``[] queries, ``int` `q)` `{` `    ``for``(``int` `i = 0; i < q; i++)` `    ``{` `        ``Console.WriteLine(nextValid(queries[i]));` `    ``}` `}`   `// Driver code ` `static` `public` `void` `Main()` `{` `    ``int``[] queries = { 4, 6 };` `    ``int` `q = queries.Length;` `    `  `    ``// Pre-compute the numbers ` `    ``preCompute();` `    `  `    ``// Perform the queries` `    ``performQueries(queries, q);` `}` `}`   `// This code is contributed by avanitrachhadiya2155`

## Javascript

 ``

Output:

```5
8```

Time Complexity: O(MAX * log MAX)

Auxiliary Space: O(MAX)