Eight queens puzzle

solutions

Here’s a classic puzzle: the eight queens puzzle.

Quoted from Wikipedia:

The eight queens puzzle is the problem of placing eight chess queens on an 8×8 chessboard so that no two queens threaten each other. Thus, a solution requires that no two queens share the same row, column, or diagonal. The eight queens puzzle is an example of the more general n-queens problem of placing n queens on an n×n chessboard, where solutions exist for all natural numbers n with the exception of n=2 and n=3.[1]

I solve puzzles from time to time to keep my motivation up and to get some exercise for my brain. But mostly for fun.

In this puzzle on a standard 8x8 chess board there are 92 solutions where no two queens threaten each other.

What could a solution in Javascript for this puzzle look like?
I’ve moved more and more into functional programming lately so this is my take on it.

// Solve queens puzzle.
// https://en.wikipedia.org/wiki/Eight_queens_puzzle

const doCollide = (arr1, arr2) => {
  const shorter = arr1.length < arr2.length ? arr1 : arr2
  const longer = arr2.length > arr1.length ? arr2 : arr1
  const collisionsRemoved = shorter.filter((val, i) => shorter[i] != longer[i])
  return collisionsRemoved.length != shorter.length
}

const okToAdd = (base, candidate, fn) => {
  const candVector = base.reduce((last, curr, index) => {
    return [].concat(last, [fn(candidate, index)])
  }, [])
  return !doCollide(candVector, base)
}

const upStep = (num, index) => parseInt(num) + index + 1
const downStep = (num, index) => parseInt(num) - index - 1
const levelStep = num => parseInt(num)
const getArr = (num) => Array.apply(null, Array(num))

const addQueen = (bases, candidates) => {
  return bases.map((base) => {
    return candidates.filter((cand) => {
      return [upStep, downStep, levelStep].every((fn) => okToAdd(base, cand, fn))
    }).map(val => [val].concat(base))
  }).reduce((all, curr) => {
    return all.concat(curr)
  }, [])
}

const solve = (numTiles) => {
  return getArr(numTiles).reduce((solutions, depth) => {
    const candidates = getArr(numTiles).map((_, i) => i)
    return addQueen(solutions, candidates)
  }, [[]])
}

// 8 tiles = normal chess board
const solution = solve(8)
console.log('solutions', solution)
console.log('number of solutions: ' + solution.length)

You can try it out in this JSBin: http://jsbin.com/qubeye/6/edit?js,console
Have you any ideas for improvement?

Comment below!