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 <iomanip>
       
 
       
// return number of batch where a single sheet is in the envelope
       
// parameter is a list of the number of available sheets, starting with A1
       
// e.g. 0x A5, 0x A4, 2x A3, 0x A4, 1x A5 is encoded as { 0, 0, 2, 0, 1 }

       
double evaluate(std::vector<unsigned int> sheets)
       
{
       
  // count sheets
       
  unsigned int numSheets = 0;
       
  for (auto s : sheets)
       
    numSheets += s;
       
 
       
  // a single sheet ?
       
  double single = 0;
       
  if (numSheets == 1)
       
  {
       
    // only one sheet of A5 left => last batch
       
    if (sheets.back() == 1)
       
      return 0;
       
 
       
    // except if the single sheet is A1 (first batch)
       
    if (sheets.front() == 0)
       
      single = 1;
       
  }
       
 
       
  // process all sheet sizes
       
  for (size_t i = 0; i < sheets.size(); i++)
       
  {
       
    if (sheets[i] == 0)
       
      continue;
       
 
       
    auto next = sheets;
       
    // use one piece of the sheet size
       
    next[i]--;
       
    // cut it into smaller pieces
       
    for (size_t j = i + 1; j < next.size(); j++)
       
      next[j]++;
       
 
       
    // how likely do we pick this sheet size ?
       
    double probability = sheets[i] / (double)numSheets;
       
    // analyze next batch
       
    single += evaluate(next) * probability;
       
  }
       
 
       
  return single;
       
}
       
 
       
// I kept this code for historical reasons ... it's not called in main()

       
double montecarlo()
       
{
       
  // more rounds improve precision
       
  const unsigned int NumRounds = 1000000;
       
  // different seeds yields different results ...
       
  srand(111);
       
 
       
  // how often a single sheet is observed
       
  unsigned int singleSheet = 0;
       
  for (unsigned int round = 0; round < NumRounds; round++)
       
  {
       
    // 1 => DIN A1, 2 => A2, ... 5 => A5
       
    // this stack of sheets may contain some sizes multiple times
       
    const unsigned int SheetSizes = 5;
       
    unsigned int sheets[SheetSizes] = { 1,0,0,0,0 }; // one sheet A1 on Monday morning
       
    unsigned int numSheets = 1;
       
 
       
    // until all sheets are used (on Friday afternoon)
       
    while (numSheets > 0)
       
    {
       
      // a single sheet ?
       
      if (numSheets == 1)
       
        singleSheet++;
       
 
       
      // pick a random sheet
       
      unsigned int pick = rand() % numSheets;
       
      unsigned int current = 0;
       
      // select sheet size
       
      while (pick >= sheets[current])
       
        pick -= sheets[current++];
       
      // and remove one sheet
       
      sheets[current]--;
       
 
       
      // reduce total number of sheets, too
       
      numSheets--;
       
 
       
      // if the current sheet is larger than A5 then cut it into smaller sheets
       
      while (++current < SheetSizes)
       
      {
       
        sheets[current]++;
       
        numSheets++;
       
      }
       
    }
       
 
       
    // don't count the first and last batch (always one sheet)
       
    singleSheet -= 2;
       
  }
       
 
       
  return singleSheet / (double)NumRounds;
       
}
       
 
       
int main()
       
{
       
  std::cout << std::fixed << std::setprecision(6);
       
 
       
  // start with one A1 sheet
       
  std::cout << evaluate({ 1,0,0,0,0 }) << std::endl;
       
 
       
  // my first approach was using a Monte-Carlo simulation but it converges too slowly
       
  //std::cout << montecarlo() << std::endl;
       
 
       
  return 0;
       
}

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