Google hiring smart engineers ( if you can solve this one )

solve this puzzle to send your resume .

... where you find the next diversion:

Congratulations. You've made it to level 2. Go to ---.-------.--- and enter xxxxxxxxxxx as the login and the answer to this equation as the password.

f(1)= 7182818284
f(2)= 8182845904
f(3)= 8747135266
f(4)= 7427466391
f(5)= __________

The url and Username differ in the original text

f(5)=5966290435

public class Google{
 
   private static int decimalplaces = 0;
   private static int magnifyCount = 0;
 
   public static void main(String[] args){
      double e = 1;                //Set e to 1 in order to avoid calculation of 0!
      boolean primeFound = false;  //Until prime is found...
      long denom = 1;              //Initialize to one to avoid x * 0 = 0 in factorial
      int count;                   //Used to create factorial
 
 
      for(count = 1; count <= 15; count++){  //get at least 10 decimal places of expansion
         denom *= count;
         e += 1.0/denom;
      }
 
      double eMagnified = magnify(e);
      System.out.println(eMagnified);
 
 
      while(!primeFound){
         if(isPrime((long)eMagnified)){
            System.out.println("----------->" + (long)eMagnified);
            primeFound = true;
         }
         else{
            eMagnified = truncateLeading(eMagnified);
            System.out.println(eMagnified);
 
            if(decAcc(denom) <= magnifyCount-1){                          //If there needs to be another term added...
 
               denom *= count;                                            //Essentially, this is the factorial in the 
               eMagnified += (1.0/denom) * Math.pow(10, magnifyCount);    //denominator of the Taylor expansion - 
                                                                          //increase once every iteration
               System.out.println("+" + 1.0/denom + "=" + eMagnified);
               try{Thread.currentThread().sleep(500);}catch(InterruptedException ex){}
               count++;
            }
         }
      }
      
   }
 
   /* Recursively finds the number of accurate decimal
    * places represented in an approximation to a series 
    * of X(n), where x(n+1) < x(n).  The series must be 
    * convergent.
    *
    * @param The reciprocal of a fraction of
    * the form << 1/x >>, (i.e., x).
    * @return The number of accurate decimal places represented
    * by the reciprocal of the nth term.
    */
 
   private static int decAcc(long reciprocal){
      if(reciprocal < 10){
         int temp = decimalplaces;
         decimalplaces = 0;        //Re-initialize for subsequent calls
         return temp;
      }
      else{
         decimalplaces++;
         reciprocal /= 10;
         return decAcc(reciprocal);
      }
   }
 
   private static double truncateLeading(double eMagnified){
      long base = 1000000000;
 
      for(int i = 9; i > 0; i--){
         if(eMagnified >= i * base){
            eMagnified -= i * base;   //remove the leading value
            eMagnified *= 10;         //shift left by 1
            magnifyCount++;
            break;
         }
      }
      
      return eMagnified;
   }
 
 
   /* Gets the leading ten numbers of the
    * e expansion and converts them to an
    * integer.
    */
 
   private static double magnify(double e){
      double upperBound = 1000000000.;
 
      if(e >= upperBound){
          magnifyCount = 0;
          return e;
      }
      else{
         e *= 10;
         magnifyCount++;
         return magnify(e);
      }
   }
 
 
   private static boolean isPrime(long testLong){
      for(long i = 2; i <= (long)Math.sqrt(testLong); i++){
         if(testLong%i == 0)
            return false;
      }
 
      return true;
   }
}

[ August 21, 2004: Message edited by: Ryan Smith ]

Wait I take it back - that isn't quite right. Doubles are not going to cut it - must adjust with BigDecimal.

Ok, scratch that one too. That one finds an incorrect prime, due to the uncertainty of approximations that end in "9." Re-thinking...