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>
       
 
       
// represent digits as bitmasks, lit segments are 1

       
const unsigned char Segments[10] =
       
{
       
  // assume the following numbering scheme for the seven segments:
       
  //  000
       
  // 1   2
       
  // 1   2
       
  //  333
       
  // 4   5
       
  // 4   5
       
  //  666
       
  (1 << 0) | (1 << 1) | (1 << 2) | (0 << 3) | (1 << 4) | (1 << 5) | (1 << 6), // digit 0 = 0x77
       
  (0 << 0) | (0 << 1) | (1 << 2) | (0 << 3) | (0 << 4) | (1 << 5) | (0 << 6), // digit 1 = 0x24
       
  (1 << 0) | (0 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (0 << 5) | (1 << 6), // digit 2 = 0x5d
       
  (1 << 0) | (0 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6), // digit 3 = 0x6d
       
  (0 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6), // digit 4 = 0x2e
       
  (1 << 0) | (1 << 1) | (0 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6), // digit 5 = 0x6b
       
  (1 << 0) | (1 << 1) | (0 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6), // digit 6 = 0x3b
       
  (1 << 0) | (1 << 1) | (1 << 2) | (0 << 3) | (0 << 4) | (1 << 5) | (0 << 6), // digit 7 = 0x27
       
  (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6), // digit 8 = 0x7f
       
  (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6)  // digit 9 = 0x6f
       
};
       
 
       
 
       
// ---------- standard prime sieve 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 solution ----------

       
 
       
// return sum of all digits

       
unsigned int digitSum(unsigned int x)
       
{
       
  unsigned int result = 0;
       
  while (x > 0)
       
  {
       
    result += x % 10;
       
    x      /= 10;
       
  }
       
  return result;
       
}
       
 
       
// convert number to its bitmasks, 8 bits per digit => x must not exceed 99999999

       
unsigned long long getSegments(unsigned int x)
       
{
       
  unsigned long long result = 0;
       
  unsigned int shift = 0;
       
  while (x > 0)
       
  {
       
    unsigned long long current = Segments[x % 10];
       
    result |= current << shift;
       
    x      /= 10;
       
    shift  += 8;
       
  }
       
  return result;
       
}
       
 
       
// count bits which are set to 1

       
unsigned int popcnt(unsigned long long x)
       
{
       
#ifdef __GNUC__
       
  return __builtin_popcount(x);
       
#endif
       
 
       
  unsigned int result = 0;
       
  while (x > 0)
       
  {
       
    // clear right-most bit
       
    x &= x - 1;
       
    result++;
       
  }
       
  return result;
       
}
       
 
       
// process all steps with strategy of Sam, return number of transitions

       
unsigned int sam(unsigned int x)
       
{
       
  // memoize (runs quite fast without, too)
       
  static std::vector<unsigned int> cache(100, 0);
       
  if (x < cache.size() && cache[x] > 0)
       
    return cache[x];
       
 
       
  // display was clear
       
  auto segments = getSegments(x);
       
  // switch (intermediate) number on and off
       
  auto result   = 2 * popcnt(segments);
       
 
       
  // need further iterations ?
       
  if (x > 9)
       
    result += sam(digitSum(x));
       
 
       
  if (x < cache.size())
       
    cache[x] = result;
       
  return result;
       
}
       
 
       
// process all steps with strategy of Max, return number of transitions

       
unsigned int max(unsigned int x, unsigned long long previousSegments = 0)
       
{
       
  auto segments    = getSegments(x);
       
  auto transitions = segments ^ previousSegments;
       
  auto result      = popcnt(transitions);
       
 
       
  if (x > 9)
       
    // morph to next number
       
    result += max(digitSum(x), segments);
       
  else
       
    // fade out
       
    result += popcnt(segments);
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  // search range
       
  unsigned int from = 10000000;
       
  unsigned int to   = 20000000;
       
  std::cin >> from >> to;
       
 
       
  // for live input only
       
  if (from > to)
       
    return 1;
       
 
       
  // generate prime sieve
       
  fillSieve(to);
       
 
       
  // count all digits of Sam and Max
       
  unsigned long long sumSam = 0;
       
  unsigned long long sumMax = 0;
       
  for (auto i = (from | 1); i <= to; i += 2) // odd numbers only
       
  {
       
    if (!isPrime(i))
       
      continue;
       
 
       
    sumSam += sam(i);
       
    sumMax += max(i);
       
  }
       
 
       
  // Sam >= Max, display the difference
       
  std::cout << sumSam - sumMax << std::endl;
       
  return 0;
       
}

This solution contains 27 empty lines, 39 comments and 4 preprocessor commands.