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 <vector>
       
 
       
// ---------- Monte-Carlo simulation to get a rough estimation ----------
       
// note: not used anymore

       
 
       
// a simple pseudo-random number generator
       
// (produces the same result no matter what compiler you have - unlike rand() from math.h)

       
unsigned int myrand()
       
{
       
  static unsigned long long seed = 0;
       
  seed = 6364136223846793005ULL * seed + 1;
       
  return (unsigned int)(seed >> 30);
       
}
       
 
       
// Monte Carlo simulation

       
double monteCarlo(unsigned int numColors, unsigned int numBallsPerColor, unsigned int picks, unsigned int iterations)
       
{
       
  // count different colors of all iterations
       
  unsigned int sum = 0;
       
 
       
  auto numBalls = numColors * numBallsPerColor;
       
  for (unsigned int i = 0; i < iterations; i++)
       
  {
       
    std::vector<bool> current(numBalls, true);
       
    for (unsigned int j = 0; j < picks; j++)
       
    {
       
      unsigned int id;
       
      // pick a ball (if still available)
       
      do
       
        id = myrand() % numBalls;
       
      while (!current[id]);
       
 
       
      // remove that ball
       
      current[id] = false;
       
    }
       
 
       
    // for each color check if at least one ball was picked
       
    for (unsigned int c = 0; c < numColors; c++)
       
      for (unsigned int b = 0; b < numBallsPerColor; b++)
       
      {
       
        auto id = c * numBallsPerColor + b;
       
        if (!current[id])
       
        {
       
          sum++;
       
          break;
       
        }
       
      }
       
  }
       
 
       
  return sum / double(iterations);
       
}
       
 
       
// ---------- my solution ----------

       
 
       
// number of ways to choose n elements from k available
       
// taken from problem 116

       
unsigned long long choose(unsigned long long n, unsigned long long k)
       
{
       
  // n! / (n-k)!k!
       
  unsigned long long result = 1;
       
  // reduce overflow by dividing as soon as possible to keep numbers small
       
  for (unsigned long long invK = 1; invK <= k; invK++)
       
  {
       
    result *= n;
       
    result /= invK;
       
    n--;
       
  }
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int colors        =  7;
       
  unsigned int ballsPerColor = 10;
       
  unsigned int picks         = 20;
       
  std::cin >> colors >> ballsPerColor >> picks;
       
 
       
  const auto numBalls = colors * ballsPerColor;
       
 
       
  std::cout << std::fixed << std::setprecision(9);
       
 
       
  // run Monte-Carlo simulation to estimate the result
       
  //while (true)
       
    //std::cout << monteCarlo(colors, ballsPerColor, picks, 10000000) << std::endl;
       
 
       
  // and now the precise computation
       
  double result = 0;
       
  for (unsigned int current = 0; current < colors; current++)
       
  {
       
    // count combinations where any ball is picked - but not from a special color
       
    auto dontPickThatColor = choose(numBalls - ballsPerColor, picks);
       
    // count combinations where any ball can be picked, no matter what color
       
    auto total             = choose(numBalls,                 picks);
       
 
       
    // probability that the current color was not picked
       
    auto absent   = dontPickThatColor / double(total);
       
    // probability that the current color was     picked
       
    auto hasColor = 1 - absent;
       
 
       
    // expected value: 0 if absent, 1 if present
       
    result += 0 * absent + 1 * hasColor; // which is the same as result += hasColor
       
  }
       
 
       
  // obviously all 7 iterations don't depend on "current" and could be merged into a single equation:
       
  //result = colors * (1 - choose(numBalls - ballsPerColor, picks) / (double)choose(numBalls, picks));
       
 
       
  // and we're done !
       
  std::cout << result << std::endl;
       
  return 0;
       
}

This solution contains 18 empty lines, 26 comments and 3 preprocessor commands.