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>
       
 
       
typedef std::vector<unsigned char> Row;
       
const unsigned int Modulo = 7;
       
 
       
// generate next row of Pascal's triangle modulo a number (> 1)
       
// return count of elements that are not a multiple of modulo (in C++ speak: x % modulo != 0)

       
unsigned long long nextRow(Row& row)
       
{
       
  // last value is always 1
       
  row.push_back(1);
       
  if (row.size() == 1)
       
    return 1;
       
 
       
  // first and last value are never a multiple of 7
       
  unsigned long long result = 2;
       
 
       
  // C(n+1,k+1) = C(n,k) + C(n,k+1)
       
  for (size_t k = row.size() - 2; k > 0; k--)
       
  {
       
    // note: I'm processing the row back-to-front
       
    // therefore minus 1 instead of plus 1
       
    unsigned char current = row[k] + row[k - 1];
       
 
       
    // subtraction is faster than modulo: current %= modulo
       
    // all values must be 0 ... 2*(modulo-1)
       
    if (current >= Modulo)
       
      current -= Modulo;
       
 
       
    // not divisible ?
       
    if (current != 0)
       
      result++;
       
 
       
    row[k] = current;
       
  }
       
 
       
  return result;
       
}
       
 
       
// convert to base 7 and multiply all digits plus 1

       
unsigned long long countNonDivisible(unsigned int row)
       
{
       
  unsigned long long result = 1;
       
  while (row > 0)
       
  {
       
    // one more digit ...
       
    result *= (row % Modulo) + 1;
       
    row    /= Modulo;
       
  }
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int numRows = 1000000000;
       
  std::cin >> numRows;
       
 
       
  // for simple algorithm based on nextRow()
       
  Row current = { 1 };
       
 
       
  // for my fastest pseudo brute-force algorithm
       
  std::vector<unsigned char> base7(12, 1); // 7^12 > 10^9
       
 
       
  unsigned long long count = 1;
       
  for (unsigned int row = 1; row < numRows; row++)
       
  {
       
    // simple algorithm (basically takes forever and needs tons of memory)
       
    //auto found = nextRow(current);
       
    //std::cout << row << " " << found << std::endl;
       
 
       
    // slightly more advanced
       
    //auto found = countNonDivisible(row);
       
 
       
    // and my fastest (still pseudo brute-force) algorithm:
       
    // keep all digits of row in base 7 in an array base7 with a twist:
       
    // each digit is one higher than it should be
       
    // => because previously I had to add 1 before multiplying
       
 
       
    // next number
       
    base7[0]++;
       
    // carry over to next digits
       
    auto carryPos = 0;
       
    while (base7[carryPos] == Modulo + 1)
       
    {
       
      base7[carryPos] = 1; // remember: start at 1 instead of 0
       
      base7[carryPos + 1]++;
       
      carryPos++;
       
    }
       
 
       
    // multiply all digits
       
    unsigned long long found = 1;
       
    for (auto& x : base7)
       
      found *= x;
       
 
       
    // keep track of the sum of all rows
       
    count += found;
       
  }
       
 
       
  std::cout << count << std::endl;
       
  return 0;
       
}

This solution contains 19 empty lines, 27 comments and 2 preprocessor commands.