#!/bin/sh
echo 'Start of queens, part 01 of 01:'
echo 'x - queens.cc'
sed 's/^X//' > queens.cc << '/'
Xclass Queen {
X	int row;
X	int column;
X	Queen *neighbor;
X	int canAttack(int r, int c);
X	int testOrAdvance();
Xpublic:
X	Queen(int c, Queen * ngh);
X	int first();
X	int next();
X	void print();
X};
X
X	// construct a new queen, setting neighbor and column number 
XQueen::Queen(int c, Queen * ngh)
X{	column = c; neighbor = ngh; }
X
X	// check to see if queen or neighbor can attach position 
XQueen::canAttack(int r, int c)
X{	int cd;
X	if (row == r) return 1;
X	cd = c - column;
X	if ((row + cd == r) || (row - cd == r)) return 1;
X	if (neighbor) return neighbor->canAttack(r, c);
X	return 0;
X}
X
X	// compute first legal position for queen and neighbor
Xint Queen::first()
X{	 row = 1;
X	if (neighbor && neighbor->first()) 
X		return testOrAdvance();
X	return 1;
X}
X
X	// test or advance a position
Xint Queen::testOrAdvance()
X{	if (neighbor && neighbor->canAttack(row, column))
X		return next();
X	return 1;
X}
X
X	// compute another legal position for queen and neighbor
Xint Queen::next()
X{	if (row == 8) {
X		if (!(neighbor && neighbor->next())) return 0;
X		row = 0;
X		}
X	row = row + 1;
X	return testOrAdvance();
X}
X
X	// print solution
Xvoid Queen::print()
X{	if (neighbor) neighbor->print();
X	printf("column %d row %d\n", column, row);
X}
X
Xmain() 	// main program
X{	Queen *lastQueen;
X	int i;
X
X	lastQueen = (Queen *) 0;
X	for (i = 1; i <= 8; i++)
X		lastQueen = new Queen(i, lastQueen);
X	if (lastQueen->first()) lastQueen->print();
X}
/
echo 'x - queens.m'
sed 's/^X//' > queens.m << '/'
X# import <objc/Object.h>
X
X@implementation NullQueen : Object
X{
X}
X- (int) first {return 1;}
X- (int) next {return 0;}
X- (int) checkrow: (int) r column: (int) c { return 0; }
X- (int) print {};
X@end
X
X@implementation Queen : Object
X{
X	int row;
X	int column;
X	id neighbor;
X}
X
X	/* initialize the column and neighbor values */
X- (void) initialColumn: (int) c neighbor: ngh
X{	column = c; neighbor = ngh; }
X
X	/* check to see if queen or neighbors can attack a given position */
X- (int) checkrow: (int) r column: (int) c
X{	int cd;
X	if (row == r) return 1;
X	cd = c - column;
X	if ((row + cd == r) || (row - cd == r)) return 1;
X	return [ neighbor checkrow: r column: c];
X}
X
X	/* test a given position, advancing if not acceptable */
X- (int) testOrAdvance 
X{	if ([neighbor checkrow: row column: column])
X		return [ self next ];
X	return 1;
X}
X
X	/* compute first legal position for queen and neighbors */
X- (int) first 
X{	row = 1;
X	if ([ neighbor first ])
X		return [ self testOrAdvance ];
X	return 0;
X}
X
X	/* compute next legal position for queen and neighbors */
X- (int) next
X{	if (row == 8) {
X		if (! [ neighbor next ]) return 0;
X		row = 0;
X		}
X	row = row + 1;
X	return [ self testOrAdvance ];
X}
X
X	/* print out solution */
X- (int) print
X{	[ neighbor print ];
X	printf("row %d column %d\n", row, column);
X}
X@end
X
X	/* main program */
Xmain() {
Xid lastQueen, nghbor;
Xint i;
X
Xnghbor = [ NullQueen new ];
Xfor (i = 1; i <= 8; i++) {
X	lastQueen = [ Queen new ];
X	[lastQueen initialColumn: i neighbor: nghbor];
X	nghbor = lastQueen;
X	}
Xif ([lastQueen first]) [lastQueen print];
X}
/
echo 'x - queens.p'
sed 's/^X//' > queens.p << '/'
Xprogram queens;
X	type
X		Queen = object
X			row : integer;
X			column : integer;
X			neighbor : Queen;
X			procedure initial (col : integer; ngh : Queen);
X			function canAttack (r, c : integer) : boolean;
X			function first : boolean;
X			function testOrAdvance : boolean;
X			function next: : boolean;
X			procedure print;
X		end;
X	var
X		neighbor, lastqueen : Queen;
X		i : integer;
X
X		(* initialize the newly created queen object *)
X	procedure Queen.initial(col : integer; ngh : Queen);
X	begin
X		column := col;
X		neighbor := ngh;
X	end;
X
X		(* can queen or neighbors attach position? *)
X	function Queen.canAttack(r, c : integer) : boolean;
X	var
X		cd : integer;
X	begin
X		if row = r then
X			canAttack := true
X		else 
X			begin
X				cd := c - column;
X				if (row + cd = r) or (row - cd = r) then
X					canAttack := true
X				else if neighbor = nil then
X					canAttack := false
X				else
X					canAttack := neighbor.canAttack(r, c)
X			end
X	end;
X
X		(* generate first acceptable solution *)
X	function Queen.first : boolean;
X	begin
X		row := 1;
X		if neighbor = nil then
X			first := true
X		else if not neighbor.first then
X			first := false
X		else
X			first := self.testOrAdvance
X	end;
X
X		(* test and possibly advance solution *)
X	function Queen.testOrAdvance : boolean;
X	begin
X		if neighbor = nil then
X			testOrAdvance := true
X		else if neighbor.canAttack(row, column) then
X			testOrAdvance := self.next
X		else
X			testOrAdvance := true
X	end;
X
X		(* generate next acceptable solution *)
X	function Queen.next : boolean;
X	begin
X		if row = 8 then
X			if neighbor = nil then
X				next := false
X			else if not neighbor.next then
X				next := false
X			else 
X				begin
X					row := 1;
X					next := self.testOrAdvance;
X				end
X		else
X			begin
X				row := row + 1;
X				next := self.testOrAdvance;
X			end
X	end;
X
X		(* print out solution *)
X	procedure Queen.print;
X	begin
X		if neighbor <> nil then
X			neighbor.print;
X		writeln(' row ', row, ' column ', column);
X	end;
X
Xbegin		(* main program *)
X	neighbor := nil;
X	for i := 1 to 8 do
X		begin
X			new(lastQueen);
X			lastQueen.initial(i, neighbor);
X			neighbor := lastQueen;
X		end;
X	if lastQueen.first then
X		lastQueen.print;
Xend.
/
echo 'Part 01 of queens complete.'
exit