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).

       
#include <iostream>
       
#include <vector>
       
#include <algorithm>
       
 
       
// pseudo-random number generator

       
int lcg()
       
{
       
  static long long seed = 0;
       
  seed = (615949 * seed + 797807) % (1 << 20);
       
  return int(seed - (1 << 19));
       
}
       
 
       
int main()
       
{
       
  // indexed: triangle[y][x] where y denotes the row
       
  std::vector<std::vector<int>> triangle;
       
 
       
  // step 1: initialize the triangle (either with random data or from STDIN)
       
#define ORIGINAL
       
#ifdef ORIGINAL
       
  // 1000 rows
       
  unsigned int maxSize = 1000;
       
  std::cin >> maxSize;
       
 
       
  // fill with (pseudo) random data
       
  triangle.resize(maxSize);
       
  for (size_t y = 0; y < triangle.size(); y++)
       
    for (size_t x = 0; x <= y; x++)
       
      triangle[y].push_back(lcg());
       
 
       
#else
       
  size_t size;
       
  size_t maxResults;
       
  std::cin >> size >> maxResults;
       
 
       
  triangle.resize(size);
       
  for (size_t y = 0; y < size; y++)
       
    for (size_t x = 0; x <= y; x++)
       
    {
       
      int current;
       
      std::cin >> current;
       
      triangle[y].push_back(current);
       
    }
       
#endif
       
 
       
  // step 2: build another triangle called "sums" where each cell is sum(triangle[y][0..x])
       
  std::vector<std::vector<int>> sums(triangle.size());
       
  for (size_t y = 0; y < triangle.size(); y++)
       
  {
       
    // same size
       
    sums[y].resize(triangle[y].size());
       
 
       
    // store running sum of all cells to the left of the current cell, including the current, too
       
    int rowSum = 0;
       
    for (size_t x = 0; x <= y; x++)
       
    {
       
      rowSum += triangle[y][x];
       
      sums[y][x] = rowSum;
       
    }
       
  }
       
 
       
  // store the smallest sums
       
#ifdef ORIGINAL
       
  auto result = triangle[0][0]; // simplify if only one sum
       
#else
       
  std::vector<int> results;   // needs sorting, pruning, etc.
       
#endif
       
 
       
  // analyze all positions
       
  for (size_t y = 0; y < triangle.size(); y++)
       
  {
       
    for (size_t x = 0; x <= y; x++)
       
    {
       
      // smallest triangle consists of a single-cell
       
      auto sum = triangle[y][x];
       
 
       
      // better than before ?
       
#ifdef ORIGINAL
       
      if (result > sum)
       
        result = sum;
       
#else
       
      results.push_back(sum);
       
#endif
       
 
       
      // add rows
       
      auto maxSize = triangle.size() - y;
       
      for (size_t current = 1; current < maxSize; current++)
       
      {
       
        // compute sum(triangle[y + rows][x ... x + rows])
       
        // add singles values, "old way"
       
        //for (size_t scan = x; scan <= x + current; scan++)
       
        //  sum += triangle[y + current][scan];
       
 
       
        // access pre-computed running sums from step 2, "new way"
       
        auto rowSum = sums[y + current][x + current];
       
        if (x > 0)
       
          rowSum -= sums[y + current][x - 1];
       
        sum += rowSum;
       
 
       
        // better than before ?
       
#ifdef ORIGINAL
       
        if (result > sum)
       
          result = sum;
       
#else
       
        results.push_back(sum);
       
#endif
       
      }
       
    }
       
 
       
#ifndef ORIGINAL
       
    // prune sums
       
    std::sort(results.begin(), results.end());
       
    if (results.size() > maxResults)
       
      results.erase(results.begin() + maxResults, results.end());
       
#endif
       
  }
       
 
       
  // show result
       
#ifdef ORIGINAL
       
  std::cout << result << std::endl;
       
#else
       
  for (auto x : results)
       
    std::cout << x << std::endl;
       
#endif
       
 
       
  return 0;
       
}

This solution contains 17 empty lines, 21 comments and 21 preprocessor commands.