Where are the cows?

[desh]

The best maze ever is apparently online!

"Where Are the Cows?" was first published in Scientific American in 1996 as probably the only self-referential flowchart word maze in existence. I fell in love with it, and I think I even solved it. (Can't remember for sure.)

I went looking for it again about 4 years ago, and found it in a book called SuperMazes, by the maze's author, Robert Abbott. To my surprise, he said that this maze "may be too difficult for anyone to solve", making me really wish I could remember for sure if I solved it the first time around.

Just now I went looking for it online, to see if I could share it, and I found a copy. (Logically the same, as far as I can see, but a bit shabbier presentation-wise.) I present it to all of you.


The rules: Start with a pointer on box #1 and another pointer on box #7. A move consists of choosing one of your two pointers, following the instructions in that box, and then moving that pointer from that box, along the appropriate line, to another box. Generally the "instructions" are a yes/no question, and the "appropriate line" is either the one labeled "yes" or the one labeled "no". (Note that you do not "officially read" the new box you move to at that time; in other words, you don't follow the directions on the moved-to box until you choose that pointer again on a subsequent move.) On most moves, the only choice you make is which pointer to move.




I'm interested in what y'all think of the maze, because I think it's a great judge of what sort of intellectual exercise you enjoy or don't enjoy. Also please tell me if you attempt it, solve it, diagram it, can't even figure out how to move, or whatever. (And I might even give hints.)

Oh, and my second-favorite maze from SuperMazes is online and Javafied! Check out http://home.att.net/~robtabbott/sliding.html.

Comments

Solver.java:

[mrputter.livejournal.com]

import java.awt.Color;
import java.util.Stack;

public class Solver {
	private Stack<Marker> posn = new Stack<Marker>();
	private Stack<Integer> lastM = new Stack<Integer>();
	private Stack<Boolean> isGreen = new Stack<Boolean>();
	private Color[] col = new Color[ 76 ];
	private int[] tmove = new int[ 76 ];
	private int[] fmove = new int[ 76 ];
	private boolean selfReference;
	
	public Solver() {
		lastM.push( Integer.valueOf( 1 ) );
		Marker thispos = new Marker();
		thispos.a = 1;
		thispos.b = 7;
		posn.push( thispos );
		isGreen.push( Boolean.valueOf( false ) );

		selfReference = false;

		col[ 1 ] = col[ 2 ] = col[ 5 ] = col[ 15 ] = col[ 35 ] = col[ 55 ] = col[ 65 ] = col[ 75 ] = Color.black;
		col[ 7 ] = col[ 9 ] = col[ 25 ] = col[ 26 ] = col[ 40 ] = col[ 50 ] = col[ 61 ] = Color.red;
		col[ 60 ] = Color.green;
		tmove[ 1 ] = 2; tmove[ 2 ] = 7; tmove[ 5 ] = 25; tmove[ 7 ] = 26; tmove[ 9 ] = 2;
		tmove[ 15 ] = 5; tmove[ 25 ] = 7; tmove[ 26 ] = 61; tmove[ 35 ] = 40; tmove[ 40 ] = 65;
		tmove[ 55 ] = 15; tmove[ 60 ] = 25; tmove[ 61 ] = 1; tmove[ 65 ] = 75; tmove[ 75 ] = 1;
		fmove[ 1 ] = 9; fmove[ 2 ] = 15; fmove[ 5 ] = 2; fmove[ 7 ] = 5; fmove[ 9 ] = 35;
		fmove[ 15 ] = 40; fmove[ 25 ] = 50; fmove[ 26 ] = 55; fmove[ 35 ] = 1; fmove[ 40 ] = 60;
		fmove[ 50 ] = 26; fmove[ 55 ] = 7; fmove[ 75 ] = 50;
	}
	
	public void setSelfRef( boolean sr ) {
		selfReference = sr;
	}
	
	public boolean backtrack() {
		if (posn.empty()) {
			return false;
		}
		
		posn.pop();
		lastM.pop();
		isGreen.pop();
		return true;
	}
	
	public boolean move( int m, boolean lugnut ) {
		// returns true if the indicated move wins the game
		
		int o = (m == 0 ? 1 : 0);
		
		Marker newpos = posn.peek();
		boolean newgreen = isGreen.peek().booleanValue();
		
		switch (newpos.get( m )) {
			case 60:
				newgreen = true;
				newpos.put( m, tmove[ newpos.get( m ) ] );
				break;
			case 61:
				if (!newgreen) {
					if (newpos.get( o ) == 50) {
						return true;
					}
					newpos.put( o, tmove[ newpos.get( o ) ] );
				}
				newpos.put( m, tmove[ newpos.get( m ) ] );
				break;
			case 65:
				newgreen = false;
				newpos.put( m, tmove[ newpos.get( m ) ] );
				break;
			default:
				if (getRes( m, lugnut )) {
					if (newpos.get( m ) == 50) {
						return true;
					}
					newpos.put( m, tmove[ newpos.get( m ) ] );
				} else {
					newpos.put( m, fmove[ newpos.get( m ) ] );
				}
				break;
		}
		posn.push( newpos );
		isGreen.push( Boolean.valueOf( newgreen ) );
		lastM.push( Integer.valueOf( m ) );

		return false;
	}

	public boolean getRes( int m, boolean lugnut ) {
		Marker thispos = posn.peek();
		int o = thispos.get( (m == 0 ? 1 : 0) );

		if ((col[ thispos.get( m ) ] == Color.red) && isGreen.peek().booleanValue()) {
			return true;
		}
				
		switch (thispos.get( m )) {
			case 1:
				return ((col[ o ] == Color.red) || (col[ o ] == Color.green));
			case 2:
				return ((col[ o ] == Color.green) || (o == 1) || (o == 2) || (o == 5) ||
				    (o == 25) || (o == 40) || (o == 65));
			case 5:
				return ((o == 1) || (o == 2) || (o == 5) || (o == 25) || (o == 40) || (o == 60) || (o == 65));
			case 7:
				return ((o % 2) == 1);
			case 9:
				return (lastM.peek() != m);
			case 15:
				return ((o % 5) == 0);
			case 25:
				return ((col[ o ] == Color.red) || (col[ o ] == Color.green));
			case 26:
				if (o == 26) {
					return selfReference;
				} else {
					return getRes( (m == 0 ? 1 : 0), false );
				}
			case 35:
				return ((o == 2) || (o == 5) || (o == 35));
			case 40:
				return false;
			case 50:
				return (o == 50);
			case 55:
				return (!lugnut);
			case 75:
				return ((o == 26) || (o == 61) || (o == 65));
			default:
				return true;
		}
	}
	
	public Marker getPosn() {
		return posn.peek();
	}
	
	public boolean getGreen() {
		return isGreen.peek().booleanValue();
	}
	
	public int getLastMove() {
		return lastM.peek().intValue();
	}
}