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 long long> combinations;
       
 
       
int main()
       
{
       
  const unsigned int MaxNumber = 1000;
       
  // remember combinations for all combinations from 1 up to 1000
       
  std::vector<combinations> history;
       
 
       
  // store number of combinations in [x] if only summands up to x+1 are allowed:
       
  // [0] => combinations if only 1s are allowed
       
  // [1] => 1s and 2s are allowed, nothing more
       
  // [2] => 1s, 2s and 3s are allowed, nothing more
       
  // ...
       
  // [99] => all but 100 are allowed
       
  // [100] => using all numbers if possible
       
 
       
  unsigned int tests = 1;
       
  std::cin >> tests;
       
  while (tests--)
       
  {
       
    // number that should be represented as a sum
       
    unsigned int x = 100;
       
    std::cin >> x;
       
 
       
    // initially we start at zero
       
    // but if there are previous test cases then we can re-use the old results
       
    for (unsigned int j = history.size(); j <= x; j++)
       
    {
       
      combinations ways(MaxNumber, 0);
       
 
       
      // one combination if using only 1s
       
      ways[0] = 1;
       
 
       
      // use larger numbers, too
       
      for (unsigned int i = 1; i < MaxNumber; i++)
       
      {
       
        // first, pretend not to use that number
       
        ways[i] = ways[i - 1];
       
 
       
        // now use that number once (if possible)
       
        auto current = i + 1;
       
        if (j >= current)
       
        {
       
          auto remaining = j - current;
       
          ways[i] += history[remaining][i];
       
        }
       
 
       
        // only for Hackerrank
       
        // (it prevents printing huge numbers)
       
        ways[i] %= 1000000007;
       
      }
       
 
       
      // store information for future use
       
      history.push_back(ways);
       
    }
       
 
       
    // look up combinations
       
    auto result = history[x];
       
    // the last column contains the desired value
       
    auto combinations = result.back();
       
 
       
    // but it contains one undesired combination, too: the single number MaxNumber itself
       
    // (which fails to be "the sum of two (!) numbers", it's just one number)
       
    // therefore subtract 1
       
    combinations--;
       
 
       
    combinations %= 1000000007; // only for Hackerrank
       
    std::cout << combinations << std::endl;
       
  }
       
  return 0;
       
}

This solution contains 13 empty lines, 23 comments and 2 preprocessor commands.