colsRemoved=[];

%While you are larger than 2x2 and you most recently found a zero column
while (length(colsRemoved) < length(a)-2) && (k~= length(a))
    for k=1:length(a)%for however large the matrix is
        if ( max(a(:,k)) <1 && ( max(a(:,k)~=-1 )) ); %if the column is zero
            a(k,:)=-1; %change the value of the row to -1
            a(:,k)=-1 %change the value of the column to -1
            colsRemoved(end+1)=k;

            break;
        end
    end
end

%Now go through and remove all the -1's.
while find(a==-1)
     for k=1:length(a)
         if max(a(:,k)==-1)
             a(k,:)=[];
             a(:,k)=[];
             break

         end
     end
end
a
disp(['Removed column numbers: ' num2str(colsRemoved)])

remember a sum is simply an or operation on the columns

A(:,sum(A)~=0)

A(:,find(sum(A)~=0))

It is completely vectorized.

http://www.mathworks.com/contest/jumping/winners.html#winner1

Thanks for comments. I see the reason why the second does not work because it missed the cases where there are more rows than columns with all zeros. Here is the modified version.

while ~isequal(any(A) & any(A,2)', any(A'))
    A(~any(A),:)=0;
end
disp(['Removed columns: ',num2str(find(~any(A)))]);
disp(A(any(A),any(A)));

The first code is based on the fact that a diagonl mtrix left-multiply a matrix equivalent to multiply the matrix row by row with the corresponding elements in the diagonal vector. Hence, any(A) get a vector with 1 where the coulmn is not full zero, 0 otherwise. Using this vector to form a diagonl mtrix to left multiply A will set rows of A either all zero (multiply by 0 where corresponding column is all zero) or no change (multiply 1 where corresponding column is not full zero). This is exactly your puzzle required.

In the code, double is used to convert logical variable produced by any(A) to double so that the multiplication can be performed.

Hope this makes the code understandable.

The first algorithm seems to work.

The second fails here:

A = [
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
1 0 0 1 0
0 0 0 0 1]


What I notice with your code is that it works, but after five minutes, I still do not really understand why. It is very clever, more clever than me!

My goal in writing code is to make people understand it as easily as the computer does. More often than not, the person that will need to understand it is me in a few weeks once I have forgotten all about it. Here is my solution:

a = full(round(sprand(5,5,0.8)))
oldEmptyCols = [];
newEmptyCols = all(~a);
%
while ~isequal(oldEmptyCols, newEmptyCols)
a(newEmptyCols,:) = 0;
oldEmptyCols = newEmptyCols;
newEmptyCols = all(~a);
end
% display results
disp ('---------------')
disp(['Remove these columns: ' num2str(find(newEmptyCols))])
find(newEmptyCols)
%
a(newEmptyCols,:) = [];
a(:,newEmptyCols) = []

Notice that with a good variable naming scheme and use of functions that are pronounceable, this code is very readable, even without comments.

For example, I picked:
~isequal(oldEmptyCols, newEmptyCols)
instead of
~(oldEmptyCols == newEmptyCols)

Little things like this make the code easier to understand when you need to deal with it again later.

Doug

while ~isequal(any(A),any(A,2)')

    A(~any(A),:)=0;

end

disp(['Removed columns: ',num2str(find(~any(A)))]);

disp(A(any(A),any(A)));

while ~isequal(a,diag(double(any(a)))*a)
a=diag(double(any(a)))*a;
end
idx=any(a);
disp(['Removed columns: ',num2str(find(~idx))])
disp(a(idx,idx))

Here is another solution based on MATLAB’s powerful indexing capabilities:

function res = puzzler(a)
sub = 1:size(a, 1);
rem = zeros(1, 0);
zer = 0;
while ~isempty(zer)
    zer=find(sum(a(sub, sub), 1)==0);
    rem = [rem sub(zer)];
    sub(zer)=[];
end
disp(sprintf('Removed: %s', mat2str(rem)));
res = a(sub,sub);

(this works “in place” without disturbing the contents of a)