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>
       
 
       
// ---------- code from my toolbox ----------

       
 
       
// odd prime numbers are marked as "true" in a bitvector

       
std::vector<bool> sieve;
       
 
       
// 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) + 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;
       
      }
       
    }
       
}
       
 
       
// ---------- problem-specific code ----------

       
 
       
// return true if prime * 56789 ends with ...99999

       
bool endsWith56789(unsigned int prime)
       
{
       
  // cyclic = (10^(p-1) - 1) / p
       
  // cyclic * p = 10^(p-1) - 1
       
  // the last 5 digits of cyclic are ...56789
       
  // => cyclic * p must end with 5 nines (99999)
       
  // => add 1 to both sides => 99999 + 1 mod 100000 = 0
       
  auto cyclic  =  56789;
       
  auto modulo  = 100000;
       
  auto product = cyclic * (unsigned long long)prime;
       
  return (product + 1) % modulo == 0;
       
}
       
 
       
// return true if 9999...9999 / p = 137....

       
bool startsWith137(unsigned int prime)
       
{
       
  double cyclic = 1.0 / prime;
       
  return cyclic > 0.00000000137 &&
       
         cyclic < 0.00000000138;
       
}
       
 
       
// return the digit sum if the prime produces a cyclic number with a cycle length of prime - 1, else return 0

       
unsigned int cyclicDigitSum(unsigned int prime)
       
{
       
  // compute all digits of the cycle:
       
  // compute 1/prime, 10/prime, 100/prime, etc.
       
  // whenever the
       
  unsigned long long result = 0;
       
  unsigned long long numerator   = 1;
       
  unsigned int cycleLength = 0;
       
  while (true)
       
  {
       
    cycleLength++;
       
    // produce next leading digit
       
    numerator *= 10;
       
    result    += numerator / prime;
       
    numerator %= prime;
       
 
       
    // cycle found (or cycle too long)
       
    if (numerator <= 1 || cycleLength == prime)
       
      break;
       
  }
       
 
       
  // wrong cycle length
       
  if (cycleLength != prime - 1)
       
    return 0;
       
 
       
  // return digit sum
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int limit = 750000000;
       
  fillSieve(limit);
       
 
       
  // check each prime
       
  //for (unsigned int prime = 1; ; prime += 2)
       
  for (unsigned int prime = limit-1; prime > 1; prime -= 2)
       
  {
       
    if (!isPrime(prime))
       
      continue;
       
 
       
    // verify digits
       
    if (startsWith137(prime) && endsWith56789(prime))
       
    {
       
      // compute digit sum
       
      auto digitSum = cyclicDigitSum(prime);
       
      if (digitSum > 0) // accept only if the prime actually produces a cycle number with correct cycle length
       
      {
       
        std::cout << digitSum << std::endl;
       
        break;
       
      }
       
    }
       
  }
       
  return 0;
       
}

This solution contains 17 empty lines, 32 comments and 2 preprocessor commands.