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

/*
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)
*/
}
}``````

#### 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()
{
/*
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)
*/
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)
{
/*
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)
*/
}
}``````

#### 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()
{
/*
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)
*/
}
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()
{
/*
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)
*/
}
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() :
#
#     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)

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

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)
*/
}
}``````

#### 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()
{
/*
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)
*/
}
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
{
/*
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)
*/
}``````

#### Output

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

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