the ant walk (year $12$) An ant stands in the middle of a circle ($3$ metres in diameter) and walks in a straight line at a random angle from 0 to 360 degrees. 
Problem is, it can only walk one metre before it needs a break, the ant has the memory of a fish and forgets what direction it has just walked in.After the break, it gets all dizzy and thus chooses another random direction from $0$ to $360$ in an attempt to escape the circle again.
As you can well imagine, it could escape the circle after just 2 walks (just one break needed). Or... it could take $20,000$ walks ($19,999$ breaks needed)!! There might even be the very slim possibility it might take ${20,000}^{20,000}$ walks.
What is the average amount of walks required for the ant to escape the circle?
 A: This answer is incomplete.
Due to symmetry the direction the ant can choose can be any value between $0$ (directly towards the centre) and $\pi$ (directly outwards).
If the ant is at a distance $r_i$ from the centre then it can escape if it choose a angle greater than $\theta_{crit}$, where
$$\theta_{crit}=\cases{\pi-\arccos\left(\frac{4r_i^2-5}{8r_i}\right); & \text{}r_i>\frac12 \cr \pi; &\text{} r_i\leq\frac12}$$
If it doesn't escape then it's new distance from the centre is given by:
$$r_{i+1}=\sqrt{r_i^2+1-2r_i\cos\theta_i}$$
where $\theta_i$ is the angle randomly chosen at step $i$, between $0$ and $\theta_{crit}$.
A: For complicated problem in probability, the Monte Carlo method can be applied to get a numerical approximation relatively quickly. 
The basis of this method is really simple. We all know the expected value of a dice is 3.5, and if we actually throw a dice infinite number of times, the average value should indeed by 3.5. 
But we don't have infinite amount of time, so let's throw it a million time? We will find the result to be very, very close to 3.5, the central limit theorem will guarantee that.
So let simulate an ant for a million time and see what we get.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Ant
{
    class Program
    {
        static void Main(string[] args)
        {
            Random random = new Random();
            double sum = 0;
            double sumSquared = 0;
            int count = 1000000;
            int max = 0;
            int min = int.MaxValue;
            for (int i = 0; i < count; i++)
            {
                int step = Experiment(random);
                max = Math.Max(max, step);
                min = Math.Min(min, step);
                sum += step;
                sumSquared += step * step;
            }
            double mean = sum / count;
            double variance = sumSquared / count - mean * mean;
            double stdev = Math.Sqrt(variance);
            Console.WriteLine(min);
            Console.WriteLine(max);
            Console.WriteLine(mean);
            Console.WriteLine(stdev);
        }

        private static int Experiment(Random random)
        {
            int step = 0;
            double antx = 0;
            double anty = 0;
            while ((antx * antx) + (anty * anty) < 1.5 * 1.5)
            {
                double direction = random.NextDouble() * Math.PI * 2 - Math.PI;
                antx = antx + Math.Cos(direction);
                anty = anty + Math.Sin(direction);
                step++;
            }

            return step;
        }
    }
}

On average, the ant just take 3.52 steps to get out of the circle, and the standard derivation of that is 2.12 steps. In a million time, the min and max are 2 and 29 respectively. That ant is pretty bad luck to take so many steps, once in a million time!
I would really love to see if anyone can get an analytic solution out of this.
