# I used to like Python but...

Isaac Barona ibarona at tid.es
Thu Jun 14 18:43:15 CEST 2001

```On 7 Jun 2001 12:46:39 -0700, alankarmisra at hotmail.com (gods1child)
wrote:

>Now I think I'm just plain in love. I wuz reading this book on OOP
>concepts which used a classic problem of chess (described below) to
>illustrate the power of 'thinking OOP'. It gave a 'pseudocode' for a
>possible solution to the problem. Converting the pseudocode to Python
>was like typing the darn pseudocode! Man i love this language. Here's
>the problem and the code for your amusement and one more reason to
>pray for Python becoming king of the hill:
>
>The problem is to place 8 queens on a chess board such that no queen
>can attack another. The solution given below takes an 'OOP' approach
>where each queen queries its immediate neighbor (the one that came
>before) as to where it can place itself in a specific cell. If the
>neighbor accepts, it in turn politely asks its neighbor if this new
>entrant should be allowed to stand in that cell until someone says
>'this means war!' and the poor new entrant starts looking for a new
>home. This way the queens find the acceptable solution by talking to
>each other instead of Mr Garry Kasparov looking over the chess board
>making decisions on behalf of each queen. BTW, i'm not a science grad
>so i apologize if this is like the oldest problem in the world
>
># 8 queens
># The problem is to place 8 queens on a
># chess board such that no queen can attack
># another
>
>class Queen:
>    def __init__(self, column, queen):
>        self.row = 1
>        self.column = column
>        self.neighbor = queen
>
>    def findSolution(self):
>        while (self.neighbor and \
>               self.neighbor.canAttack(self.row, self.column)):
>                return 0
>        return 1
>
>        if(self.row < 8):
>            self.row += 1
>            return self.findSolution()
>
>            return 0
>
>        self.row = 1
>        return self.findSolution()
>
>    def canAttack(self, testRow, testColumn):
>        if self.row == testRow:
>            return 1
>
>        columnDifference = testColumn - self.column
>        if ((self.row + columnDifference) == testRow) or \
>           ((self.row - columnDifference) == testRow):
>            return 1
>
>        if self.neighbor:
>            return self.neighbor.canAttack(testRow, testColumn)
>
>        return 0
>
>    def getPosition(self, cells):
>        if self.neighbor != None:
>            self.neighbor.getPosition(cells)
>        cells[self.row-1][self.column-1] = 'X'
>
>lastQueen = None
>for i in range(1,9):
>    lastQueen = Queen(i, lastQueen)
>    lastQueen.findSolution()
>
>cells = []
>for i in range(0,8):
>    cells.append(list('O'* 8))
>
>lastQueen.getPosition(cells)
>print '\n\n'
>for i in range(0,8):
>    for j in range(0,8):
>        print cells[i][j],
>    print

```