# 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)

My Personal Notes arrow_drop_up