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 <vector>
       
#include <map>
       
#include <set>
       
 
       
int main()
       
{
       
  unsigned int limit = 1000000000;
       
  std::cin >> limit;
       
 
       
  // ---------- step 1: find all admissible numbers ----------
       
 
       
  // generate all numbers 2^a * 3^b * 5^c * 7^d * 11^e ...
       
  const unsigned int NumFactors = 9;
       
  const unsigned int factors[NumFactors] = { 2,3,5,7,11,13,17,19,23 };
       
  // product of all factors is just under 10^9, including the next prime (29) would be bigger than 10^9
       
 
       
  // store all admissible numbers
       
  std::vector<unsigned int> admissible;
       
 
       
  // [number] => [index of its highest prime factor]
       
  std::map<unsigned int, unsigned char> todo = { { 2, 0 } };
       
  while (!todo.empty())
       
  {
       
    // pick smallest number and remove from to-do list
       
    auto current = *(todo.begin());
       
    todo.erase(todo.begin());
       
 
       
    auto number   = current.first;
       
    auto maxPrime = current.second;
       
 
       
    // add to admissible list
       
    admissible.push_back(number);
       
 
       
    // multiply by all already used prime numbers and the next one
       
    for (unsigned char i = 0; i <= maxPrime + 1; i++) // can start with i = maxPrime, too
       
    {
       
      // only up to 9 primes are relevant
       
      if (i == NumFactors)
       
        break;
       
 
       
      // put on to-do list if below 10^9
       
      auto next = number * (unsigned long long)factors[i];
       
      if (next < limit)
       
        todo[next] = std::max(maxPrime, i);
       
    }
       
  }
       
  // note: only 6656 admissible numbers
       
 
       
  // ---------- step 2: generate prime numbers up to sqrt(10^9) ----------
       
 
       
  // find at least one prime factor for each number below 10^9
       
  // => all up to sqrt(10^9) which is about 31622
       
  // and a few more to be on the safe side ... not needed in this case, but safety first :-)
       
  auto primeLimit = limit + 1000;
       
  // but I can cheat and reduce primeLimit as long as I get the correct result
       
  // => makes the program about 30% faster
       
  //primeLimit = 271623361;
       
 
       
  std::vector<unsigned int> primes = { 2 };
       
  // simply trial-division prime generator
       
  for (unsigned int i = 3; i*i <= primeLimit; i += 2)
       
  {
       
    bool isPrime = true;
       
 
       
    // test against all prime numbers we have so far (in ascending order)
       
    for (auto x : primes)
       
    {
       
      // prime is too large to be a divisor
       
      if (x*x > i)
       
        break;
       
 
       
      // divisible => not prime
       
      if (i % x == 0)
       
      {
       
        isPrime = false;
       
        break;
       
      }
       
    }
       
 
       
    // yes, we have a prime
       
    if (isPrime)
       
      primes.push_back(i);
       
  }
       
  // only 1911 out of the 3401 primes are actually needed in step 3
       
 
       
  // ---------- step 3: look for each admissible number's fortunate number ----------
       
 
       
  // std::set automatically filters duplicates
       
  std::set<unsigned int> fortunate;
       
  size_t pos = 0;
       
  for (auto x : admissible)
       
  {
       
    // every admissible number is even and m > 1
       
    // => therefore the first candidate is at m = 3
       
    const unsigned int MinDistance = 3;
       
 
       
    // fast check for small primes
       
    if (x <= primes.back() - MinDistance)
       
    {
       
      while (primes[pos] < x + MinDistance)
       
        pos++;
       
 
       
      auto distance = primes[pos] - x;
       
      // might be a duplicate but std::set makes sure that all values are unique
       
      fortunate.insert(distance);
       
      continue;
       
    }
       
 
       
    // every prime is odd (except for 2)
       
    // => I look at every second number
       
    for (unsigned int m = MinDistance; ; m += 2)
       
    {
       
      auto candidate = x + m;
       
 
       
      // is it a prime ?
       
      bool isPrime = true;
       
 
       
      // trial division
       
      for (auto p : primes) // actually I could skip p = 2 because all candidates are odd
       
        if (candidate % p == 0)
       
        {
       
          // it's a composite number
       
          isPrime = false;
       
          break;
       
        }
       
 
       
      // no, keep going ...
       
      if (!isPrime)
       
        continue;
       
 
       
      // yes, a prime
       
      auto distance = candidate - x;
       
      // might be a duplicate but std::set ensures that all values are unique
       
      fortunate.insert(distance);
       
      break;
       
    }
       
  }
       
 
       
  // add all fortunate numbers
       
  unsigned int sum = 0;
       
  for (auto x : fortunate)
       
    sum += x;
       
 
       
  // display result
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 26 empty lines, 40 comments and 4 preprocessor commands.