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)
	{
		Counting task = 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)  
		*/
		task.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)
		*/
		task.consecutive_1s(6);
	}
}

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()
{
	Counting task = 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)  
			*/
	task.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)
			*/
	task.consecutive_1s(6);
	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)
	{
		Counting task = 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)  
				*/
		task.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)
				*/
		task.consecutive_1s(6);
	}
}

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()
{
	$task = 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)  
	*/
	$task->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)
	*/
	$task->consecutive_1s(6);
}
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() :
	task = 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)  
	# 		
	
	task.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)
	# 		
	
	task.consecutive_1s(6)

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() 
	task = Counting.new()
	#   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)  
	# 		
	
	task.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)
	# 		
	
	task.consecutive_1s(6)
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)  
		*/
		task.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)
		*/
		task.consecutive_1s(6);
	}
}

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
{
	var task: Counting = 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)  
	*/
	task.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)
	*/
	task.consecutive_1s(6);
}

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()
{
	let task: Counting = 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)  
	*/
	task.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)
	*/
	task.consecutive_1s(6);
}
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()
{
	var task = 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)  
	*/
	task.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)
	*/
	task.consecutive_1s(6);
}
main();

Output

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

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.

New Comment







© 2021, kalkicode.com, All rights reserved