# Count number with consecutive 1's in given length

Here given code implementation process.

``````// C program
// Count number with consecutive 1's in given length
#include <stdio.h>

// Count number of possible consecutive binary 1’s in given length
void consecutive_1s(int length)
{
if (length <= 0)
{
return;
}
int a[length];
int b[length];
// Set initial value
a[0] = 1;
b[0] = 1;
// Execute loop through by length
for (int i = 1; i < length; i++)
{
a[i] = a[i - 1] + b[i - 1];
b[i] = a[i - 1];
}
// Calculate final result
int result = (1 << length) - a[length - 1] - b[length - 1];
printf("\n Bit Length : %d", length);
// Display number of consecutive 1's
printf("\n Consecutive 1's : %d", result);
}
int main(int argc, char
const *argv[])
{
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
consecutive_1s(4);
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
consecutive_1s(6);
return 0;
}``````

#### Output

`````` Bit Length : 4
Consecutive 1's : 8
Bit Length : 6
Consecutive 1's : 43``````
``````/*
Java program
Count number with consecutive 1's in given length
*/
public class Counting
{
// Count number of possible consecutive binary 1’s in given length
public void consecutive_1s(int length)
{
if (length <= 0)
{
return;
}
int[] a = new int[length];
int[] b = new int[length];
// Set initial value
a[0] = 1;
b[0] = 1;
// Execute loop through by length
for (int i = 1; i < length; i++)
{
a[i] = a[i - 1] + b[i - 1];
b[i] = a[i - 1];
}
// Calculate final result
int result = (1 << length) - a[length - 1] - b[length - 1];
System.out.print("\n Bit Length  : " + length);
// Display number of consecutive 1's
System.out.print("\n Consecutive 1's : " + result);
}
public static void main(String[] args)
{
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
}
}``````

#### Output

`````` Bit Length  : 4
Consecutive 1's : 8
Bit Length  : 6
Consecutive 1's : 43``````
``````// Include header file
#include <iostream>
using namespace std;

/*
C++ program
Count number with consecutive 1's in given length
*/

class Counting
{
public:
// Count number of possible consecutive binary 1’s in given length
void consecutive_1s(int length)
{
if (length <= 0)
{
return;
}
int a[length];
int b[length];
// Set initial value
a[0] = 1;
b[0] = 1;
// Execute loop through by length
for (int i = 1; i < length; i++)
{
a[i] = a[i - 1] + b[i - 1];
b[i] = a[i - 1];
}
// Calculate final result
int result = (1 << length) - a[length - 1] - b[length - 1];
cout << "\n Bit Length  : " << length;
// Display number of consecutive 1's
cout << "\n Consecutive 1's : " << result;
}
};
int main()
{
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
return 0;
}``````

#### Output

`````` Bit Length  : 4
Consecutive 1's : 8
Bit Length  : 6
Consecutive 1's : 43``````
``````// Include namespace system
using System;
/*
C# program
Count number with consecutive 1's in given length
*/
public class Counting
{
// Count number of possible consecutive binary 1’s in given length
public void consecutive_1s(int length)
{
if (length <= 0)
{
return;
}
int[] a = new int[length];
int[] b = new int[length];
// Set initial value
a[0] = 1;
b[0] = 1;
// Execute loop through by length
for (int i = 1; i < length; i++)
{
a[i] = a[i - 1] + b[i - 1];
b[i] = a[i - 1];
}
// Calculate final result
int result = (1 << length) - a[length - 1] - b[length - 1];
Console.Write("\n Bit Length  : " + length);
// Display number of consecutive 1's
Console.Write("\n Consecutive 1's : " + result);
}
public static void Main(String[] args)
{
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
}
}``````

#### Output

`````` Bit Length  : 4
Consecutive 1's : 8
Bit Length  : 6
Consecutive 1's : 43``````
``````<?php
/*
Php program
Count number with consecutive 1's in given length
*/
class Counting
{
// Count number of possible consecutive binary 1’s in given length
public	function consecutive_1s(\$length)
{
if (\$length <= 0)
{
return;
}
\$a = array_fill(0, \$length, 0);
\$b = array_fill(0, \$length, 0);
// Set initial value
\$a[0] = 1;
\$b[0] = 1;
// Execute loop through by length
for (\$i = 1; \$i < \$length; \$i++)
{
\$a[\$i] = \$a[\$i - 1] + \$b[\$i - 1];
\$b[\$i] = \$a[\$i - 1];
}
// Calculate final result
\$result = (1 << \$length) - \$a[\$length - 1] - \$b[\$length - 1];
echo "\n Bit Length  : ". \$length;
// Display number of consecutive 1's
echo "\n Consecutive 1's : ". \$result;
}
}

function main()
{
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
}
main();``````

#### Output

`````` Bit Length  : 4
Consecutive 1's : 8
Bit Length  : 6
Consecutive 1's : 43``````
``````#   Python 3 program
#   Count number with consecutive 1's in given length

class Counting :
#  Count number of possible consecutive binary 1’s in given length
def consecutive_1s(self, length) :
if (length <= 0) :
return

a = [0] * (length)
b = [0] * (length)
#  Set initial value
a[0] = 1
b[0] = 1
i = 1
#  Execute loop through by length
while (i < length) :
a[i] = a[i - 1] + b[i - 1]
b[i] = a[i - 1]
i += 1

#  Calculate final result
result = (1 << length) - a[length - 1] - b[length - 1]
print("\n Bit Length  : ", length, end = "")
#  Display number of consecutive 1's
print("\n Consecutive 1's : ", result, end = "")

def main() :
#   bit length 4
#
# 		0 (0000)    1 (0001)
# 		2 (0010)    3 (0011)    4 (0100)
# 		5 (0101)    6 (0110)    7 (0111)
# 		8 (1000)    9 (1001)    10 (1010)
# 		11 (1011)   12 (1100)   13 (1101)
# 		14 (1110)   15 (1111)   16 (10000)
#

#  bit length 6
#
# 		0 (000000)  1 (000001)
# 		2 (000010)  3 (000011)  4 (000100)
# 		5 (000101)  6 (000110)  7 (000111)
# 		8 (001000)  9 (001001)  10 (001010)
# 		11 (001011) 12 (001100) 13 (001101)
# 		14 (001110) 15 (001111) 16 (010000)
# 		17 (010001) 18 (010010) 19 (010011)
# 		20 (010100) 21 (010101) 22 (010110)
# 		23 (010111) 24 (011000) 25 (011001)
# 		26 (011010) 27 (011011) 28 (011100)
# 		29 (011101) 30 (011110) 31 (011111)
# 		32 (100000) 33 (100001) 34 (100010)
# 		35 (100011) 36 (100100) 37 (100101)
# 		38 (100110) 39 (100111) 40 (101000)
# 		41 (101001) 42 (101010) 43 (101011)
# 		44 (101100) 45 (101101) 46 (101110)
# 		47 (101111) 48 (110000) 49 (110001)
# 		50 (110010) 51 (110011) 52 (110100)
# 		53 (110101) 54 (110110) 55 (110111)
# 		56 (111000) 57 (111001) 58 (111010)
# 		59 (111011) 60 (111100) 61 (111101)
# 		62 (111110) 63 (111111) 64 (1000000)
#

if __name__ == "__main__": main()``````

#### Output

`````` Bit Length  :  4
Consecutive 1's :  8
Bit Length  :  6
Consecutive 1's :  43``````
``````#   Ruby program
#   Count number with consecutive 1's in given length

class Counting
#  Count number of possible consecutive binary 1’s in given length
def consecutive_1s(length)
if (length <= 0)
return
end

a = Array.new(length) {0}
b = Array.new(length) {0}
#  Set initial value
a[0] = 1
b[0] = 1
i = 1
#  Execute loop through by length
while (i < length)
a[i] = a[i - 1] + b[i - 1]
b[i] = a[i - 1]
i += 1
end

#  Calculate final result
result = (1 << length) - a[length - 1] - b[length - 1]
print("\n Bit Length  : ", length)
#  Display number of consecutive 1's
print("\n Consecutive 1's : ", result)
end

end

def main()
#   bit length 4
#
# 		0 (0000)    1 (0001)
# 		2 (0010)    3 (0011)    4 (0100)
# 		5 (0101)    6 (0110)    7 (0111)
# 		8 (1000)    9 (1001)    10 (1010)
# 		11 (1011)   12 (1100)   13 (1101)
# 		14 (1110)   15 (1111)   16 (10000)
#

#  bit length 6
#
# 		0 (000000)  1 (000001)
# 		2 (000010)  3 (000011)  4 (000100)
# 		5 (000101)  6 (000110)  7 (000111)
# 		8 (001000)  9 (001001)  10 (001010)
# 		11 (001011) 12 (001100) 13 (001101)
# 		14 (001110) 15 (001111) 16 (010000)
# 		17 (010001) 18 (010010) 19 (010011)
# 		20 (010100) 21 (010101) 22 (010110)
# 		23 (010111) 24 (011000) 25 (011001)
# 		26 (011010) 27 (011011) 28 (011100)
# 		29 (011101) 30 (011110) 31 (011111)
# 		32 (100000) 33 (100001) 34 (100010)
# 		35 (100011) 36 (100100) 37 (100101)
# 		38 (100110) 39 (100111) 40 (101000)
# 		41 (101001) 42 (101010) 43 (101011)
# 		44 (101100) 45 (101101) 46 (101110)
# 		47 (101111) 48 (110000) 49 (110001)
# 		50 (110010) 51 (110011) 52 (110100)
# 		53 (110101) 54 (110110) 55 (110111)
# 		56 (111000) 57 (111001) 58 (111010)
# 		59 (111011) 60 (111100) 61 (111101)
# 		62 (111110) 63 (111111) 64 (1000000)
#

end

main()``````

#### Output

`````` Bit Length  : 4
Consecutive 1's : 8
Bit Length  : 6
Consecutive 1's : 43``````
``````/*
Scala program
Count number with consecutive 1's in given length
*/
class Counting
{
// Count number of possible consecutive binary 1’s in given length
def consecutive_1s(length: Int): Unit = {
if (length <= 0)
{
return;
}
var a: Array[Int] = Array.fill[Int](length)(0);
var b: Array[Int] = Array.fill[Int](length)(0);
// Set initial value
a(0) = 1;
b(0) = 1;
var i: Int = 1;
// Execute loop through by length
while (i < length)
{
a(i) = a(i - 1) + b(i - 1);
b(i) = a(i - 1);
i += 1;
}
// Calculate final result
var result: Int = (1 << length) - a(length - 1) - b(length - 1);
print("\n Bit Length  : " + length);
// Display number of consecutive 1's
print("\n Consecutive 1's : " + result);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Counting = new Counting();
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
}
}``````

#### Output

`````` Bit Length  : 4
Consecutive 1's : 8
Bit Length  : 6
Consecutive 1's : 43``````
``````/*
Kotlin program
Count number with consecutive 1's in given length
*/
class Counting
{
// Count number of possible consecutive binary 1’s in given length
fun consecutive_1s(length: Int): Unit
{
if (length <= 0)
{
return;
}
var a: Array < Int > = Array(length)
{
0
};
var b: Array < Int > = Array(length)
{
0
};
// Set initial value
a[0] = 1;
b[0] = 1;
var i: Int = 1;
// Execute loop through by length
while (i < length)
{
a[i] = a[i - 1] + b[i - 1];
b[i] = a[i - 1];
i += 1;
}
// Calculate final result
var result: Int = (1 shl length) - a[length - 1] - b[length - 1];
print("\n Bit Length  : " + length);
// Display number of consecutive 1's
print("\n Consecutive 1's : " + result);
}
}
fun main(args: Array < String > ): Unit
{
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
}``````

#### Output

`````` Bit Length  : 4
Consecutive 1's : 8
Bit Length  : 6
Consecutive 1's : 43``````
``````/*
Swift 4 program
Count number with consecutive 1"s in given length
*/
class Counting
{
// Count number of possible consecutive binary 1’s in given length
func consecutive_1s(_ length: Int)
{
if (length <= 0)
{
return;
}
var a: [Int] = Array(repeating: 0, count: length);
var b: [Int] = Array(repeating: 0, count: length);
// Set initial value
a[0] = 1;
b[0] = 1;
var i: Int = 1;
// Execute loop through by length
while (i < length)
{
a[i] = a[i - 1] + b[i - 1];
b[i] = a[i - 1];
i += 1;
}
// Calculate final result
let result: Int = (1 << length) - a[length - 1] - b[length - 1];
print("\n Bit Length  : ", length, terminator: "");
// Display number of consecutive 1's
print("\n Consecutive 1's : ", result, terminator: "");
}
}
func main()
{
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
}
main();``````

#### Output

`````` Bit Length  :  4
Consecutive 1's :  8
Bit Length  :  6
Consecutive 1's :  43``````
``````/*
Node Js program
Count number with consecutive 1's in given length
*/
class Counting
{
// Count number of possible consecutive binary 1’s in given length
consecutive_1s(length)
{
if (length <= 0)
{
return;
}
var a = Array(length).fill(0);
var b = Array(length).fill(0);
// Set initial value
a[0] = 1;
b[0] = 1;
// Execute loop through by length
for (var i = 1; i < length; i++)
{
a[i] = a[i - 1] + b[i - 1];
b[i] = a[i - 1];
}
// Calculate final result
var result = (1 << length) - a[length - 1] - b[length - 1];
process.stdout.write("\n Bit Length  : " + length);
// Display number of consecutive 1's
process.stdout.write("\n Consecutive 1's : " + result);
}
}

function main()
{
//  bit length 4
/*
0 (0000)    1 (0001)
2 (0010)    3 (0011)    4 (0100)
5 (0101)    6 (0110)    7 (0111)
8 (1000)    9 (1001)    10 (1010)
11 (1011)   12 (1100)   13 (1101)
14 (1110)   15 (1111)   16 (10000)
*/
// bit length 6
/*
0 (000000)  1 (000001)
2 (000010)  3 (000011)  4 (000100)
5 (000101)  6 (000110)  7 (000111)
8 (001000)  9 (001001)  10 (001010)
11 (001011) 12 (001100) 13 (001101)
14 (001110) 15 (001111) 16 (010000)
17 (010001) 18 (010010) 19 (010011)
20 (010100) 21 (010101) 22 (010110)
23 (010111) 24 (011000) 25 (011001)
26 (011010) 27 (011011) 28 (011100)
29 (011101) 30 (011110) 31 (011111)
32 (100000) 33 (100001) 34 (100010)
35 (100011) 36 (100100) 37 (100101)
38 (100110) 39 (100111) 40 (101000)
41 (101001) 42 (101010) 43 (101011)
44 (101100) 45 (101101) 46 (101110)
47 (101111) 48 (110000) 49 (110001)
50 (110010) 51 (110011) 52 (110100)
53 (110101) 54 (110110) 55 (110111)
56 (111000) 57 (111001) 58 (111010)
59 (111011) 60 (111100) 61 (111101)
62 (111110) 63 (111111) 64 (1000000)
*/
}
main();``````

#### Output

`````` Bit Length  : 4
Consecutive 1's : 8
Bit Length  : 6
Consecutive 1's : 43``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.