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>
       
 
       
// the first player with 100 points wins

       
unsigned int maxScore = 100;
       
 
       
// fixed probabilities of player one

       
const double win1  = 0.5;
       
const double lose1 = 1 - win1; // = 0.5
       
 
       
// return chance of winning for player 2 when it's his/her turn

       
double twoWins(unsigned int needPointsOne, unsigned int needPointsTwo)
       
{
       
  // player two won
       
  if (needPointsTwo == 0)
       
    return 1;
       
  // player one won
       
  if (needPointsOne == 0)
       
    return 0;
       
 
       
  // memoize
       
  const double Unknown = -1;
       
  static std::vector<double> cache(maxScore * maxScore, Unknown);
       
 
       
  auto id = (needPointsOne - 1) * maxScore + needPointsTwo - 1;
       
  if (cache[id] != Unknown)
       
    return cache[id];
       
 
       
  // find highest chance of winning
       
  double best = 0;
       
  // current bet (observation: betting more than 2^3 = 8 never seems profitable)
       
  unsigned int bet = 1;
       
  while (true)
       
  {
       
    // probabilities
       
    auto win2  = 0.5 / bet; // 2^(bet-1)
       
    auto lose2 = 1 - win2;
       
 
       
    // in case player two scores he shall not exceed the maximum score
       
    auto nextPointsTwo = (needPointsTwo < bet) ? 0 : needPointsTwo - bet;
       
 
       
    // at least one player scored a point
       
    auto current = win1  * win2  * twoWins(needPointsOne - 1, nextPointsTwo) +
       
                   lose1 * win2  * twoWins(needPointsOne,     nextPointsTwo) +
       
                   win1  * lose2 * twoWins(needPointsOne - 1, needPointsTwo);
       
 
       
    // both players lost, stay in same state
       
    current /= 1 - lose1 * lose2;
       
 
       
    // better than before ?
       
    if (best < current)
       
      best = current;
       
 
       
    // no use in further increasing the risk of player 2 ?
       
    if (nextPointsTwo == 0)
       
      break;
       
 
       
    // twice the risk, twice the reward ...
       
    bet *= 2;
       
  }
       
 
       
  cache[id] = best;
       
  return best;
       
}
       
 
       
int main()
       
{
       
  std::cin >> maxScore;
       
 
       
  // player one moves first
       
  // two options: he/she score one point or not
       
  // => add both states (multiplied by their probability)
       
  auto result = win1  * twoWins(maxScore - 1, maxScore) +
       
                lose1 * twoWins(maxScore,     maxScore);
       
 
       
  std::cout << std::fixed << std::setprecision(8)
       
            << result << std::endl;
       
  return 0;
       
}

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