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 <iomanip>
       
#include <map>
       
 
       
// Barbara hits exactly 20 times out of 50 attempted shots

       
      unsigned int threshold   = 20;
       
const unsigned int maxDistance = 50;
       
// Barbara has a 2% chance of making exactly 20 points (50 attempts)

       
const double chanceHitExactly  =  0.02;
       
 
       
// find probability of making 20 shots given a certain q
       
// note: second and third parameter are needed for internal recursion only

       
double probability(double q, unsigned int made = 0, unsigned int distance = 1)
       
{
       
  // made too many shots
       
  if (made > threshold)
       
    return 0;
       
 
       
  // finished ? => made exactly 20 shots ?
       
  if (distance > maxDistance)
       
    return made == threshold ? 1 : 0;
       
 
       
  // memoize
       
  static std::map<std::pair<unsigned int, double>, double> cache;
       
  auto id = std::make_pair(made * (maxDistance + 1) + distance, q);
       
  auto lookup = cache.find(id);
       
  if (lookup != cache.end())
       
    return lookup->second;
       
 
       
  // compute probabilities
       
  double chanceHit  = 1 - distance / q;
       
  double chanceMiss = 1 - chanceHit; // can be simplified to distance/q
       
 
       
  // go back one step
       
  distance++;
       
  // and attempt one more shot: could be a hit, could be a miss ...
       
  double result = chanceHit  * probability(q, made + 1, distance) +
       
                  chanceMiss * probability(q, made,     distance);
       
 
       
  cache[id] = result;
       
  return result;
       
}
       
 
       
int main()
       
{
       
  // user-defined number of made shots from distances 1..50
       
  std::cin >> threshold;
       
 
       
  // start with a large interval of potential values of q:
       
  // q >   50 because otherwise there would be a negative probability for the shot from distance 50
       
  double low  = maxDistance;
       
  // q <= 100 is a pretty random choice ... and it's much larger than the true value q
       
  double high = 100;
       
 
       
  // ten decimal places
       
  double accuracy = 0.0000000001;
       
  // while interval is still too wide ...
       
  while (high - low > accuracy)
       
  {
       
    // analyze its midpoint
       
    auto mid = (high + low) / 2;
       
 
       
    // below 2% ?
       
    if (probability(mid) < chanceHitExactly)
       
      high = mid; // mid is larger  than the true q
       
    else
       
      low  = mid; // mid is smaller than the true q
       
  }
       
 
       
  if (low > 50)
       
    // low == high (at least with respect to their first 10 decimal places)
       
    std::cout << std::fixed << std::setprecision(10) << low << std::endl;
       
  else
       
    std::cout << "impossible" << std::endl;
       
 
       
  return 0;
       
}

This solution contains 13 empty lines, 19 comments and 3 preprocessor commands.