# Maximum distance between two 1’s in Binary representation of N

Given a number N, the task is to find the maximum distance between two 1’s in the binary representation of given N. Print -1 if binary representation contains less than two 1’s.

Examples:

```Input: N = 131
Output: 6
131 in binary = 10000011.
The maximum distance between two 1's = 6.

Input: N = 8
Output: -1
8 in binary = 01000.
It contains less than two 1's.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• First find the binary representation of N.
• For each bit calculated, check if its a ‘1’.
• Store the index of first ‘1’ found in first_1, and the last ‘1’ found in last_1
• Then check if the last_1 is less than or equal to first_1. It will be the case when N is a power of 2. Hence print -1 in this case.
• In any other case, find the difference between the last_1 and first_1. This will be the required distance.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the ` `// Maximum distance between two 1's ` `// in Binary representation of N ` ` `  `#include ` `using` `namespace` `std; ` ` `  `int` `longest_gap(``int` `N) ` `{ ` ` `  `    ``int` `distance = 0, count = 0, ` `        ``first_1 = -1, last_1 = -1; ` ` `  `    ``// Compute the binary representation ` `    ``while` `(N) { ` ` `  `        ``count++; ` ` `  `        ``int` `r = N & 1; ` ` `  `        ``if` `(r == 1) { ` `            ``first_1 = first_1 == -1 ` `                          ``? count ` `                          ``: first_1; ` `            ``last_1 = count; ` `        ``} ` ` `  `        ``N = N / 2; ` `    ``} ` ` `  `    ``// if N is a power of 2 ` `    ``// then return -1 ` `    ``if` `(last_1 <= first_1) { ` `        ``return` `-1; ` `    ``} ` `    ``// else find the distance ` `    ``// between the first position of 1 ` `    ``// and last position of 1 ` `    ``else` `{ ` `        ``distance = (last_1 - first_1 - 1); ` `        ``return` `distance; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 131; ` `    ``cout << longest_gap(N) << endl; ` ` `  `    ``N = 8; ` `    ``cout << longest_gap(N) << endl; ` ` `  `    ``N = 17; ` `    ``cout << longest_gap(N) << endl; ` ` `  `    ``N = 33; ` `    ``cout << longest_gap(N) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find the  ` `// Maximum distance between two 1's  ` `// in Binary representation of N  ` `class` `GFG ` `{ ` `    ``static` `int` `longest_gap(``int` `N)  ` `    ``{  ` `        ``int` `distance = ``0``, count = ``0``,  ` `            ``first_1 = -``1``, last_1 = -``1``;  ` `     `  `        ``// Compute the binary representation  ` `        ``while` `(N != ``0``)  ` `        ``{  ` `            ``count++;  ` `     `  `            ``int` `r = N & ``1``;  ` `     `  `            ``if` `(r == ``1``)  ` `            ``{  ` `                ``first_1 = first_1 == -``1` `?  ` `                                  ``count : first_1;  ` `                ``last_1 = count;  ` `            ``}  ` `            ``N = N / ``2``;  ` `        ``}  ` `     `  `        ``// if N is a power of 2  ` `        ``// then return -1  ` `        ``if` `(last_1 <= first_1)  ` `        ``{  ` `            ``return` `-``1``;  ` `        ``}  ` `         `  `        ``// else find the distance  ` `        ``// between the first position of 1  ` `        ``// and last position of 1  ` `        ``else` `        ``{  ` `            ``distance = (last_1 - first_1 - ``1``);  ` `            ``return` `distance;  ` `        ``}  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{  ` `        ``int` `N = ``131``;  ` `        ``System.out.println(longest_gap(N));  ` `     `  `        ``N = ``8``;  ` `        ``System.out.println(longest_gap(N));  ` `     `  `        ``N = ``17``;  ` `        ``System.out.println(longest_gap(N));  ` `     `  `        ``N = ``33``;  ` `        ``System.out.println(longest_gap(N));  ` `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 program to find the ` `# Maximum distance between two 1's ` `# in Binary representation of N ` `def` `longest_gap(N): ` ` `  `    ``distance ``=` `0` `    ``count ``=` `0` `    ``first_1 ``=` `-``1` `    ``last_1 ``=` `-``1` ` `  `    ``# Compute the binary representation ` `    ``while` `(N > ``0``): ` `        ``count ``+``=` `1` ` `  `        ``r ``=` `N & ``1` ` `  `        ``if` `(r ``=``=` `1``): ` `            ``if` `first_1 ``=``=` `-``1``: ` `                ``first_1 ``=` `count ` `            ``else``: ` `                ``first_1 ``=` `first_1 ` ` `  `            ``last_1 ``=` `count ` ` `  `        ``N ``=` `N ``/``/` `2` ` `  `    ``# if N is a power of 2 ` `    ``# then return -1 ` `    ``if` `(last_1 <``=` `first_1): ` `        ``return` `-``1` `         `  `    ``# else find the distance ` `    ``# between the first position of 1 ` `    ``# and last position of 1 ` `    ``else``: ` `        ``distance ``=` `last_1 ``-` `first_1 ``-` `1` `        ``return` `distance ` ` `  `# Driver code ` `N ``=` `131` `print``(longest_gap(N)) ` ` `  `N ``=` `8` `print``(longest_gap(N)) ` ` `  `N ``=` `17` `print``(longest_gap(N)) ` ` `  `N ``=` `33` `print``(longest_gap(N)) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# program to find the  ` `// Maximum distance between two 1's  ` `// in Binary representation of N  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``static` `int` `longest_gap(``int` `N)  ` `    ``{  ` `        ``int` `distance = 0, count = 0,  ` `            ``first_1 = -1, last_1 = -1;  ` `     `  `        ``// Compute the binary representation  ` `        ``while` `(N != 0)  ` `        ``{  ` `            ``count++;  ` `     `  `            ``int` `r = N & 1;  ` `     `  `            ``if` `(r == 1)  ` `            ``{  ` `                ``first_1 = first_1 == -1 ?  ` `                                  ``count : first_1;  ` `                ``last_1 = count;  ` `            ``}  ` `            ``N = N / 2;  ` `        ``}  ` `     `  `        ``// if N is a power of 2  ` `        ``// then return -1  ` `        ``if` `(last_1 <= first_1)  ` `        ``{  ` `            ``return` `-1;  ` `        ``}  ` `         `  `        ``// else find the distance  ` `        ``// between the first position of 1  ` `        ``// and last position of 1  ` `        ``else` `        ``{  ` `            ``distance = (last_1 - first_1 - 1);  ` `            ``return` `distance;  ` `        ``}  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main (String []args)  ` `    ``{  ` `        ``int` `N = 131;  ` `        ``Console.WriteLine(longest_gap(N));  ` `     `  `        ``N = 8;  ` `        ``Console.WriteLine(longest_gap(N));  ` `     `  `        ``N = 17;  ` `        ``Console.WriteLine(longest_gap(N));  ` `     `  `        ``N = 33;  ` `        ``Console.WriteLine(longest_gap(N));  ` `    ``}  ` `} ` ` `  `// This code is contributed by Arnab Kundu `

Output:

```6
-1
3
4
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.