The code assumes that inMatrix is of type logical.

 
[deltaX, deltaY] = puzzler(inMatrix)

halfsize = floor(length(inMatrix)/2);  %a vector of possible distances from the centre
[X,Y] = meshgrid(-halfsize:halfsize,-(-halfsize:halfsize));
therange = max( abs(X), abs(Y) );  %the distance of each point from the centre
orientation = Angle(-Y + i*X); %Is a maximum vertically and decreases clockwise.
closest = find( therange == min(therange(inMatrix)) & inMatrix ); %removes all non-closest elements of inMatrix
[direction,index] = max(orientation(closest)); %finds the element we want to move towards
%Find whether the X,Y coordinates of our target are >0 or <0.
deltaX = sign(X(closest(index)));
deltaY = sign(Y(closest(index)));
 

function [deltaX, deltaY] = puzzler(inMatrix)
% Our arbitrary order - could be anything
order = [24 25 10 11 12;
         23  9  2  3 13;
         22  8  1  4 14;
         21  7  6  5 15;
         20 19 18 17 16];
% Compute multiplication matrix - powers of two means highest bit indicates
% highest in the order
M = 2 .^ (numel(order) - order);
% Multiply with the input - for an image this can be achieved with a
% convolution
M = M(:)' * inMatrix(:);
% Special case
if M == 0
    deltaX = -3;
    deltaY = -3;
    return;
end
% Compute highest set bit
[M M] = log2(M);
% Compute offsets in X and Y
deltaX = [-1 -2 -2 -2 -2 -2 -1 0 1 2 2 2 2 2 1 0 -1 -1 -1 0 1 1 1 0 0];
deltaY = [-2 -2 -1 0 1 2 2 2 2 2 1 0 -1 -2 -2 -2 -1 0 1 1 1 0 -1 -1 0];
deltaY = deltaY(M);
deltaX = deltaX(M);

In fact, I use exactly this trick in my print2im function on the FEX.

Thanks for pointing out errors in my original code. I should test it before posting. Anyway, here is the version with corrections. It has been tested, hence should be correct.

 
function [deltaX, deltaY] = puzzler(inMatrix)
% Using lookup tables to solve the probelm
if isempty(inMatrix(inMatrix>0))
    deltaX=ceil(3*rand)-2;
    deltaY=ceil(3*rand)-2;
    return
end
%spiral positions
spiralMatrix = [
	24 25 10 11 12;
	23  9  2  3 13;
	22  8  1  4 14;
	21  7  6  5 15;
	20 19 18 17 16];
dX=repmat([-1 -1 0 1 1],5,1);
dY=rot90(dX);
idx=spiralMatrix==min(spiralMatrix(inMatrix>0));
deltaX=dX(idx);
deltaY=dY(idx);
 

compare a recursive approach like this, to the classic for-loop approach in spiral.m. I think a recursive approach like this is far and away easier to understand for a problem like this. Memorywise, it’s a tad wasteful, and it’s not as fast. But it’s readable.

function s = myspiral(n)
% returns spiral matrix (recursive method)
% MYSPIRAL(n) is an n-by-n matrix with elements ranging
%   from 1 to n^2 in a rectangular spiral pattern.
% see also spiral.m

if n == 1
    s = 1;
    return
end

if n == 2
    s = [4 1; 3 2];
    return
end

% now, do outer loop, and recursively solve inner parts

mymax = n^2;
mymin = ((n-2)^2)+1;
mynum = mymax:-1:mymin;

s = zeros(n,n);

%left
s(:,1) = mynum(1:n);
mynum(1:n) = []; %chop away used numbers as we go
%bottom
s(end, 2:end) = mynum(1:(n-1));
mynum(1:(n-1)) = [];
%top
s(1,2:(n-1)) = fliplr(mynum(round(length(mynum)/2)+1:end));
mynum(round(length(mynum)/2)+1:end) = [];
%right
s(1:n-1, n) = flipud(mynum(:));

% recurse to middle

s(2:n-1, 2:n-1) = myspiral(n-2);

 
%% All the code so someone can just copy and paste it from
%% the comments.

function [deltax, deltay] = puzzler(matrixin)

% puzzler 9/26/08

values25 = [ 24 25 10 11 12;
            23 9 2 3 13;
            22 8 1 4 14;
            21 7 6 5 15;
            20 19 18 17 16;];

bigdeltax = [-1*ones(5,2) zeros(5,1) ones(5,2)];
bigdeltay = flipud(bigdeltax');

hits = values25(matrixin==1);
idx = find(values25==min(hits));

deltax = bigdeltax(idx);
deltay = bigdeltay(idx);

if sum(matrixin) == 0
    deltax = floor(2.9*rand(1))-1;;
    deltay = floor(2.9*rand(1))-1;
end

 

You caught me! I must have copied your formatting example from above, then pasted my function in the middle. I think I remember seeing two ‘function declarations’ and deleting one. I must have erased mine instead of yours! Oh, well, you get that the function declaration should look like:

function [dx,dy] = puzzler(a)

I would be interested to see if one could come up with a fast way to get idxa for any size input, and if that is faster than some of the other scalable submissions. The other two “lookup vectors” should be easy enough to generate. Interesting…

It is always interesting to see how people solve the problem. Yours is a little different from the rest. It took me a while to understand what IDXA was. Then I figured out it was the absolute indices of the matrix in preferred order. The rest follows from that. This makes the problem a short look-up table type of problem

While it makes the code a little harder to visualize, it does make for very clean code. There are always trade-offs.

Doug

PS. You never actually define your outputs in the function, not do you have the function keyword, but the ideas are there.

Pros:
Scalable
Doesn’t generate big matrix

Cons:
Uses find twice, possibly slow

~Adam

Spiral is not documented as such, because it is not a MATLAB function, it is a MATLAB demo:

>> which spiral
C:\Program Files\MATLAB\R2008a\toolbox\matlab\demos\spiral.m

These are treated differently, even thought this demo happens to be useful as a stand alone function also.

Doug