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 <iomanip>
       
#include <algorithm>
       
 
       
// slowly step through all iterations until enough primes are found; display the exponents in each step

       
unsigned long long enumerate(unsigned int numPrimes, bool displaySteps = true)
       
{
       
  const auto NumFractions = 14;
       
  const auto NumExponents = 10;
       
  const char Fractions[NumFractions][NumExponents] =
       
  {
       
    // represent fractions as exponents of these primes:
       
    //          2,  3,  5,  7, 11, 13, 17, 19, 23, 29
       
    // 17/91 =             1/7   *1/13*17
       
             {  0,  0,  0, -1,  0, -1, +1,  0,  0,  0 },
       
    // 78/85 =  2 * 3 *1/5        *13*1/17
       
             { +1, +1, -1,  0,  0, +1, -1,  0,  0,  0 },
       
    // 19/51 =     1/3               *1/17*19
       
             {  0, -1,  0,  0,  0,  0, -1, +1,  0,  0 },
       
    // 23/38 = 1/2                       *1/19*23
       
             { -1,  0,  0,  0,  0,  0,  0, -1, +1,  0 },
       
    // 29/33 =     1/3       *1/11                *29
       
             {  0, -1,  0,  0, -1,  0,  0,  0,  0, +1 },
       
    // 77/29 =              7* 11                *1/29
       
             {  0,  0,  0, +1, +1,  0,  0,  0,  0, -1 },
       
    // 95/23 =          5                 *19*1/23
       
             {  0,  0, +1,  0,  0,  0,  0, +1, -1,  0 },
       
    // 77/19 =              7* 11        *1/19
       
             {  0,  0,  0, +1, +1,  0,  0, -1,  0,  0 },
       
    //  1/17 =                       *1/17
       
             {  0,  0,  0,  0,  0,  0, -1,  0,  0,  0 },
       
    // 11/13 =                 11*1/13
       
             {  0,  0,  0,  0, +1, -1,  0,  0,  0,  0 },
       
    // 13/11 =                1/11*13
       
             {  0,  0,  0,  0, -1, +1,  0,  0,  0,  0 },
       
    // 15/2  = 1/2* 3 * 5
       
             { -1, +1, +1,  0,  0,  0,  0,  0,  0,  0 },
       
    //  1/7  =             1/7
       
             {  0,  0,  0, -1,  0,  0,  0,  0,  0,  0 },
       
    // 55/1  =          5     *11
       
             {  0,  0, +1,  0, +1,  0,  0,  0,  0,  0 }
       
  };
       
 
       
  // seed = 2 = 2^1 => set first exponent to 1
       
  int current[NumExponents] = { +1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
       
 
       
  // count number of steps required to find that prime
       
  unsigned long long steps = 0;
       
 
       
  // number of primes encountered along the way
       
  unsigned int numFound = 0;
       
  while (numFound < numPrimes)
       
  {
       
    // print current step
       
    if (displaySteps)
       
    {
       
      std::cout << "step " << std::setw(3) << steps << ": ";
       
      for (auto x : current)
       
        // replace zeros by dashes to ease "pattern detection"
       
        std::cout << std::setw(2) << (x == 0 ? "-" : std::to_string(x)) << " ";
       
      std::cout << std::endl;
       
    }
       
 
       
    // apply first rule that produces an integer
       
    for (const auto& fraction : Fractions)
       
    {
       
      bool matchingFraction = true;
       
      // no exponent should become negative after applying a rule
       
      for (auto exponent = 0; exponent < NumExponents; exponent++)
       
        matchingFraction &= (current[exponent] + fraction[exponent]) >= 0;
       
 
       
      // yes, that rule rules !
       
      if (matchingFraction)
       
      {
       
        // just add exponents
       
        for (auto exponent = 0; exponent < NumExponents; exponent++)
       
          current[exponent] += fraction[exponent];
       
        // no further rules
       
        break;
       
      }
       
    }
       
 
       
    steps++;
       
 
       
    // one more prime ?
       
    bool isPrime = true;
       
    // all but the first exponent are zero
       
    for (auto exponent = 1; exponent < NumExponents; exponent++)
       
      isPrime &= current[exponent] == 0;
       
    if (isPrime) // only 2s, ignore seed value (2^1)
       
    {
       
      numFound++;
       
      if (displaySteps)
       
        std::cout << "prime " << current[0] << " @ step " << steps << std::endl;
       
    }
       
  }
       
 
       
  return steps;
       
}
       
 
       
// treat the FRACTRAN sequence as a state machine

       
unsigned long long search(unsigned int numPrimes)
       
{
       
  // and manually optimize a few states (GCC discovers a few optimizations on its own)
       
#define OPTIMIZED
       
 
       
  // at most one exponent a,b,c,d,e,f of 11^a, 13^b, 17^c, 19^d, 23^e, 29^f can be one
       
  // => seven states
       
  enum State { S_, S11, S13, S17, S19, S23, S29 };
       
  State state = S_; // default state
       
 
       
  // the exponents of 2,3,5,7 can be any non-negative number
       
  auto two   = 1;
       
  auto three = 0;
       
  auto five  = 0;
       
  auto seven = 0;
       
 
       
  unsigned long long steps = 0;
       
  unsigned long long iterations = 0; // to measure how efficient my state optimizations are
       
  unsigned int    numFound = 0;
       
  while (true) // exit-condition in state S_
       
  {
       
    iterations++;
       
 
       
    switch (state)
       
    {
       
      case S_:
       
        if (three == 0 && five == 0 && seven == 0 && steps > 0)
       
        {
       
          numFound++;
       
          //std::cout << "prime " << two << "/" << numFound << " @ " << steps
       
          //          << " (" << iterations << " iterations => " << 100.0 * iterations / steps << "%)" << std::endl;
       
          if (numFound == numPrimes)
       
            return steps;
       
        }
       
 
       
        // fraction L: 15/2 = 3*5 / 2
       
        if (two > 0)
       
        {
       
          two--; three++; five++;
       
          // could be optimized, too:
       
          //steps += two; three += two; five += two; two = 0; continue:
       
          break;
       
        }
       
 
       
        // fraction M: 1/7
       
        if (seven > 0)
       
        {
       
          // could be optimized, too
       
          //steps += seven; seven = 0; continue;
       
          seven--;
       
          break;
       
        }
       
 
       
        // fraction N: 55/1 = 5 * 11
       
        five++;
       
        state = S11;
       
        break;
       
 
       
      case S11:
       
        // fraction E: 29/33 = 29 / (3*11)
       
        if (three > 0)
       
        {
       
#ifdef OPTIMIZED
       
          // S11 <=> S29
       
          // S29 performs seven++ and immediately returns to the current state S11
       
          steps += 2 * three;
       
          seven += three;
       
          three  = 0;
       
          continue; // to avoid step++ after the switch-block
       
#endif
       
          three--;
       
          state = S29;
       
          break;
       
        }
       
 
       
        // fraction K: 13/11
       
        state = S13;
       
        break;
       
 
       
      case S13:
       
        // fraction A: 17/91 = 17 / (7*13)
       
        if (seven > 0)
       
        {
       
#ifdef OPTIMIZED
       
          // S13 <=> S17:
       
          // as long as five and seven are not zero both are decremented by one
       
          // whereas two and three are incremented by one
       
          if (five > 0)
       
          {
       
            auto smallest = std::min(five, seven);
       
            steps += 2 * smallest;
       
            two   += smallest;
       
            three += smallest;
       
            five  -= smallest;
       
            seven -= smallest;
       
            continue; // to avoid step++ after the switch-block
       
          }
       
#endif
       
          seven--;
       
          state = S17;
       
          break;
       
        }
       
 
       
        // fraction J: 11/13
       
        state = S11;
       
        break;
       
 
       
      case S17:
       
        // fraction B: 78/85 = 2*3*13 / (5*17)
       
        if (five > 0)
       
        {
       
          five--; two++; three++;
       
          state = S13;
       
          break;
       
        }
       
        // fraction C: 19/51 = 19 / (3*17)
       
        if (three > 0)
       
        {
       
          three--;
       
          state = S19;
       
          break;
       
        }
       
 
       
        // fraction I: 1/17
       
        state = S_;
       
        break;
       
 
       
      case S19:
       
        // fraction D: 23/38 = 23 / (2*19)
       
        if (two > 0)
       
        {
       
#ifdef OPTIMIZED
       
          // S19 <=> S23 (apparently automatically detected by GCC at optimization level -O3, too)
       
          // two is decremented until it's zero while five is incremented
       
          steps += 2 * two;
       
          five  += two;
       
          two    = 0;
       
          continue; // to avoid step++ after the switch-block
       
#endif
       
          two--;
       
          state = S23;
       
          break;
       
        }
       
 
       
        // fraction H: 77/19 = 7*11 / 19
       
        seven++;
       
        state = S11;
       
        break;
       
 
       
      case S23:
       
        // fraction G: 95/23 = 5*19 / 23
       
        five++;
       
        state = S19;
       
        break;
       
 
       
      case S29:
       
        // fraction F: 77/29 = 7*11 / 29
       
        seven++;
       
        state = S11;
       
        break;
       
    }
       
 
       
    // next iteration
       
    steps++;
       
  }
       
}
       
 
       
int main()
       
{
       
  unsigned int numPrimes = 10001;
       
  std::cin >> numPrimes;
       
 
       
  // visualize steps
       
  //enumerate(numPrimes, true);
       
 
       
  // fast algorithm to solve the problem
       
  std::cout << search(numPrimes) << std::endl;
       
  return 0;
       
}

This solution contains 31 empty lines, 65 comments and 10 preprocessor commands.