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>
       
 
       
// return the smallest 10^k bigger than x
       
// e.g. tens(456) = 1000 => "a 1 followed by as many 0s as x has digits"

       
unsigned long long tens(unsigned long long x)
       
{
       
  unsigned long long result = 1;
       
  while (result <= x)
       
    result *= 10;
       
  return result;
       
}
       
 
       
// when you are too lazy to type and your CPU is too fast ...
       
// no, seriously: quite useful for verifying small solutions

       
unsigned long long bruteForce(unsigned long long smallPrime, unsigned long long largePrime)
       
{
       
  // solve x == 0 mod largePrime
       
  // and   x == smallPrime mod tens(smallPrime)
       
 
       
  // find 10^k with the minimum amount of zeros
       
  auto shift = tens(smallPrime);
       
 
       
  // start with smallest possible value
       
  auto result = shift + smallPrime;
       
  // is it a multiple of b ?
       
  while (result % largePrime != 0)
       
    result += shift; // no, keep going ...
       
 
       
  return result;
       
}
       
 
       
// extended Euclidean algorithm

       
struct ExtendedGcd
       
{
       
  // this typedef allows me to switch easily between int and long long
       
  typedef long long Number;
       
 
       
  // find solutions x and y (so-called Bezout coefficients)
       
  ExtendedGcd(Number a, Number b)
       
  {
       
    // iterative algorithm from https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
       
    Number s = 0, lastS = 1;
       
    Number t = 1, lastT = 0;
       
    Number r = b, lastR = a; // remainder
       
    while (r != 0)
       
    {
       
      Number quotient = lastR / r;
       
      Number tmp;
       
      tmp = lastR; lastR = r; r = tmp - quotient * r;
       
      tmp = lastS; lastS = s; s = tmp - quotient * s;
       
      tmp = lastT; lastT = t; t = tmp - quotient * t;
       
    }
       
 
       
    // fill members
       
    gcd = lastR;
       
    x   = lastS;
       
    y   = lastT;
       
  }
       
 
       
  // Bezout coefficients
       
  Number x;
       
  Number y;
       
  // just in case we need it, too ...
       
  Number gcd;
       
};
       
 
       
// use Chinese Remainder Theorem

       
unsigned long long chineseRemainderTheorem(unsigned int smallPrime, unsigned int largePrime)
       
{
       
  // solve x == 0 mod largePrime
       
  // and   x == smallPrime mod tens(smallPrime)
       
  // e.g. Wolfram Alpha "x = 0 mod 23, x = 19 mod 100" => 1219
       
  auto modulo1 = largePrime;
       
  auto modulo2 = tens(smallPrime);
       
 
       
  // apply extended Euclidean algorithm
       
  ExtendedGcd gcd(modulo1, modulo2);
       
 
       
  //long long result = 0 * gcd.y * modulo2 + (long long)smallPrime * gcd.x * modulo1;
       
  // => multiplying by zero cancels half of the equation
       
  auto result = smallPrime * gcd.x * modulo1;
       
 
       
  // reduce to smallest solution
       
  auto product = modulo1 * modulo2;
       
  result %= (long long)product; // make sure it's a signed modulo
       
  // "too small" ?
       
  if (result < 0)
       
    result += product;
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  // result
       
  unsigned long long sum = 0;
       
 
       
  // sieve based on trial division
       
  unsigned int lastPrime = 2;
       
  std::vector<unsigned int> primes = { lastPrime };
       
  for (unsigned int i = 3; ; i += 2)
       
  {
       
    bool isPrime = true;
       
 
       
    // test against all prime numbers we have so far (in ascending order)
       
    for (auto p : primes)
       
    {
       
      // next prime is too large to be a divisor ?
       
      if (p*p > i)
       
        break;
       
 
       
      // divisible ? => not prime
       
      if (i % p == 0)
       
      {
       
        isPrime = false;
       
        break;
       
      }
       
    }
       
 
       
    // no prime ?
       
    if (!isPrime)
       
      continue;
       
 
       
    auto lastPrime = primes.back();
       
    primes.push_back(i);
       
 
       
    // find solution
       
    if (lastPrime >= 5)
       
    {
       
      //sum += bruteForce(lastPrime, i);
       
      sum += chineseRemainderTheorem(lastPrime, i);
       
    }
       
 
       
    // done ?
       
    if (i > 1000000)
       
      break;
       
  }
       
 
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 23 empty lines, 34 comments and 2 preprocessor commands.