# KeiruaProd

I help my clients acquire new users and make more money with their web businesses. I have ten years of experience with SaaS projects. If that’s something you need help with, we should get in touch!
< Back to article list

## Solving the 8 queens problem

The 8 queens problem is a popular problem: can you place n chess queens on a n*n board, so that no two queens threaten each other ?

This problem lends itself very well to backtracking; when you are studying computer science, this is often one of the exercises that help you learn it.

The time complexity for the N-queens is usually N!. It’s ok for small N (you most likely only care about N=8 anyway), when as N grows, the algorithm does not scale well.

Fortunately, the problem also has a closed-form solution that spoils all the fun. The complexity is linear, so it is way faster to generate a solution.

``````import random

def generate_queens(n):
positions = []
if ((n%2 == 0) and (n%6==2)):
for i in range(1, n/2+1):
positions.append([i, 2*i])
positions.append([n/2+i, 2*i-1])
return positions

def draw_board(positions, n):
board = []
empty_line = [' ' for i in range(n) ]
board = [list(empty_line) for i in range(n) ]
for p in positions:
board[p-1][p-1] = '*'
for i in range(n):
print(board[i])

def is_valid(positions):
for p in positions:
for c in [x for x in positions if x != p]:
if p == c or p == c or abs(p-c)==abs(p-c):
return False
print(p)
return True

n = 8;
queens = generate_queens(n)
print(queens)
print("Board:")
draw_board(queens, n)

print(is_valid(queens))
``````

Here is another solution using the same algorithm, this time in Rust:

``````use std::fmt;

#[derive(Debug)]
struct Position {
x:i32,
y:i32
}

fn generate_queens(n:i32) -> Vec<Position>{
let mut positions:Vec<Position> = Vec::new();

if (n % 2 == 0) && (n %6 == 2) {
for i in 1..n/2+1 {
positions.push(Position{
x: i,
y: 2*i
});
positions.push(Position{
x: n/2+i,
y: 2*i-1
});
}
}

positions
}

#[derive(Debug)]
pub struct Board {
queens: Vec<Position>
}

impl Board {
pub fn new(n: i32) -> Board {
Board{
queens:generate_queens(n)
}
}
}

impl fmt::Display for Board {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let size = self.queens.len() as i32;
for i in 0..size {
for j in 0..size {
let mut has_queen = false;
for q in self.queens.iter() {
if q.x-1 ==i && q.y-1 == j {
let _ = write!(f, "♛");
has_queen = true;
break;
}
}
if !has_queen {
let _ = write!(f, ".");
}
}
let _ = write!(f, "\n");
}
write!(f, "")
}
}

fn main() {
let board = Board::new(8);
println!("{:#?}", board);
println!("{}", board);
}
``````