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 <deque>
       
#include <queue>
       
#include <functional>
       
 
       
int main()
       
{
       
  unsigned int limit = 47;
       
  std::cin >> limit;
       
 
       
  // primes <= 47 in descending order
       
  std::vector<unsigned int> primes = { 47,43,41,37,31,29,23,19,17,13,11,7,5,3,2 };
       
  // remove large prime depending on user input
       
  while (!primes.empty() && primes.front() > limit)
       
    primes.erase(primes.begin());
       
 
       
  // min-heap
       
  std::priority_queue<unsigned long long, std::vector<unsigned long long>, std::greater<unsigned long long>> next;
       
  // "seed" value
       
  next.push(1);
       
 
       
  // will store the final result
       
  unsigned long long sum  = 0;
       
 
       
  // 47-smooth number from previous iteration
       
  unsigned long long last = 1; // must not be zero, any other value is fine
       
 
       
  // I saw in my first runs that no solutions were found beyond the 10 millionth 47-smooth number
       
  for (unsigned int iteration = 0; iteration < 10000000; iteration++)
       
  {
       
    // fetch next 47-smooth number
       
    auto current = next.top();
       
    next.pop();
       
 
       
    // two consecutive 47-smooth numbers ? => T(last) is 47-smooth, too
       
    if (last + 1 == current)
       
    {
       
      sum += last;
       
      //std::cout << "T(" << last << "), sum=" << sum << " @ iteration " << iterations << " " << next.size() << std::endl;
       
    }
       
 
       
    // remember for next iteration
       
    last = current;
       
 
       
    // find further 47-smooth numbers
       
    for (auto p : primes)
       
    {
       
      auto todo = current * p;
       
 
       
      // heuristic: ignore numbers beyond the largest 47-smooth T(n)
       
      if (todo < 1111111111111ULL)
       
        next.push(todo);
       
 
       
      // any prime smaller than the largest prime yields a number already found in "next"
       
      if (current % p == 0)
       
        break;
       
    }
       
  }
       
 
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 12 empty lines, 14 comments and 5 preprocessor commands.