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>
       
#include <set>
       
#include <string>
       
#include <algorithm>
       
 
       
// find the the length of shortest move sequence
       
// too slow for anything > 10

       
unsigned int countMoves(unsigned int stonesPerColor)
       
{
       
  const auto Red    = 'R';
       
  const auto Blue   = 'B';
       
  const auto Empty  = '.';
       
 
       
  const auto Length = 2 * stonesPerColor + 1;
       
 
       
  // create initial state
       
  const auto initial = std::string(stonesPerColor, Red ) + Empty + std::string(stonesPerColor, Blue);
       
  // and final state
       
  const auto final   = std::string(stonesPerColor, Blue) + Empty + std::string(stonesPerColor, Red);
       
 
       
  // breadth search
       
  std::vector<std::string> last        = { initial };
       
  std::set   <std::string> alreadySeen = { initial };
       
  unsigned int numMoves = 0;
       
  while (true)
       
  {
       
    std::vector<std::string> next;
       
    for (const auto& current : last)
       
    {
       
      if (current == final)
       
        return numMoves;
       
 
       
      // locate the empty cell
       
      size_t pos = 0;
       
      while (current[pos] != Empty)
       
        pos++;
       
 
       
      // generate all possible moves
       
      if (pos >= 2)
       
      {
       
        // jump two positions to the right
       
        auto jumpTwoRight = current;
       
        std::swap(jumpTwoRight[pos - 2], jumpTwoRight[pos]);
       
        // accept only positions that I haven't seen before
       
        if (alreadySeen.count(jumpTwoRight) == 0)
       
        {
       
          next.push_back(jumpTwoRight);
       
          alreadySeen.insert(jumpTwoRight);
       
        }
       
      }
       
      if (pos >= 1)
       
      {
       
        // move one position to the right
       
        auto moveOneRight = current;
       
        std::swap(moveOneRight[pos - 1], moveOneRight[pos]);
       
        // accept only positions that I haven't seen before
       
        if (alreadySeen.count(moveOneRight) == 0)
       
        {
       
          next.push_back(moveOneRight);
       
          alreadySeen.insert(moveOneRight);
       
        }
       
      }
       
      if (pos < Length - 1)
       
      {
       
        // move one position to the left
       
        auto moveOneLeft = current;
       
        std::swap(moveOneLeft[pos + 1], moveOneLeft[pos]);
       
        // accept only positions that I haven't seen before
       
        if (alreadySeen.count(moveOneLeft) == 0)
       
        {
       
          next.push_back(moveOneLeft);
       
          alreadySeen.insert(moveOneLeft);
       
        }
       
      }
       
      if (pos < Length - 2)
       
      {
       
        // jump two positions to the left
       
        auto jumpTwoLeft = current;
       
        std::swap(jumpTwoLeft[pos + 2], jumpTwoLeft[pos]);
       
        // accept only positions that I haven't seen before
       
        if (alreadySeen.count(jumpTwoLeft) == 0)
       
        {
       
          next.push_back(jumpTwoLeft);
       
          alreadySeen.insert(jumpTwoLeft);
       
        }
       
      }
       
    }
       
 
       
    // next move
       
    numMoves++;
       
    last = std::move(next);
       
  }
       
 
       
  // never reached
       
  return 0;
       
}
       
 
       
int main()
       
{
       
  unsigned int numValues = 40;
       
  std::cin >> numValues;
       
 
       
  // count moves via brute-force
       
//#define COUNTMOVES

       
#ifdef  COUNTMOVES
       
  for (unsigned int stonesPerColor = 1; stonesPerColor <= numValues; stonesPerColor++)
       
    std::cout << "M(" << stonesPerColor << ")=" << countMoves(stonesPerColor) << std::endl;
       
#endif
       
 
       
  // solve t * (t + 1) / 2 = (n + 1)^2 - 1 via brute-force
       
//#define SLOWSEARCH

       
#ifdef  SLOWSEARCH
       
  unsigned long long t = 1;
       
  unsigned long long n = 1;
       
 
       
  // only feasible for the first 20 solutions
       
  unsigned int i = 1;
       
  unsigned int m = 0;
       
  while (i <= numValues)
       
  {
       
    auto triangle = t * (t + 1) / 2;
       
    auto moves    = (n + 1) * (n + 1) - 1;
       
    // is triangle number too small ?
       
    if (triangle <  moves)
       
      t++;
       
    // is triangle number too large ?
       
    else if (triangle >  moves)
       
      n++;
       
    else // if (triangle == moves)
       
    {
       
      // found a match
       
      m += n;
       
      std::cout << "M(" << i << ")=" << m << std::endl;
       
 
       
      i++; t++; n++;
       
    }
       
  }
       
#endif
       
 
       
  // solve ax^2 + bxy + cy^2 + dx + ey + f = 0
       
  // a =  1;
       
  // b =  0;
       
  // c = -2;
       
  // d =  1;
       
  // e = -4;
       
  // f =  0;
       
 
       
  // inital solution
       
  unsigned long long x1 = 2;
       
  unsigned long long y1 = 1;
       
  unsigned long long x2 = 5;
       
  unsigned long long y2 = 3;
       
  unsigned long long sum = y1 + y2;
       
  for (unsigned int n = 3; n <= numValues; n++)
       
  {
       
    // https://www.alpertron.com.ar/QUAD.HTM
       
    // a =  1;
       
    // b =  0;
       
    // c = -2;
       
    // d =  1;
       
    // e = -4;
       
    // f =  0;
       
    const auto P = 3;
       
    const auto Q = 4;
       
    const auto K = 5;
       
    const auto R = 2;
       
    const auto S = 3;
       
    const auto L = 3;
       
 
       
    // update first pair x,y
       
    auto nextX1 = P*x1 + Q*y1 + K;
       
    auto nextY1 = R*x1 + S*y1 + L;
       
    x1 = nextX1;
       
    y1 = nextY1;
       
    sum += y1;
       
 
       
    if (++n > numValues)
       
      break;
       
 
       
    // update second pair x,y
       
    auto nextX2 = P*x2 + Q*y2 + K;
       
    auto nextY2 = R*x2 + S*y2 + L;
       
    x2 = nextX2;
       
    y2 = nextY2;
       
    sum += y2;
       
  }
       
 
       
  // print result
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 19 empty lines, 43 comments and 9 preprocessor commands.