My code

… was written in C++11 and can be compiled with G++, Clang++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <vector>
       
#include <cmath>
       
 
       
// ---------- slow algorithm ----------

       
 
       
std::vector<std::vector<unsigned int>> rooms;
       
 
       
// look up result in precomputed 2D vector "rooms"

       
unsigned int Pslow(unsigned int floor, unsigned int room)
       
{
       
  // from one-indexed to zero-based
       
  floor--;
       
  room--;
       
 
       
  if (floor >= rooms.size())
       
    return 0;
       
  if (room >= rooms[floor].size())
       
    return 0;
       
 
       
  return rooms[floor][room];
       
}
       
 
       
// return true if x is a perfect square

       
bool isSquare(unsigned int x)
       
{
       
  unsigned int root = sqrt(x);
       
  return root * root == x;
       
}
       
 
       
// precompute Hilbert's New Hotel, too slow for the problem, but solves the examples

       
void fillHotel(unsigned int numPersons)
       
{
       
  // one iteration per person
       
  for (unsigned int person = 1; person < numPersons; person++)
       
  {
       
    bool needNewFloor = true;
       
    // try to place person in an existing floor
       
    for (size_t floor = 0; floor < rooms.size(); floor++)
       
    {
       
      // last + person should be a perfect square
       
      if (isSquare(rooms[floor].back() + person))
       
      {
       
        rooms[floor].push_back(person);
       
        needNewFloor = false;
       
        break;
       
      }
       
    }
       
 
       
    // no suitable floor found, create a new floor
       
    if (needNewFloor)
       
    {
       
      std::vector<unsigned int> newFloor = { person };
       
      rooms.push_back(newFloor);
       
    }
       
  }
       
}
       
 
       
// ---------- fast algorithm ----------

       
 
       
// compute P(floor, room)

       
unsigned int P(unsigned long long floor, unsigned long long room, unsigned int modulo = 100000000)
       
{
       
  // compute number in first room of that floor
       
  __int128 result = (__int128)(floor + 1) / 2 * floor;
       
  if (floor % 2 == 1 && floor > 1)
       
    result -= (floor + 1) / 2;
       
 
       
  // separate increments for odd and even rooms
       
  __int128 incrementEven = 1;
       
  if (floor % 2 == 0)
       
    incrementEven = 2 * floor + 1;
       
 
       
  __int128 incrementOdd = 2;
       
  if (floor % 2 == 1)
       
    incrementOdd = 2 * floor;
       
 
       
  // and they are a bit different on the first floor
       
  if (floor == 1)
       
  {
       
    incrementOdd  = 3;
       
    incrementEven = 2;
       
  }
       
 
       
  // my original code:
       
  //for (unsigned int i = 2; i <= room; i += 2)
       
  //{
       
  //  result += incrementEven;
       
  //  incrementEven += 2;
       
  //}
       
  //for (unsigned int i = 3; i <= room; i += 2)
       
  //{
       
  //  result += incrementOdd;
       
  //  incrementOdd += 2;
       
  //}
       
  // and converted to a closed form:
       
 
       
  // number of rooms with even room numbers
       
  __int128 numEven = room / 2;
       
  // sum of 1+2+3+...+numEven
       
  auto triangleEven = numEven * (numEven + 1) / 2;
       
  // sum of 2+4+6+...+2*numEven
       
  triangleEven *= 2;
       
 
       
  // number of rooms with even odd numbers
       
  __int128 numOdd = (room - 1) / 2;
       
  // sum of 1+2+3+...+numOdd
       
  auto triangleOdd = numOdd * (numOdd + 1) / 2;
       
  // sum of 2+4+6+...+2*numOdd
       
  triangleOdd *= 2;
       
 
       
  result += numEven * (incrementEven - 2) + triangleEven;
       
  result += numOdd  * (incrementOdd  - 2) + triangleOdd;
       
 
       
  return result % modulo;
       
}
       
 
       
int main()
       
{
       
  auto maxExponentTwo   = 27;
       
  auto maxExponentThree = 12;
       
  auto number = 71328803586048ULL;
       
 
       
  std::cin >> maxExponentTwo >> maxExponentThree;
       
  number = pow(2ULL, maxExponentTwo) * pow(3ULL, maxExponentThree);
       
 
       
  const unsigned int Modulo = 100000000;
       
 
       
  // solve examples with slow algorithm
       
  //fillHotel(20000);
       
  //std::cout << Pslow( 1,  1) << " " << Pslow( 1,  2) << " " << Pslow( 2,   1) << " "
       
  //          << Pslow(10, 20) << " " << Pslow(25, 75) << " " << Pslow(99, 100) << std::endl;
       
 
       
  unsigned int sum = 0;
       
  // 71328803586048 = 2^27 * 3^12
       
  auto two = 1ULL;
       
  // iterate over all exponents of 2 and 3
       
  for (auto expTwo = 0; expTwo <= maxExponentTwo; expTwo++, two *= 2)
       
  {
       
    auto three = 1ULL;
       
    for (auto expThree = 0; expThree <= maxExponentThree; expThree++, three *= 3)
       
    {
       
      auto floor = two * three;    //         2^expTwo      * 3^expThree
       
      auto room  = number / floor; // will be 2^(27-expTwo) * 3^(12-expThree)
       
      sum += P(floor, room, Modulo);
       
      sum %= Modulo;
       
    }
       
  }
       
 
       
  // finally ...
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 24 empty lines, 39 comments and 3 preprocessor commands.