Dado un número n, imprima los primeros n enteros positivos con exactamente dos bits configurados en su representación binaria.
Ejemplos:

 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ón sencilla    es considerar todos los números enteros positivos uno por uno a partir de 1. Para cada número, verifique si tiene exactamente dos conjuntos de bits. Si un número tiene exactamente dos bits configurados, imprímalo e incremente el recuento de dichos números.   
 Un     Solución eficiente    es generar directamente tales números. Si observamos claramente los números, podemos reescribirlos como se indica a continuación pow(21)+pow(20) pow(22)+pow(20) pow(22)+pow(21) pow(23)+pow(20) pow(23)+pow(21) pow(23)+pow(22) .........   
 Todos los números se pueden generar en orden creciente según el mayor de los dos bits establecidos. La idea es arreglar dos bits uno por uno. Para el bit establecido más alto actual, considere todos los bits más bajos e imprima los números formados.  
 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   ?>   
   
    Producción :        
    
  
 3 5 6 9   
 
  
    Complejidad del tiempo:    En)  
  
    Espacio Auxiliar:    O(1)   
     
   
  
 Enfoque n.° 2: usar while y join  
 
  
 El enfoque consiste en comenzar desde el número entero 3 y comprobar si el número de bits establecidos en su representación binaria es igual a 2 o no. Si tiene exactamente 2 bits configurados, agréguelo a la lista de números con 2 bits configurados hasta que la lista tenga n elementos.  
  
 Algoritmo  
 
 1. Inicialice una lista vacía res para almacenar los números enteros con exactamente dos bits establecidos.   
 2. Inicialice una variable entera i a 3.   
 3. Mientras la longitud de la lista res sea menor que n, haga lo siguiente:   
 a. Compruebe si el número de bits establecidos en la representación binaria de i es igual a 2 o no utilizando el método count() de la cadena.   
 b. Si el número de bits configurados es igual a 2, agregue i a la lista res.   
 do. Incrementar i en 1.   
 4. Devuelve la lista 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   
    
  Producción   
3 5 6 
 
 Complejidad del tiempo: O (n log n) donde n es el número de números enteros con exactamente dos bits configurados. Esto se debe a que estamos verificando el número de bits establecidos en la representación binaria de cada número entero, lo que toma O (log n) tiempo.  
  
 Complejidad espacial: O(n) donde n es el número de números enteros con exactamente dos bits configurados. Esto se debe a que estamos almacenando la lista de números enteros con dos bits configurados en la memoria.