Thursday Code Puzzler: Investment Predictor

 Groovy code that prints 70 as answer

double INTEREST_PER_DAY = 1
println Math.round(Math.log(2) / Math.log(1 + INTEREST_PER_DAY/100))

I did it like so, in Java with a recursive static method:

public static void investmentPrediction(double balance, double percentage, int target, int weeks){
		if(balance<target){
			weeks++;
			balance = balance+(balance*(percentage/100));
			investmentPrediction(balance, percentage, target, weeks);
		}
		else{
			System.out.println("It will take "+weeks+" weeks to reach 2000");
		}
		
	}

In Oracle / PL-SQL

DECLARE
  vInt   NUMBER    := .01;  
  vMonto NUMBER    := 1000;
  vResul NUMBER    := vMonto;
  vDias  NUMBER(3) := 1;
BEGIN
  LOOP
    vResul := vResul + (vResul * vInt);
  EXIT WHEN vResul > (vMonto * 2);      
    vDias  := vDias + 1;
  END LOOP;
  DBMS_OUTPUT.PUT_LINE(vDias || ' Días');
END;

using System;

namespace LearnCS
{
    internal class Compute
    {
        private const double RateOfInterest = 1.0, TimesAmount = 2.0;

        private static void Run(string message, Func<long> task)
        {
            var start = DateTime.Now;
            for (int i=1; i< 10000; ++i)
                task(); //delay
            var returnValue = task();
            var timeTaken = (DateTime.Now.Ticks - start.Ticks); // 1 nano second = 100 ticks
            Console.WriteLine("{0} returned {1} and took {2} ticks", message, returnValue, timeTaken);
        }

        private long LogCompute()
        {
            return (long) Math.Ceiling(Math.Log(TimesAmount, 1 + RateOfInterest/100));
        }

        private long ItrativeCompute()
        {
            long days = 0;
            for (var start = 1.0; start < TimesAmount; days++)
                start += start*RateOfInterest/100;
            return days;
        }

        public void Main1()
        {
            //Warm-up
            LogCompute();
            ItrativeCompute();
            Run("Start of Test", () => 0 );
            //Actual run
            Run("Log", LogCompute);
            Run("Iterative", ItrativeCompute);
        }
    }
}
/*
 * The ouput of the code was
        Start of Test returned 0 and took 19531 ticks
        Log returned 70 and took 9765 ticks
        Iterative returned 70 and took 78125 ticks
 *  So apparently, log is faster in C# than in Java because C# uses processor to compute the log function, 
 *  while Java apparently does not use this optimization. This also seems logical because Java is popular 
 *  on server, where the need to use log function is minimal. C# is very popular for desktop applications, 
 *  where log function is probably needed.
*/

http://www.google.com/#hl=en&q=(ln+2)%2F(ln+1.01)

Scala

import scala.math._

val p = 1000
val target = 2000
val r = 0.01

println ceil(log(target/p)/log(1.0 + r))

 runtime 20140 nanoseconds


// objective C / objective c++

double principal = 1000;
double target = 2 * principal;
CGFloat rate = 0.01;

NSLog(@"Amount doubles in %.0f", ceil(log(target/ principal)/log(1.0 + rate))); 

I just devide 70 by percentage and get in how many time it would double. Say, with 1%, 70/1=70 would double in 70 days.