Donat un nombre n, imprimeix els primers n nombres enters positius amb exactament dos bits establerts en la seva representació binària.
Exemples:

 Input: n = 3   
 Output: 3 5 6   
 The first 3 numbers with two set bits are 3 (0011)   
 5 (0101) and 6 (0110)   
 Input: n = 5   
 Output: 3 5 6 9 10 12   
 
 A     Solució senzilla    és considerar tots els nombres enters positius un per un a partir de l'1. Per a cada nombre comproveu si té exactament dos conjunts de bits. Si un nombre té exactament dos bits establerts, imprimiu-lo i augmenteu el recompte d'aquests nombres.   
 An     Solució eficient    és generar directament aquests números. Si observem clarament els nombres, els podem reescriure com es mostra a continuació pow(21)+pow(20) pow(22)+pow(20) pow(22)+pow(21) pow(23)+pow(20) pow(23)+pow(21) pow(23)+pow(22) .........   
 Tots els números es poden generar en ordre creixent segons el més alt dels dos bits establerts. La idea és arreglar més alt de dos bits un per un. Per al bit de conjunt més alt actual, considereu tots els bits inferiors i imprimiu els números formats.  
 C++   
   // C++ program to print first n numbers   // with exactly two set bits   #include          using     namespace     std  ;   // Prints first n numbers with two set bits   void     printTwoSetBitNums  (  int     n  )   {      // Initialize higher of two sets bits      int     x     =     1  ;      // Keep reducing n for every number      // with two set bits.      while     (  n     >     0  )      {      // Consider all lower set bits for      // current higher set bit      int     y     =     0  ;      while     (  y      <     x  )      {      // Print current number      cout      < <     (  1      < <     x  )     +     (  1      < <     y  )      < <     ' '  ;      // If we have found n numbers      n  --  ;      if     (  n     ==     0  )      return  ;      // Consider next lower bit for current      // higher bit.      y  ++  ;      }      // Increment higher set bit      x  ++  ;      }   }   // Driver code   int     main  ()   {      printTwoSetBitNums  (  4  );      return     0  ;   }   
  Java   
   // Java program to print first n numbers   // with exactly two set bits   import     java.io.*  ;   class   GFG      {      // Function to print first n numbers with two set bits      static     void     printTwoSetBitNums  (  int     n  )      {      // Initialize higher of two sets bits      int     x     =     1  ;          // Keep reducing n for every number      // with two set bits      while     (  n     >     0  )      {      // Consider all lower set bits for      // current higher set bit      int     y     =     0  ;      while     (  y      <     x  )      {      // Print current number      System  .  out  .  print  (((  1      < <     x  )     +     (  1      < <     y  ))     +  ' '  );          // If we have found n numbers      n  --  ;      if     (  n     ==     0  )      return  ;          // Consider next lower bit for current      // higher bit.      y  ++  ;      }          // Increment higher set bit      x  ++  ;      }      }          // Driver program      public     static     void     main     (  String  []     args  )         {      int     n     =     4  ;      printTwoSetBitNums  (  n  );      }   }   // This code is contributed by Pramod Kumar   
  Python3   
   # Python3 program to print first n    # numbers with exactly two set bits    # Prints first n numbers    # with two set bits    def   printTwoSetBitNums  (  n  )   :   # Initialize higher of   # two sets bits    x   =   1   # Keep reducing n for every    # number with two set bits.    while   (  n   >   0  )   :   # Consider all lower set bits    # for current higher set bit    y   =   0   while   (  y    <   x  )   :   # Print current number    print  ((  1    < <   x  )   +   (  1    < <   y  )   end   =   ' '   )   # If we have found n numbers    n   -=   1   if   (  n   ==   0  )   :   return   # Consider next lower bit    # for current higher bit.    y   +=   1   # Increment higher set bit    x   +=   1   # Driver code    printTwoSetBitNums  (  4  )   # This code is contributed    # by Smitha   
  C#   
   // C# program to print first n numbers   // with exactly two set bits   using     System  ;   class     GFG         {          // Function to print first n      // numbers with two set bits      static     void     printTwoSetBitNums  (  int     n  )      {          // Initialize higher of       // two sets bits      int     x     =     1  ;          // Keep reducing n for every      // number with two set bits      while     (  n     >     0  )      {          // Consider all lower set bits       // for current higher set bit      int     y     =     0  ;      while     (  y      <     x  )      {          // Print current number      Console  .  Write  (((  1      < <     x  )     +      (  1      < <     y  ))     +  ' '  );          // If we have found n numbers      n  --  ;      if     (  n     ==     0  )      return  ;          // Consider next lower bit       // for current higher bit.      y  ++  ;      }          // Increment higher set bit      x  ++  ;      }      }          // Driver program      public     static     void     Main  ()         {      int     n     =     4  ;      printTwoSetBitNums  (  n  );      }   }       // This code is contributed by Anant Agarwal.   
  JavaScript   
    <  script  >   // Javascript program to print first n numbers   // with exactly two set bits   // Prints first n numbers with two set bits   function     printTwoSetBitNums  (  n  )   {      // Initialize higher of two sets bits      let     x     =     1  ;      // Keep reducing n for every number      // with two set bits.      while     (  n     >     0  )      {          // Consider all lower set bits for      // current higher set bit      let     y     =     0  ;      while     (  y      <     x  )      {          // Print current number      document  .  write  ((  1      < <     x  )     +     (  1      < <     y  )     +     ' '  );      // If we have found n numbers      n  --  ;      if     (  n     ==     0  )      return  ;      // Consider next lower bit for current      // higher bit.      y  ++  ;      }      // Increment higher set bit      x  ++  ;      }   }   // Driver code   printTwoSetBitNums  (  4  );   // This code is contributed by Mayank Tyagi    <  /script>   
  PHP   
      // PHP program to print    // first n numbers with    // exactly two set bits   // Prints first n numbers    // with two set bits   function   printTwoSetBitNums  (  $n  )   {   // Initialize higher of   // two sets bits   $x   =   1  ;   // Keep reducing n for    // every number with    // two set bits.   while   (  $n   >   0  )   {   // Consider all lower set    // bits for current higher    // set bit   $y   =   0  ;   while   (  $y    <   $x  )   {   // Print current number   echo   (  1    < <   $x  )   +   (  1    < <   $y  )   ' '  ;   // If we have found n numbers   $n  --  ;   if   (  $n   ==   0  )   return  ;   // Consider next lower    // bit for current    // higher bit.   $y  ++  ;   }   // Increment higher set bit   $x  ++  ;   }   }   // Driver code   printTwoSetBitNums  (  4  );   // This code is contributed by Ajit   ?>   
   
    Sortida:        
    
  
 3 5 6 9   
 
  
    Complexitat temporal:    O(n)  
  
    Espai auxiliar:    O(1)   
     
   
  
 Enfocament núm. 2: utilitzar while i join  
 
  
 L'enfocament és començar des de l'enter 3 i comprovar si el nombre de bits establerts en la seva representació binària és igual a 2 o no. Si té exactament 2 bits establerts, afegiu-lo a la llista de números amb 2 bits establerts fins que la llista tingui n elements.  
  
 Algorisme  
 
 1. Inicialitzeu una llista buida res per emmagatzemar els nombres enters amb exactament dos bits establerts.   
 2. Inicialitzeu una variable entera i a 3.   
 3. Si bé la longitud de la llista res és menor que n, feu el següent:   
 a. Comproveu si el nombre de bits establerts a la representació binària de i és igual a 2 o no utilitzant el mètode count() de la cadena.   
 b. Si el nombre de bits establerts és igual a 2, afegiu i a la llista res.   
 c. Incrementa i en 1.   
 4. Retorna la llista res.  
 C++   
   #include          #include         using     namespace     std  ;   int     countSetBits  (  int     num  )     {      int     count     =     0  ;      while     (  num     >     0  )     {      count     +=     num     &     1  ;      num     >>=     1  ;      }      return     count  ;   }   vector   <  int  >     numbersWithTwoSetBits  (  int     n  )     {      vector   <  int  >     res  ;      int     i     =     3  ;      while     (  res  .  size  ()      <     n  )     {      if     (  countSetBits  (  i  )     ==     2  )     {      res  .  push_back  (  i  );      }      i  ++  ;      }      return     res  ;   }   int     main  ()     {      int     n     =     3  ;      vector   <  int  >     result     =     numbersWithTwoSetBits  (  n  );      cout      < <     'Result: '  ;      for     (  int     i     =     0  ;     i      <     result  .  size  ();     i  ++  )     {      cout      < <     result  [  i  ]      < <     ' '  ;      }      cout      < <     endl  ;      return     0  ;   }   
  Java   
   // Java program for the above approach   import     java.util.ArrayList  ;   import     java.util.List  ;   public     class   GFG     {      // Function to count the number of set bits (binary 1s)      // in an integer      static     int     countSetBits  (  int     num  )      {      int     count     =     0  ;      while     (  num     >     0  )     {      count     +=     num     &     1  ;     // Increment count if the last      // bit is set (1)      num     >>=     1  ;     // Right shift to check the next bit      }      return     count  ;      }      // Function to generate 'n' numbers with exactly two set      // bits in their binary representation      static     List   <  Integer  >     numbersWithTwoSetBits  (  int     n  )      {      List   <  Integer  >     res     =     new     ArrayList   <>  ();      int     i     =     3  ;     // Start from 3 as the first number with      // two set bits      while     (  res  .  size  ()      <     n  )     {      if     (  countSetBits  (  i  )      ==     2  )     {     // Check if the number has exactly      // two set bits      res  .  add  (      i  );     // Add the number to the result list      }      i  ++  ;     // Move to the next number      }      return     res  ;      }      public     static     void     main  (  String  []     args  )      {      int     n     =     3  ;     // Number of numbers with two set bits to      // generate      List   <  Integer  >     result     =     numbersWithTwoSetBits  (      n  );     // Get the generated numbers      for     (  int     num     :     result  )     {      System  .  out  .  print  (      num     +     ' '  );     // Display the generated numbers      }      System  .  out  .  println  ();      }   }   // This code is contributed by Susobhan Akhuli   
  Python3   
   def   numbersWithTwoSetBits  (  n  ):   res   =   []   i   =   3   while   len  (  res  )    <   n  :   if   bin  (  i  )  .  count  (  '1'  )   ==   2  :   res  .  append  (  i  )   i   +=   1   return   res   n   =   3   result   =   numbersWithTwoSetBits  (  n  )   output_string   =   ' '  .  join  (  str  (  x  )   for   x   in   result  )   print  (  output_string  )   
  C#   
   using     System  ;   using     System.Collections.Generic  ;   class     Program   {      // Function to count the number of set bits (binary 1s) in an integer      static     int     CountSetBits  (  int     num  )      {      int     count     =     0  ;      while     (  num     >     0  )      {      count     +=     num     &     1  ;     // Increment count if the last bit is set (1)      num     >>=     1  ;     // Right shift to check the next bit      }      return     count  ;      }      // Function to generate 'n' numbers with exactly two set bits in their binary representation      static     List   <  int  >     NumbersWithTwoSetBits  (  int     n  )      {      List   <  int  >     res     =     new     List   <  int  >  ();      int     i     =     3  ;     // Start from 3 as the first number with two set bits      while     (  res  .  Count      <     n  )      {      if     (  CountSetBits  (  i  )     ==     2  )     // Check if the number has exactly two set bits      {      res  .  Add  (  i  );     // Add the number to the result list      }      i  ++  ;     // Move to the next number      }      return     res  ;      }      static     void     Main  (  string  []     args  )      {      int     n     =     3  ;     // Number of numbers with two set bits to generate      List   <  int  >     result     =     NumbersWithTwoSetBits  (  n  );     // Get the generated numbers      Console  .  Write  (  'Result: '  );      foreach     (  int     num     in     result  )      {      Console  .  Write  (  num     +     ' '  );     // Display the generated numbers      }      Console  .  WriteLine  ();      }   }   
  JavaScript   
   // Javascript program for the above approach   // Function to count the number of set bits (binary 1s)   // in an integer   function     countSetBits  (  num  )     {      let     count     =     0  ;      while     (  num     >     0  )     {      count     +=     num     &     1  ;     // Increment count if the last      // bit is set (1)      num     >>=     1  ;     // Right shift to check the next bit      }      return     count  ;   }   // Function to generate 'n' numbers with exactly two set   // bits in their binary representation   function     numbersWithTwoSetBits  (  n  )     {      let     res     =     [];      let     i     =     3  ;     // Start from 3 as the first number with      // two set bits      while     (  res  .  length      <     n  )     {      if     (  countSetBits  (  i  )     ===     2  )     {     // Check if the number has exactly      // two set bits      res  .  push  (  i  );     // Add the number to the result list      }      i  ++  ;     // Move to the next number      }      return     res  ;   }   // Number of numbers with two set bits to generate   let     n     =     3  ;   // Get the generated numbers   let     result     =     numbersWithTwoSetBits  (  n  );   // Display the generated numbers   console  .  log  (  result  .  join  (  ' '  ));   // This code is contributed by Susobhan Akhuli   
    
  Sortida   
3 5 6 
 
 Complexitat temporal: O(n log n) on n és el nombre de nombres enters amb exactament dos bits establerts. Això es deu al fet que estem comprovant el nombre de bits establerts en la representació binària de cada nombre enter que triga O(log n) temps.  
  
 Complexitat espacial: O(n) on n és el nombre d'enters amb exactament dos bits establerts. Això és perquè estem emmagatzemant la llista de nombres enters amb dos bits establerts a la memòria.