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.

       
#include <iostream>
       
#include <vector>
       
#include <map>
       
#include <cmath>
       
 
       
// all prime factors of 43!

       
std::vector<unsigned char> primes = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43 };
       
std::vector<unsigned char> factors; // = { 39, 19, 9, 6, 3, 3, 2, 2, 1, 1, 1, 1, 1, 1 };
       
 
       
// store all relevant divisors of 43!

       
std::map<unsigned long long, std::vector<unsigned char>> candidates;
       
 
       
// fill container "factors" with prime exponents of 43!

       
void factorizeFactorial(unsigned int factorial)
       
{
       
  factors.resize(primes.size(), 0);
       
  // each number 2..43
       
  for (unsigned int i = 2; i <= factorial; i++)
       
  {
       
    // find their prime factors ...
       
    auto reduce = i;
       
    for (unsigned int j = 0; j < primes.size(); j++)
       
    {
       
      auto p = primes[j];
       
      // ... and add them
       
      while (reduce % p == 0)
       
      {
       
        factors[j]++;
       
        reduce /= p;
       
      }
       
    }
       
  }
       
}
       
 
       
// find all divisors close to sqrt3(43!) in a recursive way

       
void findCandidates(std::vector<unsigned char>& exponents, unsigned int pos,
       
                    unsigned long long current, unsigned long long atLeast, unsigned long long atMost)
       
{
       
  // multiplied all primes ?
       
  if (pos == exponents.size())
       
  {
       
    // must be within range of relevant divisors
       
    if (current < atLeast || current > atMost)
       
      return;
       
 
       
    // store it
       
    candidates[current] = exponents;
       
    return;
       
  }
       
 
       
  // try all exponents of the current prime
       
  auto maxExponent = exponents[pos];
       
  for (exponents[pos] = 0; exponents[pos] <= maxExponent; exponents[pos]++)
       
  {
       
    if (exponents[pos] > 0)
       
    {
       
      // fast exit if too big
       
      if (current * primes[pos] > atMost)
       
        break;
       
 
       
      current *= primes[pos];
       
    }
       
 
       
    // go deeper ...
       
    findCandidates(exponents, pos + 1, current, atLeast, atMost);
       
  }
       
  // restore previous value
       
  exponents[pos] = maxExponent;
       
}
       
 
       
// find a+b+c, where root3 is an approximation of sqrt3(43!)

       
unsigned long long search(double root3)
       
{
       
  // a+b+c
       
  unsigned long long result = 0;
       
 
       
  // minimize c / a, start with worst case
       
  auto bestRatio = candidates.rbegin()->first / double(candidates.begin()->first);
       
  // the initial numbers probably don't "match"
       
 
       
  // a < sqrt3(43!) and c > sqrt3(43!)
       
  auto mid = candidates.lower_bound(root3);
       
  // compare all pairs a,c
       
  for (auto a = candidates.begin(); a != mid; a++)
       
    for (auto c = mid; c != candidates.end(); c++)
       
    {
       
      // too far apart ?
       
      if (a->first * bestRatio < c->first)
       
        break;
       
 
       
      // calculate b based on the unused prime exponents
       
      bool isValid = true;
       
      unsigned long long b = 1;
       
      for (unsigned int i = 0; i < primes.size() && isValid; i++)
       
      {
       
        // find "remaining" exponent for each prime
       
        auto used = a->second[i] + c->second[i];
       
        // make sure we don't consume "too many" exponents
       
        isValid = used <= factors[i];
       
 
       
        // calculate b
       
        while (used < factors[i])
       
        {
       
          b *= primes[i];
       
          used++;
       
        }
       
      }
       
 
       
      // no valid b ?
       
      if (!isValid)
       
        continue;
       
 
       
      // verify that a <= b <= c
       
      if (b < a->first || b > c->first)
       
        continue;
       
 
       
      // compare ratio against the previous record
       
      auto ratio = c->first / double(a->first);
       
      if (bestRatio > ratio)
       
      {
       
        bestRatio = ratio;
       
        result = a->first + b + c->first;
       
      }
       
 
       
      // a,b,c was a valid triple => if c increments then c/a worsens
       
      break;
       
    }
       
 
       
  // a+b+c
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int limit = 43;
       
  std::cin >> limit;
       
 
       
  // factorize 43!
       
  factorizeFactorial(limit);
       
 
       
  // cheating ?! I optimized the search range manually for 43!
       
  double maxRatio = 0.0002;
       
  std::cin >> maxRatio;
       
  auto atLeast = 1 - maxRatio / 2;
       
  auto atMost  = 1 + maxRatio / 2;
       
 
       
  // approximation of 43!
       
  double factorial = 1;
       
  for (unsigned int i = 2; i <= limit; i++)
       
    factorial *= i;
       
 
       
  // a,b,c will be close to sqrt3(43!)
       
  auto root3 = pow(factorial, 1.0/3);
       
  findCandidates(factors, 0, 1, root3 * atLeast, root3 * atMost);
       
 
       
  // let's find the best triple !
       
  std::cout << search(root3) << std::endl;
       
  return 0;
       
}

This solution contains 24 empty lines, 35 comments and 4 preprocessor commands.