My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <iomanip>
       
#include <cmath>
       
 
       
// 32 bits

       
unsigned int maxBits = 32;
       
 
       
// ---------- first approach: find a good estimation with Monte-Carlo simulation ----------

       
 
       
// a simple pseudo-random number generator
       
// (produces the same result no matter what compiler you have - unlike rand() from math.h)

       
unsigned int myrand()
       
{
       
  static unsigned long long seed = 0;
       
  seed = 6364136223846793005ULL * seed + 1;
       
  return seed >> 30;
       
}
       
 
       
// randomized simulation

       
double montecarlo(unsigned int iterations)
       
{
       
  // all 32 bits are set
       
  const unsigned int allBits = (1ULL << maxBits) - 1;
       
 
       
  unsigned int numSteps = 0;
       
  for (unsigned int i = 0; i < iterations; i++)
       
  {
       
    // start with zero
       
    unsigned int current = 0;
       
    // and repeat until all bits are set
       
    do
       
    {
       
      // and some random bits
       
      current |= myrand() & allBits;
       
      numSteps++;
       
    } while (current != allBits);
       
  }
       
 
       
  // return average number of steps until "completion"
       
  return numSteps / double(iterations);
       
}
       
 
       
// ---------- final approach: solve "smarter" ! ----------

       
 
       
int main()
       
{
       
  std::cin >> maxBits;
       
 
       
  // number of accurate digits
       
  const unsigned int digits = 10;
       
  // 0.00000000001 => one more zero ensures that the last digit is correct even after rounding
       
  const double Epsilon = pow(10.0, -(double)(digits + 1));
       
 
       
  // at least one round
       
  double result = 0;
       
  unsigned int round = 0;
       
 
       
  // until change is smaller than Epsilon
       
  while (true)
       
  {
       
    // chance of "survival" for a single zero after all those rounds
       
    auto hasZero = pow(0.5, round);
       
    // were all 32 bits flipped from 0 to 1 ?
       
    auto isDone  = pow(1 - hasZero, maxBits);
       
 
       
    // remaining
       
    auto delta = 1 - isDone;
       
    // enough digits ?
       
    if (delta < Epsilon)
       
      break;
       
 
       
    // next iteration
       
    result += delta;
       
    round++; // stop after 42 rounds
       
  }
       
 
       
  // display result
       
  std::cout << std::fixed << std::setprecision(digits)
       
            << result << std::endl;
       
 
       
  // run Monte-Carlo simulation
       
  //while (true)
       
  //  std::cout << montecarlo(100000000) << std::endl;
       
 
       
  return 0;
       
}

This solution contains 17 empty lines, 24 comments and 3 preprocessor commands.