golden hour

/lib64/python2.7/Demo/scripts

File/Folder	Size	Actions
README	1009 B
beer.py	459 B
beer.pyc	703 B
beer.pyo	703 B
eqfix.py	6.16 KB
eqfix.pyc	4.52 KB
eqfix.pyo	4.52 KB
fact.py	1.11 KB
fact.pyc	1.14 KB
fact.pyo	1.14 KB
find-uname.py	1.18 KB
find-uname.pyc	1.47 KB
find-uname.pyo	1.47 KB
from.py	874 B
from.pyc	749 B
from.pyo	749 B
lpwatch.py	2.77 KB
lpwatch.pyc	2.54 KB
lpwatch.pyo	2.54 KB
makedir.py	510 B
makedir.pyc	732 B
makedir.pyo	732 B
markov.py	3.51 KB
markov.pyc	3.93 KB
markov.pyo	3.93 KB
mboxconvert.py	3.11 KB
mboxconvert.pyc	3.17 KB
mboxconvert.pyo	3.17 KB
morse.py	4.21 KB
morse.pyc	4.33 KB
morse.pyo	4.33 KB
newslist.doc	2.36 KB
newslist.py	11.17 KB
newslist.pyc	7.55 KB
newslist.pyo	7.55 KB
pi.py	888 B
pi.pyc	921 B
pi.pyo	921 B
pp.py	3.73 KB
pp.pyc	2.28 KB
pp.pyo	2.28 KB
primes.py	603 B
primes.pyc	921 B
primes.pyo	921 B
queens.py	2.19 KB
queens.pyc	2.95 KB
queens.pyo	2.95 KB
script.py	962 B
script.pyc	1.21 KB
script.pyo	1.21 KB
unbirthday.py	3.07 KB
unbirthday.pyc	2.93 KB
unbirthday.pyo	2.93 KB
update.py	2.69 KB
update.pyc	2.69 KB
update.pyo	2.69 KB

Edit: queens.py

#! /usr/bin/env python

"""N queens problem.

The (well-known) problem is due to Niklaus Wirth.

This solution is inspired by Dijkstra (Structured Programming).  It is
a classic recursive backtracking approach.

"""

N = 8                                   # Default; command line overrides

class Queens:

def __init__(self, n=N):
        self.n = n
        self.reset()

def reset(self):
        n = self.n
        self.y = [None] * n             # Where is the queen in column x
        self.row = [0] * n              # Is row[y] safe?
        self.up = [0] * (2*n-1)         # Is upward diagonal[x-y] safe?
        self.down = [0] * (2*n-1)       # Is downward diagonal[x+y] safe?
        self.nfound = 0                 # Instrumentation

def solve(self, x=0):               # Recursive solver
        for y in range(self.n):
            if self.safe(x, y):
                self.place(x, y)
                if x+1 == self.n:
                    self.display()
                else:
                    self.solve(x+1)
                self.remove(x, y)

def safe(self, x, y):
        return not self.row[y] and not self.up[x-y] and not self.down[x+y]

def place(self, x, y):
        self.y[x] = y
        self.row[y] = 1
        self.up[x-y] = 1
        self.down[x+y] = 1

def remove(self, x, y):
        self.y[x] = None
        self.row[y] = 0
        self.up[x-y] = 0
        self.down[x+y] = 0

silent = 0                          # If true, count solutions only

def display(self):
        self.nfound = self.nfound + 1
        if self.silent:
            return
        print '+-' + '--'*self.n + '+'
        for y in range(self.n-1, -1, -1):
            print '|',
            for x in range(self.n):
                if self.y[x] == y:
                    print "Q",
                else:
                    print ".",
            print '|'
        print '+-' + '--'*self.n + '+'

def main():
    import sys
    silent = 0
    n = N
    if sys.argv[1:2] == ['-n']:
        silent = 1
        del sys.argv[1]
    if sys.argv[1:]:
        n = int(sys.argv[1])
    q = Queens(n)
    q.silent = silent
    q.solve()
    print "Found", q.nfound, "solutions."

if __name__ == "__main__":
    main()