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>
       
 
       
// taken from problem statement

       
const unsigned int Modulo = 1000267129;
       
 
       
// set the n-th bit if x contains digit n

       
unsigned int fingerprint(unsigned long long x)
       
{
       
  unsigned int result = 0;
       
  while (x > 0)
       
  {
       
    auto digit = x % 10;
       
    result |= 1 << digit;
       
    x /= 10;
       
  }
       
  return result;
       
}
       
 
       
// O(n^2) algorithm, compare each number q with all smaller numbers p

       
unsigned long long bruteForce(unsigned long long limit)
       
{
       
  unsigned long long result = 0;
       
  for (unsigned long long q = 1; q < limit; q++)
       
  {
       
    // bitmask of used digits
       
    auto maskQ = fingerprint(q);
       
 
       
    for (unsigned long long p = 1; p < q; p++)
       
    {
       
      auto maskP = fingerprint(p);
       
      // share at least one digit
       
      if ((maskQ & maskP) != 0)
       
      {
       
        result++;
       
        // much faster than %-operator
       
        if (result == Modulo)
       
          result = 0;
       
      }
       
    }
       
  }
       
 
       
  return result;
       
}
       
 
       
// O(n) algorithm, much faster than bruteForce() but still too slow to handle limit = 10^18
       
// but still useful up to 10^8

       
unsigned long long slow(unsigned long long limit)
       
{
       
  unsigned long long result = 0;
       
 
       
  // setup counters for each bitmask (10 digits => 2^10 bitmasks
       
  const auto NumCounters = 1 << 10;
       
  unsigned long long maskCount[NumCounters] = { 0 };
       
 
       
  // iterate over all numbers
       
  for (unsigned long long q = 1; q < limit; q++)
       
  {
       
    // get current bitmask
       
    auto maskQ = fingerprint(q);
       
 
       
    // add all counters that share at least one bit with the current bitmask
       
    for (auto i = 1; i < NumCounters; i++)
       
      if (i & maskQ)
       
      {
       
        result += maskCount[i];
       
        if (result >= Modulo)
       
          result %= Modulo;
       
      }
       
 
       
    // add current number to its bitmask counter
       
    maskCount[maskQ]++;
       
    // avoid overflows
       
    if (maskCount[maskQ] == Modulo)
       
      maskCount[maskQ] = 0;
       
  }
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  // friends(    100) =             1539
       
  // friends(   1000) =           289665
       
  // friends(  10000) =         39235977
       
  // friends( 100000) =       4528635021 % 1000267129 = 527566505
       
  // friends(1000000) =     481858831665 % 1000267129 = 730342616
       
  // friends(   10^7) =   49369806187101 % 1000267129 = 621768177
       
  // friends(   10^8) = 4979780329300065 % 1000267129 = 440930015
       
  unsigned long long limit = 1000000ULL;
       
  std::cin >> limit;
       
  //std::cout << bruteForce(limit) << std::endl;
       
  std::cout << slow(limit) << std::endl;
       
  return 0;
       
}

This solution contains 12 empty lines, 22 comments and 1 preprocessor command.