p = [.25 .25 .5 .75 ; .5 0 0 .25 ; .25 .5 0 0 ; 0 .25 .5 0 ];
[P D] = eig(p);
D=(abs(D)>.99).*D;
x = real(P * D * P^(-1) * [1 ; 0 ; 0 ; 0]);

The idea here is to use the eigenvalue decomposition, noting that the eigenvalues with norm less than 1 will vanish. Remove those eigenvalues and reassemble the matrix. Multiply by the starting vector and you have the result. This is accurate to machine precision. The real is to remove the roundoff imaginary components.

best from zurich
urs

ps: maybe i’m not meant to contribute… or it’s just the date…

About the comments. Great idea. I will make it a best practice.

Thanks,
Doug

I am surprised that so many people jumped no the Markov chain method, I expected that the exhaustive search or monte carlo methods would dominate. Maybe that is because I worked with distributed computing clusters for MATLAB for a while but never really studied Markov Chains.

Thanks for playing!
Doug

A beautiful solution. I like how you derived the M matrix rather than it being a “Magic Number Matrix” (which is what I did).

When I was designing this challenge, I was going to have an add-on where the number of coins and number of squares was variable. I thought that simpler was better. I see that your code would have been able to handle such a complication nicely.

Thanks for a great solution that works in a different way than the earlier one.

Doug

Sincerely
Daniel Armyr

startPos = [1; 0; 0; 0];
numberOfMoves = 20;

probabilityMatrix = …
[ 1/4 1/2 1/4 0; …
1/4 0 1/2 1/4; …
1/2 0 0 1/2; …
3/4 1/4 0 0]’;

probabilityAfter20Turns = probabilityMatrix^numberOfMoves*startPos

p20 = (0.25 * [1 2 1 0; 1 0 2 1; 2 0 0 2; 3 1 0 0])^20;
disp(p20(1, :))

cheers,

Richard

Here is a function working for a slightly more general situation:

function probs = game(steps)
N = 4; % number of game states

% Basic transition matrices
% move(k) corresponds to "move k squares"
move = @(k)circshift(eye(N),[0 k]);
% go(k) corresponds to "go to square k"
go = @(k)ones(N,1)*((1:N)==k);

% Build the actual transition matrix
M = 1/2 * move(1) + 1/4 * move(2) + 1/4 * go(1);

% Compute probabilities
if steps < inf
   % Finite number of steps: intermediate distributions are computed
   % using successive matrix-vector products
   state = (1:N)==1;
   for i = 1:steps
       state = state*M;
       probs(i, 1:N) = state;
   end
else
   % Infinite number of steps: stationary distribution is computed
   % (assuming it exists) by solving a linear system
   probs = [zeros(1,N) 1] /[M-eye(N) ones(N,1)];
end

I like this solution. It follows exactly the idea I put in the last wrap-up where you make your code as readable as possible, and then modify it for speed when needed.

Your implementation is very similar to my solution (video one above), but yours is a lot faster. The reason yours is faster is the use of BSXFUN. In this case, a little less clarity is worth the performance increase. I have to admit, I needed to read the doc for this function, as I have never used it!

I would have placed the definition of twoTails immediately before the line where it was used, so it is easier to follow, but this is pretty clear code with some amount of commenting where needed.

While this code is fast and pretty accurate, I am curious if anyone will come up with other methods that are exactly accurate and even faster like my second video.

Thanks!
Doug