Skip to main content

Print first n numbers with exactly two set bits

Here given code implementation process.

// C Program
// Print first n numbers with exactly two set bits
#include <stdio.h>

// Print the initial n numbers with only two active bits
void twoSetBits(int n)
{
	if (n <= 0)
	{
		return;
	}
	printf("\n  N : %d \n", n);
	int bit1 = 1;
	int bit2 = 0;
	int counter = 0;
	// Execute loop until count value is less than n
	while (counter < n)
	{
		while (bit2 < bit1 && counter < n)
		{
			// Display the  number which have two active bits
			printf("  %d", ((1 << bit1) | (1 << bit2)));
			bit2++;
			// Increase resultant count
			counter++;
		}
		bit1++;
		// Reset bit two
		bit2 = 0;
	}
	printf("\n");
}
int main()
{
	/*
	    First few numbers which have two active bits 
	    ---------------    
	    3   : (11)
	    5   : (101)
	    6   : (110)
	    9   : (1001)
	    10  : (1010)
	    12  : (1100)
	    17  : (10001)
	    18  : (10010)
	    20  : (10100)
	    24  : (11000)
	    33  : (100001)
	    34  : (100010)
	    36  : (100100)
	    40  : (101000)
	    48  : (110000)
	    65  : (1000001)
	    66  : (1000010)
	    68  : (1000100)
	    72  : (1001000)
	    80  : (1010000)
	*/
	// Test
	twoSetBits(10);
	return 0;
}

Output

  N : 10
  3  5  6  9  10  12  17  18  20  24
/*
  Java Program
  Print first n numbers with exactly two set bits
*/
public class Activity
{
    // Print the initial n numbers with only two active bits
    public void twoSetBits(int n)
    {
        if (n <= 0)
        {
            return;
        }
        System.out.print("\n N : " + n + " \n");
        int bit1 = 1;
        int bit2 = 0;
        int counter = 0;
        while (counter < n)
        {
            while (bit2 < bit1 && counter < n)
            {
                // Display the  number which have two active bits
                System.out.print(" " + ((1 << bit1) | (1 << bit2)) );
                bit2++;
                counter++;
            }
            bit1++;
            // Reset bit two
            bit2 = 0;
        }
        System.out.print("\n");
    }
    public static void main(String[] args)
    {
        Activity task = new Activity();

        /*
            First few numbers which have two active bits 
            ---------------    
            3   : (11)
            5   : (101)
            6   : (110)
            9   : (1001)
            10  : (1010)
            12  : (1100)
            17  : (10001)
            18  : (10010)
            20  : (10100)
            24  : (11000)
            33  : (100001)
            34  : (100010)
            36  : (100100)
            40  : (101000)
            48  : (110000)
            65  : (1000001)
            66  : (1000010)
            68  : (1000100)
            72  : (1001000)
            80  : (1010000)
        */
        task.twoSetBits(10);
    }
}

Output

 N : 10
 3 5 6 9 10 12 17 18 20 24
// Include header file
#include <iostream>

using namespace std;
/*
  C++ Program
  Print first n numbers with exactly two set bits
*/
class Activity
{
	public:
		// Print the initial n numbers with only two active bits
		void twoSetBits(int n)
		{
			if (n <= 0)
			{
				return;
			}
			cout << "\n N : " << n << " \n";
			int bit1 = 1;
			int bit2 = 0;
			int counter = 0;
			while (counter < n)
			{
				while (bit2 < bit1 && counter < n)
				{
					// Display the  number which have two active bits
					cout << " " << ((1 << bit1) | (1 << bit2));
					bit2++;
					counter++;
				}
				bit1++;
				// Reset bit two
				bit2 = 0;
			}
			cout << "\n";
		}
};
int main()
{
	Activity task = Activity();
	/*
	    First few numbers which have two active bits 
	    ---------------    
	    3   : (11)
	    5   : (101)
	    6   : (110)
	    9   : (1001)
	    10  : (1010)
	    12  : (1100)
	    17  : (10001)
	    18  : (10010)
	    20  : (10100)
	    24  : (11000)
	    33  : (100001)
	    34  : (100010)
	    36  : (100100)
	    40  : (101000)
	    48  : (110000)
	    65  : (1000001)
	    66  : (1000010)
	    68  : (1000100)
	    72  : (1001000)
	    80  : (1010000) 
	*/
	task.twoSetBits(10);
	return 0;
}

Output

 N : 10
 3 5 6 9 10 12 17 18 20 24
// Include namespace system
using System;
/*
  C# Program
  Print first n numbers with exactly two set bits
*/
public class Activity
{
	// Print the initial n numbers with only two active bits
	public void twoSetBits(int n)
	{
		if (n <= 0)
		{
			return;
		}
		Console.Write("\n N : " + n + " \n");
		int bit1 = 1;
		int bit2 = 0;
		int counter = 0;
		while (counter < n)
		{
			while (bit2 < bit1 && counter < n)
			{
				// Display the  number which have two active bits
				Console.Write(" " + ((1 << bit1) | (1 << bit2)));
				bit2++;
				counter++;
			}
			bit1++;
			// Reset bit two
			bit2 = 0;
		}
		Console.Write("\n");
	}
	public static void Main(String[] args)
	{
		Activity task = new Activity();
		/*
		    First few numbers which have two active bits 
		    ---------------    
		    3   : (11)
		    5   : (101)
		    6   : (110)
		    9   : (1001)
		    10  : (1010)
		    12  : (1100)
		    17  : (10001)
		    18  : (10010)
		    20  : (10100)
		    24  : (11000)
		    33  : (100001)
		    34  : (100010)
		    36  : (100100)
		    40  : (101000)
		    48  : (110000)
		    65  : (1000001)
		    66  : (1000010)
		    68  : (1000100)
		    72  : (1001000)
		    80  : (1010000) 
		*/
		task.twoSetBits(10);
	}
}

Output

 N : 10
 3 5 6 9 10 12 17 18 20 24
<?php
/*
  Php Program
  Print first n numbers with exactly two set bits
*/
class Activity
{
	// Print the initial n numbers with only two active bits
	public	function twoSetBits($n)
	{
		if ($n <= 0)
		{
			return;
		}
		echo "\n N : ". $n ." \n";
		$bit1 = 1;
		$bit2 = 0;
		$counter = 0;
		while ($counter < $n)
		{
			while ($bit2 < $bit1 && $counter < $n)
			{
				// Display the  number which have two active bits
				echo " ". ((1 << $bit1) | (1 << $bit2));
				$bit2++;
				$counter++;
			}
			$bit1++;
			// Reset bit two
			$bit2 = 0;
		}
		echo "\n";
	}
}

function main()
{
	$task = new Activity();
	/*
	    First few numbers which have two active bits 
	    ---------------    
	    3   : (11)
	    5   : (101)
	    6   : (110)
	    9   : (1001)
	    10  : (1010)
	    12  : (1100)
	    17  : (10001)
	    18  : (10010)
	    20  : (10100)
	    24  : (11000)
	    33  : (100001)
	    34  : (100010)
	    36  : (100100)
	    40  : (101000)
	    48  : (110000)
	    65  : (1000001)
	    66  : (1000010)
	    68  : (1000100)
	    72  : (1001000)
	    80  : (1010000) 
	*/
	$task->twoSetBits(10);
}
main();

Output

 N : 10
 3 5 6 9 10 12 17 18 20 24
/*
  Node Js Program
  Print first n numbers with exactly two set bits
*/
class Activity
{
	// Print the initial n numbers with only two active bits
	twoSetBits(n)
	{
		if (n <= 0)
		{
			return;
		}
		process.stdout.write("\n N : " + n + " \n");
		var bit1 = 1;
		var bit2 = 0;
		var counter = 0;
		while (counter < n)
		{
			while (bit2 < bit1 && counter < n)
			{
				// Display the  number which have two active bits
				process.stdout.write(" " + ((1 << bit1) | (1 << bit2)));
				bit2++;
				counter++;
			}
			bit1++;
			// Reset bit two
			bit2 = 0;
		}
		process.stdout.write("\n");
	}
}

function main()
{
	var task = new Activity();
	/*
	    First few numbers which have two active bits 
	    ---------------    
	    3   : (11)
	    5   : (101)
	    6   : (110)
	    9   : (1001)
	    10  : (1010)
	    12  : (1100)
	    17  : (10001)
	    18  : (10010)
	    20  : (10100)
	    24  : (11000)
	    33  : (100001)
	    34  : (100010)
	    36  : (100100)
	    40  : (101000)
	    48  : (110000)
	    65  : (1000001)
	    66  : (1000010)
	    68  : (1000100)
	    72  : (1001000)
	    80  : (1010000) 
	*/
	task.twoSetBits(10);
}
main();

Output

 N : 10
 3 5 6 9 10 12 17 18 20 24
#   Python 3 Program
#   Print first n numbers with exactly two set bits

class Activity :
	#  Print the initial n numbers with only two active bits
	def twoSetBits(self, n) :
		if (n <= 0) :
			return
		
		print("\n  N : ", n ," ")
		bit1 = 1
		bit2 = 0
		counter = 0
		while (counter < n) :
			while (bit2 < bit1 and counter < n) :
				#  Display the  number which have two active bits
				print(" ", ((1 << bit1) | (1 << bit2)), end = "")
				bit2 += 1
				counter += 1
			
			bit1 += 1
			#  Reset bit two
			bit2 = 0
		
		print(end = "\n")
	

def main() :
	task = Activity()
	# 
	#     First few numbers which have two active bits 
	#     ---------------    
	#     3   : (11)
	#     5   : (101)
	#     6   : (110)
	#     9   : (1001)
	#     10  : (1010)
	#     12  : (1100)
	#     17  : (10001)
	#     18  : (10010)
	#     20  : (10100)
	#     24  : (11000)
	#     33  : (100001)
	#     34  : (100010)
	#     36  : (100100)
	#     40  : (101000)
	#     48  : (110000)
	#     65  : (1000001)
	#     66  : (1000010)
	#     68  : (1000100)
	#     72  : (1001000)
	#     80  : (1010000) 
	
	task.twoSetBits(10)

if __name__ == "__main__": main()

Output

  N :  10
  3  5  6  9  10  12  17  18  20  24
#   Ruby Program
#   Print first n numbers with exactly two set bits

class Activity 
	#  Print the initial n numbers with only two active bits
	def twoSetBits(n) 
		if (n <= 0) 
			return
		end

		print("\n N : ", n ," \n")
		bit1 = 1
		bit2 = 0
		counter = 0
		while (counter < n) 
			while (bit2 < bit1 && counter < n) 
				#  Display the  number which have two active bits
				print(" ", ((1 << bit1) | (1 << bit2)))
				bit2 += 1
				counter += 1
			end

			bit1 += 1
			#  Reset bit two
			bit2 = 0
		end

		print("\n")
	end

end

def main() 
	task = Activity.new()
	# 
	#     First few numbers which have two active bits 
	#     ---------------    
	#     3   : (11)
	#     5   : (101)
	#     6   : (110)
	#     9   : (1001)
	#     10  : (1010)
	#     12  : (1100)
	#     17  : (10001)
	#     18  : (10010)
	#     20  : (10100)
	#     24  : (11000)
	#     33  : (100001)
	#     34  : (100010)
	#     36  : (100100)
	#     40  : (101000)
	#     48  : (110000)
	#     65  : (1000001)
	#     66  : (1000010)
	#     68  : (1000100)
	#     72  : (1001000)
	#     80  : (1010000) 
	
	task.twoSetBits(10)
end

main()

Output

 N : 10 
 3 5 6 9 10 12 17 18 20 24

/*
  Scala Program
  Print first n numbers with exactly two set bits
*/
class Activity
{
	// Print the initial n numbers with only two active bits
	def twoSetBits(n: Int): Unit = {
		if (n <= 0)
		{
			return;
		}
		print("\n N : " + n + " \n");
		var bit1: Int = 1;
		var bit2: Int = 0;
		var counter: Int = 0;
		while (counter < n)
		{
			while (bit2 < bit1 && counter < n)
			{
				// Display the  number which have two active bits
				print(" " + ((1 << bit1) | (1 << bit2)));
				bit2 += 1;
				counter += 1;
			}
			bit1 += 1;
			// Reset bit two
			bit2 = 0;
		}
		print("\n");
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Activity = new Activity();
		/*
		    First few numbers which have two active bits 
		    ---------------    
		    3   : (11)
		    5   : (101)
		    6   : (110)
		    9   : (1001)
		    10  : (1010)
		    12  : (1100)
		    17  : (10001)
		    18  : (10010)
		    20  : (10100)
		    24  : (11000)
		    33  : (100001)
		    34  : (100010)
		    36  : (100100)
		    40  : (101000)
		    48  : (110000)
		    65  : (1000001)
		    66  : (1000010)
		    68  : (1000100)
		    72  : (1001000)
		    80  : (1010000) 
		*/
		task.twoSetBits(10);
	}
}

Output

 N : 10
 3 5 6 9 10 12 17 18 20 24
/*
  Swift 4 Program
  Print first n numbers with exactly two set bits
*/
class Activity
{
	// Print the initial n numbers with only two active bits
	func twoSetBits(_ n: Int)
	{
		if (n <= 0)
		{
			return;
		}
		print("\n N : ", n ," ");
		var bit1: Int = 1;
		var bit2: Int = 0;
		var counter: Int = 0;
		while (counter < n)
		{
			while (bit2 < bit1 && counter < n)
			{
				// Display the  number which have two active bits
				print(" ", ((1 << bit1) | (1 << bit2)), terminator: "");
				bit2 += 1;
				counter += 1;
			}
			bit1 += 1;
			// Reset bit two
			bit2 = 0;
		}
		print(terminator: "\n");
	}
}
func main()
{
	let task: Activity = Activity();
	/*
	    First few numbers which have two active bits 
	    ---------------    
	    3   : (11)
	    5   : (101)
	    6   : (110)
	    9   : (1001)
	    10  : (1010)
	    12  : (1100)
	    17  : (10001)
	    18  : (10010)
	    20  : (10100)
	    24  : (11000)
	    33  : (100001)
	    34  : (100010)
	    36  : (100100)
	    40  : (101000)
	    48  : (110000)
	    65  : (1000001)
	    66  : (1000010)
	    68  : (1000100)
	    72  : (1001000)
	    80  : (1010000) 
	*/
	task.twoSetBits(10);
}
main();

Output

 N :  10
  3  5  6  9  10  12  17  18  20  24
/*
  Kotlin Program
  Print first n numbers with exactly two set bits
*/
class Activity
{
	// Print the initial n numbers with only two active bits
	fun twoSetBits(n: Int): Unit
	{
		if (n <= 0)
		{
			return;
		}
		print("\n N : " + n + " \n");
		var bit1: Int = 1;
		var bit2: Int = 0;
		var counter: Int = 0;
		while (counter < n)
		{
			while (bit2 < bit1 && counter < n)
			{
				// Display the  number which have two active bits
				print(" " + ((1 shl bit1) or (1 shl bit2)));
				bit2 += 1;
				counter += 1;
			}
			bit1 += 1;
			// Reset bit two
			bit2 = 0;
		}
		print("\n");
	}
}
fun main(args: Array < String > ): Unit
{
	var task: Activity = Activity();
	/*
	    First few numbers which have two active bits 
	    ---------------    
	    3   : (11)
	    5   : (101)
	    6   : (110)
	    9   : (1001)
	    10  : (1010)
	    12  : (1100)
	    17  : (10001)
	    18  : (10010)
	    20  : (10100)
	    24  : (11000)
	    33  : (100001)
	    34  : (100010)
	    36  : (100100)
	    40  : (101000)
	    48  : (110000)
	    65  : (1000001)
	    66  : (1000010)
	    68  : (1000100)
	    72  : (1001000)
	    80  : (1010000) 
	*/
	task.twoSetBits(10);
}

Output

 N : 10
 3 5 6 9 10 12 17 18 20 24
Last updated on by Kalkicode




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.

New Comment