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 <algorithm>
       
#include <cmath>
       
 
       
// store the number of divisors for the first 100 million numbers

       
typedef unsigned short Number; // => 200 MByte
       
std::vector<Number> numDivisors;
       
 
       
// slow trial division

       
void countDivisorsSlow(unsigned int limit)
       
{
       
  // zero has no divisors
       
  numDivisors = { 0 };
       
 
       
  // process all numbers 1..10^8
       
  for (unsigned int current = 1; current <= limit; current++)
       
  {
       
    Number count = 0;
       
    // trial division of all numbers <= sqrt(current)
       
    for (unsigned int divisor = 1; divisor*divisor <= current; divisor++)
       
    {
       
      // divisible ?
       
      if (current % divisor != 0)
       
        continue;
       
 
       
      count++;                        // one divisor if i^2 = x
       
      if (divisor*divisor != current) // or two if not (it's i and x/i)
       
        count++;
       
    }
       
 
       
    numDivisors.push_back(count);
       
  }
       
}
       
 
       
// similar to a prime sieve, much faster

       
void countDivisors(unsigned int limit, unsigned int primeLimit = 0)
       
{
       
  numDivisors.resize(limit + 1, 1);
       
  // zero has no divisors
       
  numDivisors[0] = 0;
       
 
       
  // accurate algorithm by default
       
  if (primeLimit == 0)
       
    primeLimit = limit;
       
 
       
  // simple prime sieve (trial division because it has the shortest/most simple implementation)
       
  std::vector<unsigned int> primes = { 2 };
       
  for (unsigned int smallPrime = 3; smallPrime <= primeLimit; smallPrime += 2)
       
  {
       
    // find primes by trial division
       
    bool isPrime = true;
       
    for (auto p : primes)
       
      if (smallPrime % p == 0)
       
      {
       
        isPrime = false;
       
        break;
       
      }
       
 
       
    // yes, found another prime
       
    if (isPrime)
       
      primes.push_back(smallPrime);
       
  }
       
 
       
  // multiply all "simple" multiples of each prime by 2
       
  // ... and multiply all multiples p^2 by 3
       
  // ... and multiply all multiples p^3 by 4
       
  // ... and so on
       
  for (auto p : primes)
       
  {
       
    // "simple" multiples
       
    for (auto i = p; i <= limit; i += p)
       
      numDivisors[i] *= 2;
       
 
       
    // multiples of p^2, p^3, ...
       
    auto power    = p * p;
       
    auto exponent = 2;
       
    while (power <= limit)
       
    {
       
      // undo the previous factor and multiply with "better" factor
       
      for (auto i = power; i <= limit; i += power)
       
        numDivisors[i] = (numDivisors[i] / exponent) * (exponent + 1);
       
 
       
      // from to p^2 to p^3 to p^4 ...
       
      power *= p;
       
      exponent++;
       
    }
       
  }
       
}
       
 
       
// enough to verify the example ... (you need to fill numDivisors first)

       
unsigned long long bruteForce(unsigned int limit, unsigned int blockSize)
       
{
       
  // for each range ...
       
  unsigned long long result = 0;
       
  for (unsigned int from = 1; from <= limit - blockSize + 1; from++)
       
  {
       
    // ... find its maximum
       
    Number maximum = numDivisors[from];
       
    for (unsigned int i = 1; i < blockSize; i++)
       
      maximum = std::max(maximum, numDivisors[from + i]);
       
 
       
    // and add it to the result
       
    //std::cout << maximum << " ";
       
    result += maximum;
       
  }
       
 
       
  return result;
       
}
       
 
       
// fast O(n) algorithm: a single pass iterating over all 10^8 elements of numDivisors (you need to fill numDivisors first)

       
unsigned long long search(unsigned int limit, unsigned int blockSize)
       
{
       
  // store the most recent position a certain number of divisors was encountered
       
  // actually the maximum is 768 divisors (first seen at 73513440)
       
  std::vector<unsigned int> mostRecent;
       
 
       
  // process number of divisors of the first block (10^5-1 elements)
       
  for (unsigned int i = 0; i < blockSize; i++)
       
  {
       
    // new/updated maximum
       
    auto current = numDivisors[i];
       
    if (current >= mostRecent.size())
       
      mostRecent.resize(current + 1, 0);
       
    mostRecent[current] = i;
       
  }
       
 
       
  unsigned long long result = 0;
       
  for (unsigned int i = blockSize; i <= limit; i++)
       
  {
       
    // remove "old" maximums
       
    auto tooFar = i - blockSize;
       
    while (!mostRecent.empty() && mostRecent.back() <= tooFar)
       
      mostRecent.pop_back();
       
 
       
    // new/updated maximum
       
    auto current = numDivisors[i];
       
    if (current >= mostRecent.size())
       
      mostRecent.resize(current + 1, 0);
       
    mostRecent[current] = i;
       
 
       
    // highest index is equal to size-1
       
    result += mostRecent.size() - 1;
       
  }
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int limit     = 100000000; // 10^8
       
  unsigned int blockSize =    100000; // 10^5
       
  std::cin >> limit >> blockSize;
       
 
       
  // compute number of divisors for all 100 million numbers
       
  unsigned int primeLimit = limit;
       
  // faster heuristic if possible, fails with small blockSize
       
  if (blockSize >= 100)
       
    primeLimit = sqrt(limit);
       
  // lowest limit for default input: I found it by trial'n'error
       
  if (limit == 100000000 && blockSize == 100000)
       
    primeLimit = 107;
       
 
       
  // compute number of divisors (might be off a little bit when primeLimit != limit)
       
  countDivisors(limit, primeLimit);
       
 
       
  // and now find S(10^8, 10^5)
       
  //std::cout << bruteForce(limit, blockSize) << std::endl;
       
  std::cout << search(limit, blockSize) << std::endl;
       
  return 0;
       
}

This solution contains 25 empty lines, 39 comments and 4 preprocessor commands.