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 <vector>
       
 
       
// odd prime numbers are marked as "true" in a bitvector

       
std::vector<bool> sieve;
       
// collection of all primes from the sieve (I do this because it's faster)

       
std::vector<unsigned int> primes = { 2 };
       
 
       
// return true, if x is a prime number

       
bool isPrime(unsigned int x)
       
{
       
  // handle even numbers
       
  if ((x & 1) == 0)
       
    return x == 2;
       
 
       
  // lookup for odd numbers
       
  return sieve[x >> 1];
       
}
       
 
       
// find all prime numbers from 2 to size

       
void fillSieve(unsigned int size)
       
{
       
  // store only odd numbers
       
  const unsigned int half = size >> 1;
       
 
       
  // allocate memory
       
  sieve.resize(half, true);
       
  // 1 is not a prime number
       
  sieve[0] = false;
       
 
       
  // process all relevant prime factors
       
  for (unsigned int i = 1; 2*i*i < half; i++)
       
    // do we have a prime factor ?
       
    if (sieve[i])
       
    {
       
      // mark all its multiples as false
       
      unsigned int current = 3*i+1;
       
      while (current < half)
       
      {
       
        sieve[current] = false;
       
        current += 2*i+1;
       
      }
       
    }
       
}
       
 
       
// ----- here the main algorithm starts -----

       
 
       
// return sum of all prime factors of n!

       
unsigned long long add(unsigned int n)
       
{
       
  unsigned long long sum = 0;
       
  for (auto p : primes)
       
  {
       
    // prime too large ? => done
       
    if (p > n)
       
      return sum;
       
 
       
    // start with p^1, then p^2 in next iteration
       
    unsigned long long multipleP = p;
       
    // initial count
       
    unsigned long long count = n / multipleP;
       
    do
       
    {
       
      // adjust result
       
      sum += p * count;
       
 
       
      // increase exponent by one, that means p^i => p^(i+1)
       
      multipleP *= p;
       
      // update count for next iteration
       
      count = n / multipleP;
       
    } while (count > 0); // multipleP > n
       
  }
       
  return sum;
       
}
       
 
       
// ----- below is my first approach -----

       
 
       
// my first attempt: compute a huge lookup table where
       
// (code not used anymore)

       
std::vector<unsigned long long> sums;
       
void generateTable(unsigned int limit)
       
{
       
  sums.resize(limit + 1, 0);
       
  for (unsigned int i = 2; i < sums.size(); i++)
       
  {
       
    // prime number ? its only prime factor is the number itself
       
    if (sums[i] == 0)
       
      sums[i] = i;
       
 
       
    // multiply with all prime numbers
       
    for (auto p : primes)
       
    {
       
      // too large ?
       
      if (i * p >= sums.size())
       
        break;
       
 
       
      // add current prime factor
       
      sums[i * p] = sums[i] + p;
       
    }
       
 
       
    // add all prime factors of (i-1)! to i
       
    // => that's the sum of prime factors of i!
       
    sums[i] += sums[i - 1];
       
  }
       
}
       
 
       
int main()
       
{
       
  // read input values n >= k
       
  unsigned int n = 20000000;
       
  unsigned int k = 15000000;
       
  std::cin >> n >> k;
       
 
       
  // generate all prime numbers
       
  fillSieve(n);
       
 
       
  // extract prime numbers
       
  for (unsigned int i = 3; i <= n; i += 2)
       
    if (isPrime(i))
       
      primes.push_back(i);
       
 
       
  std::cout << add(n) - (add(n - k) + add(k)) << std::endl;
       
 
       
  // older, slower algorithm
       
  //generateTable(n);
       
  //std::cout << sums[n] - (sums[n - k] + sums[k]) << std::endl;
       
 
       
  return 0;
       
}

This solution contains 22 empty lines, 35 comments and 3 preprocessor commands.