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>
       
 
       
// ---------- based on similar code in my toolbox ----------

       
 
       
// factorial
       
// result is not accurate but supports large ranges

       
double factorial(unsigned int n)
       
{
       
  double result = 1;
       
  while (n > 1)
       
    result *= n--;
       
  return result;
       
}
       
 
       
// number of ways to choose n elements from k available

       
double choose(unsigned int n, unsigned int k)
       
{
       
  // n! / (n-k)!k!
       
  return factorial(n) / (factorial(n - k) * factorial(k));
       
}
       
 
       
// ---------- problem-specific code ----------

       
 
       
// count derangement
       
// note: need double as return type because results will be HUGE

       
double derangements(unsigned int move, unsigned int dontCare)
       
{
       
  // don't need to move a prime away from its original position ?
       
  if (move < 1)
       
    return factorial(dontCare); // permutation of all remaining numbers
       
 
       
  // recursion
       
  move--;
       
  auto result = dontCare * derangements(move,     dontCare);
       
  if (move > 0)
       
    result   += move     * derangements(move - 1, dontCare + 1);
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int disks  = 100;
       
  unsigned int primes =  25;
       
  unsigned int moved  =  22;
       
  std::cin >> moved;
       
 
       
  // detect invalid input: for live test only
       
  if (moved > primes)
       
    return 1;
       
 
       
  unsigned int unchanged = primes - moved;
       
 
       
  // count ways
       
  double result = derangements(moved, disks - primes);
       
 
       
  // => 2300 ways to choose 3 primes
       
  result *= choose(primes, unchanged);
       
  // divide by total number of permutations
       
  result /= factorial(disks);
       
 
       
  // display result
       
  std::cout << std::fixed << std::setprecision(12) << result << std::endl;
       
  return 0;
       
}

This solution contains 13 empty lines, 15 comments and 2 preprocessor commands.