#Throw a SAT solver at the 8-Queens problem.

#Actually, here we do N queens.

#Variables are x(i,j) where i is the row number 0<=i<N and j is the column number

#Clauses say:

#Every row has a queen. Type 1 clause
#No row has two queens. Type 2
#No column has two queens. Type 3
#No top-left to bottom-right diagonal has two queens. Type 4
#No top-right to bottom-left diagonal has two queens. Type 5

#We have to translate our numbering system into picosat's, so we use
#(i,j)-->iN+j+1

import pycosat

def encode(i,j,N):
    return i*N+j+1

def decode(k,N):
    return divmod(k-1,N)

#return a clause that says there is a queen on a row:


def queen_on_row(row,N):
    return [encode(row,j,N) for j in range(N)]

#return a clause that says there are not two
#queens on two given locations

def no_attack(row1,row2,col1,col2,N):
    return [-encode(row1,col1,N),-encode(row2,col2,N)]

#return a list of the Type 1 clauses'

def type1(N):
    clauses=[]
    for j in range(N):
        clauses.append(queen_on_row(j,N))

    return clauses

def type2(N):
    clauses=[]
    for row in range(N):
        for j in range(N-1):
            for k in range(j+1,N):
                clauses.append(no_attack(row,row,j,k,N))
    return clauses

def type3(N):
    clauses=[]
    for col in range(N):
        for j in range(N-1):
            for k in range(j+1,N):
                clauses.append(no_attack(j,k,col,col,N))
    return clauses

def type4(N):
    clauses=[]
    for row in range(N):
        for column in range(N):
            for offset in range(1,N-1):
                if row+offset<N and column+offset<N:
                    clauses.append(no_attack(row,row+offset,column,column+offset,N))
    return clauses

def type5(N):
    clauses=[]
    for row in range(N):
        for column in range(N):
            for offset in range(1,N-1):
                if row+offset<N and 0<=column-offset<N:
                    clauses.append(no_attack(row,row+offset,column,column-offset,N))
    return clauses

def make_cnf(N):
    return type1(N)+type2(N)+type3(N)+type4(N)+type5(N)

def solve_it(N):
    u=pycosat.solve(make_cnf(N))
    if u=='UNSAT':
        print('No solution.')
    else:
        pretty_print(u,N)

#Well, it's not really that pretty, but it does the job.

def pretty_print(soln,N):
    for item in soln:
        if item>0:
            column=decode(item,N)[1]
            print('-'*column+'O'+'-'*(N-column-1))