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 <vector>
       
#include <iostream>
       
#include <cmath>
       
 
       
const double Epsilon = 0.00001;
       
 
       
// try all arithmetic operations of any two elements of "numbers", set their result in "used" to true

       
void eval(const std::vector<double>& numbers, std::vector<bool>& used)
       
{
       
  // 1. if array holds just one element, add it to the "used" list and we are done
       
  // 2. pick any two numbers
       
  // 3. loop through all operators
       
  // 4. add result to the array and call eval() recursively
       
 
       
  // step 1
       
  if (numbers.size() == 1)
       
  {
       
    auto result = numbers.front() + Epsilon;
       
    // reject non-integer result (caused by division)
       
    if (fmod(result, 1) > 10*Epsilon)
       
      return;
       
 
       
    int index = int(result + Epsilon);
       
    // reject negative and very large results
       
    if (index >= 0 && index < (int)used.size())
       
      used[index] = true;
       
 
       
    return;
       
  }
       
 
       
  // step 2
       
  auto next = numbers;
       
  for (size_t i = 0; i < numbers.size(); i++)
       
    for (size_t j = i + 1; j < numbers.size(); j++)
       
    {
       
      // fetch two numbers
       
      double a = numbers[i];
       
      double b = numbers[j];
       
 
       
      // prepare for next recursive step
       
      next = numbers;
       
      next.erase(next.begin() + j); // delete the higher index first
       
      next.erase(next.begin() + i);
       
 
       
      // steps 3 and 4 (unrolled)
       
      next.push_back(a + b); // add
       
      eval(next, used);
       
      next.back() = a - b;   // subtract (I)
       
      eval(next, used);
       
      next.back() = b - a;   // subtract (II)
       
      eval(next, used);
       
      next.back() = a * b;   // multiply
       
      eval(next, used);
       
      if (b != 0)
       
      {
       
        next.back() = a / b; // divide (I)
       
        eval(next, used);
       
      }
       
      if (a != 0)
       
      {
       
        next.back() = b / a; // divide (II)
       
        eval(next, used);
       
      }
       
 
       
      // note: I overwrite the last element because that's simpler than
       
      // pop_back(); push_back(...);
       
    }
       
}
       
 
       
// evaluate all expressions and count how many numbers from 1 to x can be expressed without any gaps

       
unsigned int getSequenceLength(const std::vector<double>& numbers)
       
{
       
  // find all results
       
  std::vector<bool> used(1000, false);
       
  eval(numbers, used);
       
 
       
  // longest sequence, beginning from 1
       
  unsigned int result = 0;
       
  while (used[result + 1])
       
    result++;
       
  return result;
       
}
       
 
       
int main()
       
{
       
#define ORIGINAL
       
#ifdef ORIGINAL
       
  unsigned int longestSequence = 0;
       
  unsigned int longestDigits   = 0;
       
 
       
  // four different digits
       
  for (unsigned int a =   1; a <= 6; a++)
       
    for (unsigned int b = a+1; b <= 7; b++)
       
      for (unsigned int c = b+1; c <= 8; c++)
       
        for (unsigned int d = c+1; d <= 9; d++)
       
        {
       
          // evaluate all combinations
       
          auto sequenceLength = getSequenceLength({ double(a), double(b), double(c), double(d) });
       
 
       
          // new record ?
       
          if (longestSequence < sequenceLength)
       
          {
       
            longestSequence = sequenceLength;
       
            // build one number out of the four digits
       
            longestDigits = a * 1000 + b * 100 + c * 10 + d;
       
          }
       
        }
       
 
       
  // print result
       
  std::cout << longestDigits << std::endl;
       
 
       
#else
       
 
       
  // 1..5 digits
       
  unsigned int numDigits;
       
  std::cin >> numDigits;
       
  // read those digits
       
  std::vector<double> numbers(numDigits);
       
  for (auto& x : numbers)
       
    std::cin >> x;
       
 
       
  // print length of longest sequence
       
  std::cout << getSequenceLength(numbers);
       
 
       
#endif
       
 
       
  return 0;
       
}

This solution contains 20 empty lines, 25 comments and 7 preprocessor commands.