My code

… was written in C++ 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>
       
 
       
// initial state: no digits used, all bits are zero

       
const unsigned int NoDigits  =  0;
       
// all ten digits used => all ten bits set

       
const unsigned int AllDigits = (1 << 10) - 1; // = 1023
       
// analyze all numbers with up to 10^40

       
const unsigned int MaxDigits = 40;
       
 
       
// count pandigital step number where bits in "mask" are set according to the first digits
       
// and the current digit is "currentDigit" with "numDigitsLeft" digits to go

       
unsigned long long search(unsigned int mask, unsigned int currentDigit, unsigned int numDigitsLeft)
       
{
       
  // update mask, "use digit"
       
  mask |= 1 << currentDigit;
       
 
       
  // arrived at last digit ?
       
  if (numDigitsLeft == 1)
       
  {
       
    // all ten bits set ? => pandigital
       
    if (mask == AllDigits)
       
      return 1; // yes, a solution
       
 
       
    // not pandigital, no valid solution
       
    return 0;
       
  }
       
 
       
  // memoize
       
  unsigned int hash = mask * MaxDigits * 10 + (numDigitsLeft - 1) * 10 + currentDigit;
       
  static std::vector<unsigned long long> cache(1024 * 10 * MaxDigits, 0);
       
  // result already known ?
       
  if (cache[hash] != 0)
       
    return cache[hash];
       
 
       
  unsigned long long result = 0;
       
  // next digit is smaller
       
  if (currentDigit > 0)
       
    result += search(mask, currentDigit - 1, numDigitsLeft - 1);
       
  // next digit is bigger
       
  if (currentDigit < 9)
       
    result += search(mask, currentDigit + 1, numDigitsLeft - 1);
       
 
       
  cache[hash] = result;
       
  return result;
       
}
       
 
       
int main()
       
{
       
  // maxDigits is the actual number of digits
       
  // MaxDigits is the highest allowed value for maxDigits
       
  // I know, it's confusing ...
       
  unsigned int maxDigits = 40;
       
  std::cin >> maxDigits;
       
  // note: input syntax differs from Hackerrank !
       
 
       
  unsigned long long result = 0;
       
  // for each number of digits ...
       
  for (unsigned int numDigits = 1; numDigits <= maxDigits; numDigits++)
       
  {
       
    // ... the first one must be 1..9 (and never zero !)
       
    for (unsigned int digit = 1; digit <= 9; digit++)
       
      result += search(NoDigits, digit, numDigits);
       
 
       
    // a little bit faster:
       
    //result += 2 * search(NoDigits, 1, numDigits);
       
    //result += 2 * search(NoDigits, 2, numDigits);
       
    //result += 2 * search(NoDigits, 3, numDigits);
       
    //result += 2 * search(NoDigits, 4, numDigits);
       
    //result +=     search(NoDigits, 9, numDigits);
       
  }
       
 
       
  std::cout << result << std::endl;
       
  return 0;
       
}

This solution contains 11 empty lines, 25 comments and 2 preprocessor commands.