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.

The code contains #ifdefs to switch between the original problem and the Hackerrank version.
Enable #ifdef ORIGINAL to produce the result for the original problem (default setting for most problems).

       
#define ORIGINAL
       
#ifdef  ORIGINAL
       
 
       
#include <iostream>
       
#include <vector>
       
#include <map>
       
 
       
typedef std::vector<unsigned int> Sequence;
       
std::map<unsigned int, Sequence> solutions;
       
 
       
// number of elements in full set

       
unsigned int finalSize;
       
// lower limit for the smallest element

       
unsigned int minElement;
       
// upper limit for the biggest element

       
unsigned int maxElement;
       
 
       
// return true if sequence is special

       
bool check(const Sequence& sequence)
       
{
       
  // sum of all elements
       
  unsigned int fullSum = 0;
       
  for (auto x : sequence)
       
    fullSum += x;
       
 
       
  // mark each generated sum as true, no collisions allowed
       
  std::vector<bool> sums(fullSum + 1, false);
       
 
       
  // track the lowest and highest sum for each subset size
       
  std::vector<unsigned int> maxSum(sequence.size() + 1, 0);
       
  std::vector<unsigned int> minSum(sequence.size() + 1, fullSum + 1);
       
  minSum[0] = maxSum[0] = 0; // empty set
       
 
       
  unsigned int fullMask = (1 << sequence.size()) - 1;
       
 
       
  // 2^elements iterations (actually, I ignore the empty set)
       
  for (unsigned int mask = 1; mask <= fullMask; mask++)
       
  {
       
    unsigned int sum  = 0;
       
    unsigned int size = 0;
       
    for (unsigned int element = 0; element < sequence.size(); element++)
       
    {
       
      // use that element ?
       
      unsigned int bit = 1 << element;
       
      if ((mask & bit) == 0)
       
        continue;
       
 
       
      sum += sequence[element];
       
      // count subset size
       
      size++;
       
    }
       
 
       
    // two subsets share the same sum ?
       
    if (sums[sum])
       
      return false;
       
    sums[sum] = true;
       
 
       
    // adjust lowest and highest sum of current subset
       
    if (minSum[size] > sum)
       
      minSum[size] = sum;
       
    if (maxSum[size] < sum)
       
      maxSum[size] = sum;
       
  }
       
 
       
  // make sure that no set will fewer elements has a higher sum
       
  for (size_t i = 1; i < sequence.size(); i++)
       
    if (maxSum[i] > minSum[i + 1])
       
      return false;
       
 
       
  // yes, have another solution
       
  solutions[fullSum] = sequence;
       
  return true;
       
}
       
 
       
// enumerate all sequences where each number is between minElement and maxElement and a_i > a_j if i > j

       
void search(Sequence& sequence) // manipulate in-place
       
{
       
  // enough elements ? check whether it is "special"
       
  if (sequence.size() == finalSize)
       
  {
       
    check(sequence);
       
    return;
       
  }
       
 
       
  // all numbers which are bigger than the predecessor
       
  auto last = sequence.empty() ? minElement - 1 : sequence.back(); // minus 1 because last always adds 1
       
  for (unsigned int i = last + 1; i <= maxElement; i++)
       
  {
       
    sequence.push_back(i);
       
 
       
    // go deeper ...
       
    search(sequence);
       
 
       
    sequence.pop_back();
       
  }
       
}
       
 
       
int main()
       
{
       
  // read set size
       
  std::cin >> finalSize;
       
 
       
  // crude heuristics for the lower and upper limits
       
  minElement = 1;
       
  maxElement = 10;
       
  if (finalSize >= 5)
       
  {
       
    maxElement = finalSize * finalSize;
       
    minElement = maxElement / 4;
       
  }
       
 
       
  Sequence empty;
       
  search(empty);
       
 
       
  // `n = 1: {  1 }`
       
  // `n = 2: {  1,  2 }`
       
  // `n = 3: {  2,  3,  4 }`
       
  // `n = 4: {  3,  5,  6,  7 }`
       
  // `n = 5: {  6,  9, 11, 12, 13 }`
       
  // `n = 6: { 11, 18, 19, 20, 22, 25 }`
       
  for (auto s : solutions)
       
  {
       
    for (auto x : s.second)
       
      std::cout << x;
       
    break;
       
  }
       
 
       
  return 0;
       
}
       
 
       
#else
       
 
       
// heavily modified Hackerrank problem

       
 
       
#include <iostream>
       
#include <vector>
       
 
       
typedef std::vector<unsigned int> Sequence;
       
 
       
// apply near-optimal algorithm to increase sequence by one element
       
// my algorithm builds the sequence in reverse

       
void next(Sequence& sequence) // modify in-place
       
{
       
  auto middle = sequence[(sequence.size() - 1) / 2];
       
  for (auto& x : sequence)
       
    x = (x + middle) % 1000000007;
       
  sequence.push_back(middle);
       
}
       
 
       
int main()
       
{
       
  unsigned int length;
       
  std::cin >> length;
       
 
       
  Sequence sequence = { 1 };
       
  sequence.reserve(length);
       
  for (unsigned int i = 2; i <= length; i++)
       
    next(sequence);
       
 
       
  for (auto i = sequence.rbegin(); i != sequence.rend(); i++)
       
    std::cout << *i << " ";
       
  std::cout << std::endl;
       
  return 0;
       
}
       
 
       
#endif

This solution contains 31 empty lines, 29 comments and 9 preprocessor commands.