open List;;

let n = 8;;
let rec ps n x y =
if y=n then [] else
if x=n then ps n 0 (y + 1) else
(x, y) :: ps n (x + 1) y;;
let ps = ps n 0 0;;
Printf.printf "%d solutions\n" (search (fun _ -> (+) 1) n [] ps 0);;


This implementation starts with a list of possible board positions and tries a queen on each one, filtering out the safe remaining positions and recursing.

If you want to print the boards, you can use:


let print_board n queens =
let a = Array.make_matrix n n '.' in
iter (fun (x, y) -> a.(y).(x) Array.iter print_char row; print_newline()) a;
print_newline ();;

let () = search (fun qs () -> print_board n qs) n [] ps ();;


This is over 100x faster than your OCaml. It can be made much faster still by using a bitboard and bitmasks.

Cheers,
Jon.

I suppose people would help you. But you have to look in the right places for the answers you want.

Yes I did. Here are the commands executed – I took the arguments to the compiler from the shootout
(q.exe is the compiled ocaml, a.exe is the compiled C++).

$ ocamlopt -noassert -unsafe -ccopt -O3 -ccopt -fomit-frame-pointer q.ml -o q.exe
$ time ./q.exe
n==10
./q.exe 0.00s user 0.00s system 0% cpu 1.000 total

$ time ./a.exe 8 1000 | grep -v Qu
./a.exe 8 1000 0.00s user 0.00s system 0% cpu 4.938 total

> Jens Axel Søgaard Says:
> December 22nd, 2006 at 5:19 pm
>
> Inlining a few of the functions speeds things up a bit.
> With minimal changes this can be done as follows:

[snip]

This gave a speed-up of about 20% – define-inline is a nice macro, thanks.

> Jens Axel Søgaard Says:
> December 22nd, 2006 at 5:32 pm
>
> I know the point of the post is to compare the speed of similar approaches in different languages,
> but you can save a *lot* of time by changing the representation of a board.
>
> At the moment add-queen creates a new array each time a new board configuration is visited.
> The representation in
>
> avoids this copying, and is much faster. Try it!

Yes, much faster, you’re right. This gives a similar speed to the C++.

> # Warren Henning Says:
> December 22nd, 2006 at 6:09 pm
>
> Is using all that pattern matching in the OCaml code really necessary?

I’ve no idea, this is my first piece of OCaml. Do you have any suggestions for improvements?

> shaurz Says:
> December 22nd, 2006 at 6:26 pm
>
> Are you compiling the Scheme version? Have you tried different compilers/interpreters (e.g. Chicken, Scheme 48, etc…)

No, this is running under mzscheme 352 on Windows which I believe includes a JIT.

> # smakk Says:
> December 23rd, 2006 at 3:28 am
>
> Can you try implementing your solution in Common Lisp? It would be interesting to see how it goes.

I have even less experience of writing CL than writing scheme and I suspect my solution would be
equally inefficient :-/

Richards solution is is clever. However, it only counts the number of solutions, but the three bytes ld, cols, and rd doesn’t contain enough information to print out the board when a solution is found (when cols=all).

Here is a Richards solution in Scheme:


(define all #b11111111)

The fastest solution I have seen the the 8-queens problem is written in MCPL by Martin Richards (designer of BCPL and MCPL). It uses clever bit-pattern tricks and only four bytes are needed to represent the board. See: http://citeseer.ist.psu.edu/richards97backtracking.html