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 <string>
       
#include <vector>
       
 
       
int main()
       
{
       
  // digits of pi
       
  std::string A = "1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679";
       
  std::string B = "8214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196";
       
 
       
  std::cin >> A >> B;
       
  // live test only: detect invalid input
       
  if (A.size() != B.size() || A.empty())
       
    return 1;
       
 
       
  // 100 digits are one "block"
       
  const auto BlockSize = A.size(); // == B.size()
       
 
       
  // first two elements of the Fibonacci series (and dummy Fibonacci number 0 is 0)
       
  std::vector<unsigned long long> fibonacci = { 0, BlockSize };
       
 
       
  // find all Fibonacci numbers below 2^64
       
  while (fibonacci.back() < 1ULL << 63)
       
    fibonacci.push_back(fibonacci[fibonacci.size() - 2] + fibonacci[fibonacci.size() - 1]);
       
 
       
  // it's easier to reverse the loop and print all digits in the correct order ...
       
  for (auto n = 17; n >= 0; n--)
       
  {
       
    // compute index according to problem description
       
    unsigned long long index = 127 + 19*n;
       
    // times 7^n
       
    for (auto seven = 1; seven <= n; seven++)
       
      index *= 7;
       
 
       
    // my indexing scheme is zero-based but Project Euler's index starts at 1
       
    index--;
       
 
       
    // "step forward":
       
    // find the first Fibonacci number with enough digits
       
    unsigned int current = 1;
       
    while (index >= fibonacci[current])
       
      current++;
       
 
       
    // "step backwards":
       
    // deduce which Fibonacci number generated the part where the index is located
       
    while (true)
       
    {
       
      // reduced to a single block A or B ?
       
      if (current == 1)
       
      {
       
        std::cout << A[index];
       
        break;
       
      }
       
      if (current == 2)
       
      {
       
        std::cout << B[index];
       
        break;
       
      }
       
 
       
      // the mid-point divides left part (fibonacci minus 2) and right part (fibonacci minus 1)
       
      auto mid = fibonacci[current - 2];
       
      if (index < mid)
       
      {
       
        // left part
       
        current -= 2;
       
      }
       
      else
       
      {
       
        // right part
       
        index   -= mid;
       
        current -= 1;
       
      }
       
    }
       
  }
       
 
       
  std::cout << std::endl;
       
  return 0;
       
}

This solution contains 11 empty lines, 17 comments and 3 preprocessor commands.