File Manager

X7ROOT File Manager

Current Path: /lib64/python2.7/Demo/scripts

lib64 / python2.7 / Demo / scripts /

ðŸ“ ..
ðŸ“„ README(1009 B)
ðŸ“„ beer.py(458 B)
ðŸ“„ beer.pyc(703 B)
ðŸ“„ beer.pyo(703 B)
ðŸ“„ eqfix.py(6.16 KB)
ðŸ“„ eqfix.pyc(4.53 KB)
ðŸ“„ eqfix.pyo(4.53 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(873 B)
ðŸ“„ from.pyc(751 B)
ðŸ“„ from.pyo(751 B)
ðŸ“„ lpwatch.py(2.77 KB)
ðŸ“„ lpwatch.pyc(2.54 KB)
ðŸ“„ lpwatch.pyo(2.54 KB)
ðŸ“„ makedir.py(509 B)
ðŸ“„ makedir.pyc(732 B)
ðŸ“„ makedir.pyo(732 B)
ðŸ“„ markov.py(3.5 KB)
ðŸ“„ markov.pyc(3.93 KB)
ðŸ“„ markov.pyo(3.93 KB)
ðŸ“„ mboxconvert.py(3.11 KB)
ðŸ“„ mboxconvert.pyc(3.18 KB)
ðŸ“„ mboxconvert.pyo(3.18 KB)
ðŸ“„ morse.py(4.21 KB)
ðŸ“„ morse.pyc(4.33 KB)
ðŸ“„ morse.pyo(4.33 KB)
ðŸ“„ pi.py(887 B)
ðŸ“„ pi.pyc(921 B)
ðŸ“„ pi.pyo(921 B)
ðŸ“„ pp.py(3.72 KB)
ðŸ“„ pp.pyc(2.28 KB)
ðŸ“„ pp.pyo(2.28 KB)
ðŸ“„ primes.py(602 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(961 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.68 KB)
ðŸ“„ update.pyc(2.69 KB)
ðŸ“„ update.pyo(2.69 KB)

Editing: queens.py

#! /usr/bin/python2.7

"""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()

X7ROOT File Manager

Editing: queens.py

Upload File

Create Folder