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 <string>
       
#include <vector>
       
#include <algorithm>
       
 
       
#define ORIGINAL
       
 
       
// return true if x is prime, based on trial division (not suitable for large numbers)

       
bool isPrime(unsigned long long x)
       
{
       
  // trial divison by 2
       
  if (x % 2 == 0)
       
    return x == 2;
       
 
       
  // trial division by odd numbers
       
  for (unsigned long long i = 3; i*i <= x; i++)
       
    if (x % i == 0)
       
      return false;
       
 
       
  return true;
       
}
       
 
       
// find all numbers where "digit" is repeated "repeat" times and "extraDigits" digits are added
       
// e.g. 10007 is found by search(0, 3, 2)

       
unsigned long long search(unsigned int digit, unsigned int repeat, unsigned int extraDigits, bool printPrimes = false)
       
{
       
  // sum of all matching primes
       
  unsigned long long sum = 0;
       
  std::vector<unsigned long long> matches; // Hackerrank only: print matches in ascending order
       
 
       
  // create string with a digit repeated a few times
       
  std::string sameDigit(repeat, digit + '0');
       
 
       
  // insert numbers i where 0 <= i < maxExtra
       
  // e.g. if extraDigits = 3 then from 0 to 999 (actually from "000" to "999")
       
  unsigned long long maxExtra = 1;
       
  for (unsigned int i = 1; i <= extraDigits; i++)
       
    maxExtra *= 10;
       
 
       
  // let's insert all those numbers !
       
  for (unsigned long long extra = 0; extra < maxExtra; extra++)
       
  {
       
    // convert to string
       
    auto current = std::to_string(extra);
       
    // is in ascending order ?
       
    auto sorted = current;
       
    std::sort(sorted.begin(), sorted.end());
       
    if (current != sorted)
       
      continue;
       
 
       
    // add zeros if "extra" has too few digits
       
    while (current.size() < extraDigits)
       
      current = '0' + current;
       
 
       
    // and add the bunch of identical digits
       
    current += sameDigit;
       
    // sort everything to ensure that std::next_permutation works properly
       
    std::sort(current.begin(), current.end());
       
 
       
    do
       
    {
       
      // no leading zeros
       
      if (current.front() == '0')
       
        continue;
       
      // no even numbers
       
      if (current.back() % 2 == 0) // ASCII code of even digits is even, too
       
        continue;
       
 
       
      // is it a prime ?
       
      unsigned long long num = std::stoll(current);
       
      if (isPrime(num))
       
      {
       
        sum += num;
       
        if (printPrimes)
       
          matches.push_back(num);
       
      }
       
    } while (std::next_permutation(current.begin(), current.end()));
       
  }
       
 
       
  // Hackerrank only: print all primes we found
       
  if (printPrimes && !matches.empty())
       
  {
       
    std::sort(matches.begin(), matches.end());
       
    for (auto x : matches)
       
      std::cout << x << " ";
       
  }
       
 
       
  return sum;
       
}
       
 
       
 
       
int main()
       
{
       
#ifdef ORIGINAL
       
  // total number of digits
       
  unsigned int digits = 10;
       
  std::cin >> digits;
       
  // sum of all matching primes
       
  unsigned long long sum = 0;
       
 
       
  // iterate over all repeated digits
       
  for (unsigned int i = 0; i <= 9; i++)
       
  {
       
    // try to use as many repeated digits as possible
       
    for (unsigned int repeated = digits - 1; repeated >= 1; repeated--)
       
    {
       
      auto insertDigits = digits - repeated;
       
      auto found = search(i, repeated, insertDigits);
       
      // found at least one prime ?
       
      if (found > 0)
       
      {
       
        sum += found;
       
        break;
       
      }
       
    }
       
  }
       
 
       
  std::cout << sum << std::endl;
       
 
       
#else
       
 
       
  unsigned int tests;
       
  std::cin >> tests;
       
  while (tests--)
       
  {
       
    unsigned int digits;
       
    unsigned int sameDigit;
       
    std::cin >> digits >> sameDigit;
       
 
       
    if (digits < 19) // my code can't handle > 64 bits at the moment
       
    {
       
      // iterate over all repeated digits
       
      for (unsigned int repeated = digits - 1; repeated >= 1; repeated--)
       
      {
       
        auto insertDigits = digits - repeated;
       
        if (search(sameDigit, repeated, insertDigits, true) > 0)
       
          break;
       
      }
       
    }
       
 
       
    std::cout << std::endl;
       
  }
       
#endif
       
 
       
  return 0;
       
}

This solution contains 23 empty lines, 25 comments and 8 preprocessor commands.