N-queens problem: Difference between revisions

[[File:chess_queen.jpg|400px||right]]

 

{{trans|Nim}}

 

 

F underAttack(col, queens)

Translated from the Fortran 77 solution.<br>

For maximum compatibility, this program uses only the basic instruction set (S/360).

MACRO

&LAB XDECO &REG,&TARGET

</pre>

 

=={{header|ABAP}}==

TYPES: BEGIN OF gty_matrix,

1 TYPE c,

 

=={{header|Ada}}==

 

procedure Queens is

This one only counts solutions, though it's easy to do something else with each one (instead of the <code>M := M + 1;</code> line).

 

use Ada.Text_IO;

 

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8.8d.fc9.i386]}}

dim = 8; # dim X dim chess board #

[ofs:dim+ofs-1]INT b;

{{works with|Dyalog APL}}

More or less copied from the "DFS" lesson on tryapl.org .

⍝Solution

accm←{⍺,((⍴⍵)=⍴⊃⍺)↑⊂⍵}

 

=={{header|AppleScript}}==

 

property Grid_Size : 8

return newRows

end Reflect</syntaxhighlight>

 

=={{header|Arc}}==

This program prints out all possible solutions:

(if (< len.queens n)

(let row (if queens (+ 1 queens.0.0) 0)

=={{header|Arturo}}==

 

 

queens: function [n, i, a, b, c][

=={{header|AWK}}==

Inspired by Raymond Hettinger's Python solution, but builds the vector incrementally.

#!/usr/bin/gawk -f

# Solve the Eight Queens Puzzle

 

=={{header|ATS}}==

(* ****** ****** *)

//

=== Output to formatted Message box ===

{{trans|C}}

; Post: http://www.autohotkey.com/forum/viewtopic.php?p=353059#353059

; Timestamp: 05/may/2010

The screenshot shows the first solution of 10 possible solutions for N = 5 queens.

 

Number: ; main entrance for different # of queens

SI := 1

[[Image:queens9_bbc.gif|right]]

[[Image:queens10_bbc.gif|right]]

Cell% = 32

VDU 23,22,Size%*Cell%;Size%*Cell%;Cell%,Cell%,16,128+8,5

 

=={{header|BCPL}}==

 

GET "libhdr.h"

It runs about 25 times faster that the version given above.

 

GET "libhdr.h"

GET "mc.h"

This algorithm works with any board size from 4 upwards.

 

"| Q"$$$>:01p:2%!00g0>>^<<!:-1\<1>00p::2%-:40p2/50p2*1+

!77**48*+31p\:1\g,::2\g:,\3\g,,^g>0g++40g%40g\-\40g\`*-

 

=={{header|Bracmat}}==

= board M L x y S R row line

. :?board

 

=={{header|C}}==

#include <stdlib.h>

 

}</syntaxhighlight>

 

#include <stdlib.h>

#include <stdint.h>

}</syntaxhighlight>

Take that and unwrap the recursion, plus some heavy optimizations, and we have a very fast and very unreadable solution:

#include <stdlib.h>

 

A slightly cleaned up version of the code above where some optimizations were redundant. This version is also further optimized, and runs about 15% faster than the one above on modern compilers:

 

#define MAXN 31

 

{{works with|C sharp|C#|7}}

<!-- By Martin Freedman, 13/02/2018 -->

using static System.Linq.Enumerable;

using static System.Console;

===Hettinger Algorithm===

Compare this to the Hettinger solution used in the first Python answer. The logic is similar but the diagonal calculation is different and more expensive computationally (Both suffer from being unable to eliminate permutation prefixes that are invalid e.g. 0 1 ...)

using System.Collections.Generic;

using static System.Linq.Enumerable;

{{works with|C sharp|C#|7.1}}

<!-- By Martin Freedman, 9/02/2018 -->

using static System.Console;

 

 

=={{header|C++}}==

// uses C++11 threads to parallelize the computation; also uses backtracking

// Outputs all solutions for any table size

3 #

4 # </pre>

// A straight-forward brute-force C++ version with formatted output,

// eschewing obfuscation and C-isms, producing ALL solutions, which

=== Alternate version ===

Windows-only

#include <windows.h>

#include <iostream>

 

Version using Heuristics - explained here: [http://en.wikipedia.org/wiki/8_queens_puzzle#Solution_construction Solution_construction]

#include <windows.h>

#include <iostream>

=={{header|Clojure}}==

This produces all solutions by essentially a backtracking algorithm. The heart is the ''extends?'' function, which takes a partial solution for the first ''k<size'' columns and sees if the solution can be extended by adding a queen at row ''n'' of column ''k+1''. The ''extend'' function takes a list of all partial solutions for ''k'' columns and produces a list of all partial solutions for ''k+1'' columns. The final list ''solutions'' is calculated by starting with the list of 0-column solutions (obviously this is the list ''[ [] ]'', and iterates ''extend'' for ''size'' times.

 

(defn extends? [v n]

(println (count solutions) "solutions")</syntaxhighlight>

===Short Version===

(:require [clojure.math.combinatorics :as combo]

 

Each state of the board can be represented as a sequence of the row coordinate for a queen, the column being the index in the sequence (coordinates starting at 0). Each state can have 'children' states if it is legal (no conflict) and has less than n queens. A child state is the result of adding a new queen on the next column, there are as many children states as rows as we are trying all of them. A depth first traversal of this virtual tree of states gives us the solutions when we filter out the illegal states and the incomplete states. The sequence of states is lazy so we could read only one result and not have to compute the other states.

 

(defn n-queens [n]

(let[children #(map (partial conj %) (range n))

=={{header|CLU}}==

{{trans|C}}

rep = null

own hist: array[int] := array[int]$[]

 

=={{header|CoffeeScript}}==

# Unlike traditional N-Queens solutions that use recursion, this

# program attempts to more closely model the "human" algorithm.

 

=={{header|Common Lisp}}==

(if (zerop n)

(list nil)

=== Alternate solution ===

Translation of Fortran 77

(let ((a (make-array n))

(s (make-array n))

As in Fortran, the iterative function above is equivalent to the recursive function below:

 

(let ((a (make-array n))

(u (make-array (+ n n -1) :initial-element t))

=={{header|Curry}}==

Three different ways of attacking the same problem. All copied from [http://web.cecs.pdx.edu/~antoy/flp/patterns/ A Catalog of Design Patterns in FLP]

-- 8-queens implementation with the Constrained Constructor pattern

-- Sergio Antoy

Another approach from the same source.

 

-- N-queens puzzle implemented with "Distinct Choices" pattern

-- Sergio Antoy

Yet another approach, also from the same source.

 

-- 8-queens implementation with both the Constrained Constructor

-- and the Fused Generate and Test patterns.

</syntaxhighlight>

Mainly [http://www-ps.informatik.uni-kiel.de/~pakcs/webpakcs/main.cgi?queens webpakcs], uses constraint-solver.

import Findall

 

===Short Version===

This high-level version uses the second solution of the Permutations task.

import std.stdio, std.algorithm, std.range, permutations2;

 

This version shows all the solutions.

{{trans|C}}

__gshared int[side] board;

 

===Fast Version===

{{trans|C}}

in {

assert(nn > 0 && nn <= 27,

 

=={{header|Dart}}==

Return true if queen placement q[n] does not conflict with

other queens q[0] through q[n-1]

{{libheader| System.SysUtils}}

{{Trans|Go}}

program N_queens_problem;

 

=={{header|Draco}}==

{{trans|C}}

word count;

 

=={{header|EasyLang}}==

 

.

.

subr test

.

n = 8

len x[] n

.

.

{{out}}

<pre>Solution 1

 

=={{header|EchoLisp}}==

;; square num is i + j*N

(define-syntax-rule (sq i j) (+ i (* j N)))

12 ♕ 14200 solutions

</pre>

 

=={{header|Eiffel}}==

class

QUEENS

=={{header|Elixir}}==

{{trans|Ruby}}

def queen(n, display \\ true) do

solve(n, [], [], [], display)

11 Queen : 2680

12 Queen : 14200

</pre>

 

=={{header|Erlang}}==

Instead of spawning a new process to search for each possible solution I backtrack.

-module( n_queens ).

 

 

===Alternative Version===

%%%For 8X8 chessboard with N queens.

-module(queens).

 

=={{header|ERRE}}==

!------------------------------------------------

! QUEENS.R : solve queens problem on a NxN board

 

=={{header|F Sharp}}==

let rec iterate f value = seq {

yield value

The output:

 

| | | |X| | | | | |

| |X| | | | | | | |

10 724

11 2680

 

=={{header|Factor}}==

{{works with|Factor|0.98}}

IN: queens

 

 

=={{header|Forth}}==

variable nodes

 

 

8 queens \ 92 solutions, 1965 nodes</syntaxhighlight>

 

=={{header|Fortran}}==

 

Using a back tracking method to find one solution

implicit none

 

 

===Alternate Fortran 77 solution===

C See the 2nd program for Scheme on the "Permutations" page for the

C main idea.

</syntaxhighlight>

 

!functions. The same algorithm is much easier to follow in Fortran 90, using the RECURSIVE keyword.

!Like previously, the program only counts solutions. It's pretty straightforward to adapt it to print

With some versions of GCC the function OMP_GET_WTIME is not known, which seems to be a bug. Then it's enough to comment out the two calls, and the program won't display timings.

 

use omp_lib

implicit none

 

Part of the intent here is to show that Fortran can do quite a few things people would not think it could, if it is given adequate library support.

 

use, intrinsic :: iso_fortran_env, only: output_unit

=={{header|FreeBASIC}}==

Get slower for N > 14

' compile with: fbc -s console

Dim Shared As ULong count, c()

=== Alternate version : recursive ===

 

u() As Integer, v() As Integer, ByRef m As LongInt)

 

=== Alternate version : iterative ===

 

Dim m As LongInt = 0

 

=={{header|Frink}}==

This example uses Frink's built-in <CODE>array.permute[]</CODE> method to generate possible permutations of the board efficiently.

{

for q = 0 to length[board] - 1

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|GAP}}==

Translation of Fortran 77. See also alternate Python implementation. One function to return the number of solutions, another to return the list of permutations.

 

local a, up, down, m, sub;

a := [1 .. n];

=={{header|Go}}==

===Niklaus Wirth algorithm (Wikipedia)===

// WP page. Well, it happened to be the example program the day I completed

// the task. It seems from the WP history that there has been some churn

 

=== Refactored Niklaus Wirth algorithm (clearer/Go friendly solution) ===

* N-Queens Problem

*

[[N-queens_problem/dlx_go|dlx packge]].

 

 

import (

===Distinct Solutions===

This solver starts with the N! distinct solutions to the N-Rooks problem and then keeps only the candidates in which all Queens are mutually diagonal-safe.

def k = [a.size(), b.size()].min()

def i = (0..<k).find { a[it] != b[it] }

===Unique Solutions===

Unique solutions are equivalence classes of distinct solutions, factoring out all reflections and rotations of a given solution. See the [[WP:Eight_queens_puzzle|Wikipedia page]] for more details.

public static final diag = { list ->

final n = list.size()

===Test and Results===

This script tests both distinct and unique solution lists.

def qds = queensDistinctSolutions(n)

def qus = queensUniqueSolutions(qds)

 

=={{header|Haskell}}==

import Data.List

 

 

===Alternative version===

import Data.List ((\\))

 

===Using permutations===

This version uses permutations to generate unique horizontal and vertical position for each queen. Thus, we only need to check diagonals. However, it is less efficient than the previous version because it does not prune out prefixes that are found to be unsuitable.

 

-- checks if queens are on the same diagonal

A back-tracking variant using the Prelude's plain '''foldr''':

{{Trans|JavaScript}}

 

--------------------- N QUEENS PROBLEM -------------------

 

===Breadth-first search and Depth-first search===

import System.Environment

 

 

=={{header|Heron}}==

inherits {

Heron.Windows.Console;

=={{header|Icon}} and {{header|Unicon}}==

Here's a solution to the <tt>n = 8</tt> case:

write(q(1), " ", q(2), " ", q(3), " ", q(4), " ", q(5), " ", q(6), " ", q(7), " ", q(8))

end

* As the calls to q() are evaluated in main, each one will suspend a possible row, thereby allowing the next q(n) in main to be evaluated. If any of the q() fails to yield a row for the nth queen (or runs out of solutions) the previous, suspended calls to q() are backtracked progressively. If the final q(8) yields a row, the write() will be called with the row positions of each queen. Note that even the final q(8) will be suspended along with the other 7 calls to q(). Unless the write() is driven to produce more solutions (see next point) the suspended procedures will be closed at the "end of statement" ie after the write has "succeeded".

* If you want to derive all possible solutions, main() can be embellished with the '''every''' keyword:

procedure main()

every write(q(1), " ", q(2), " ", q(3), " ", q(4), " ", q(5), " ", q(6), " ", q(7), " ", q(8))

The comment explains how to modify the program to produce <i>all</i>

solutions for a given <tt>N</tt>.

 

procedure main(args)

 

=={{header|IS-BASIC}}==

110 TEXT 80

120 DO

This is one of several J solutions shown and explained on this [[J:Essays/N%20Queens%20Problem|J wiki page]]

 

comb2 =: (, #: I.@,@(</)&i.)~ NB. all size 2 combinations of integers 0 to y

mask =: [ */@:~:&(|@-/) {

Example use:

 

92 8</syntaxhighlight>

 

92 distinct solutions for an 8 by 8 board.

 

0 4 7 5 2 6 1 3</syntaxhighlight>

 

 

=={{header|Java}}==

 

private static int[] b = new int[8];

===ES5===

Algorithm uses recursive Backtracking. Checks for correct position on subfields, whichs saves a lot position checks. Needs 15.720 position checks for a 8x8 field.

if (rows <= 0) {

return [[]];

===ES6===

Translating the ES5 version, and adding a function to display columns of solutions.

"use strict";

 

This section presents a function for finding a single solution using

the formulae for explicit solutions at [[WP:Eight_queens_puzzle|Eight Queens Puzzle]].

def q: "♛";

def init(k): reduce range(0;k) as $i ([]; . + ["."]);

{{out}}

$ jq -M -n -r -f n-queens-single-solution.jq

.....♛..

.......♛

{{ works with|jq|1.4}}

'''Part 1: Generic functions'''

def permutations(n):

# Given a single array, generate a stream by inserting n at different positions:

def count(g): reduce g as $i (0; .+1);</syntaxhighlight>

'''Part 2: n-queens'''

def sums:

. as $board

</syntaxhighlight>

'''Example''':

{{out}}

92

=={{header|Julia}}==

 

# EightQueensPuzzle

 

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

var count = 0

=={{header|Liberty BASIC}}==

Program uses permutation generator (stores all permutations) and solves tasks 4x4 to 9x9. It prints all the solutions.

'N queens

'>10 would not work due to way permutations used

Uses the heuristic from the Wikipedia article to get one solution.

 

20 while n<4:input "How many queens (N>=4)";n:wend

30 dim q(n),e(n),o(n)

 

=={{header|Logo}}==

if :files = 0 [make "solutions :solutions+1 show :tried stop]

localmake "safe (bitand :files :diag1 :diag2)

 

=={{header|Lua}}==

 

-- We'll use nil to indicate no queen is present.

=={{header|M2000 Interpreter}}==

{{trans|VBA}}

Module N_queens {

Const l = 15 'number of queens

It finds one solution of the Eight Queens problem.

 

 

The following macro find one solution to the eight-queens problem:

{{trans|Python}}

 

local a,u,v,m,aux;

a:=[$1..n];

=={{header|Mathematica}}/{{header|Wolfram Language}}==

This code recurses through the possibilities, using the "safe" method to check if the current set is allowed. The recursive method has the advantage that finding all possibilities is about as hard (code-wise, not computation-wise) as finding just one.

With[{l = Length@q},

Length@Union@q == Length@Union[q + Range@l] ==

 

This returns a list of valid permutations by giving the queen's column number for each row. It can be displayed in a list of chess-board tables like this:

Grid[Normal@

SparseArray[MapIndexed[{#, First@#2} -> "Q" &, #], {n, n}, "."],

This solution uses Permutations and subsets, also prints out a board representation.

 

Do[per[[q]]=Partition[Riffle[Reverse[Range[n]],per[[q]]],2],{q,1,Length[per]}];(* Riffled in the reverse of [range n] partitioned into pairs*)

Do[w=Subsets[per[[t]],{2}];(* This is a full subset of the previous set of pairs taken 2 at a time *)

Alternative Solution using Linear Programming:

 

dispSol[sol_] := sol /. {1 -> "Q" , 0 -> "-"} // Grid

 

=={{header|MATLAB}}==

This solution is inspired by Raymond Hettinger's permutations based solution which was made in Python: https://code.activestate.com/recipes/576647/

solutions=[[]];

v = 1:n;

 

=={{header|Maxima}}==

 

queens(n) := block([a, i, j, m, p, q, r, s, u, v, w, y, z],

...]] */

length(%); /* 92 */</syntaxhighlight>

 

=={{header|MiniZinc}}==

array [1..n] of var 1..n: q; % queen in column i is in row q[i]

 

=={{header|Modula-2}}==

{{trans|C}}

FROM InOut IMPORT Write, WriteCard, WriteString, WriteLn;

 

 

=={{header|MUMPS}}==

Set sol=0

For row(1)=1:1:4 Do try(2) ; Not 8, the other 4 are symmetric...

</syntaxhighlight>

<div style="overflow:scroll; height:400px;">

+--+--+--+--+--+--+--+--+ +--+--+--+--+--+--+--+--+ +--+--+--+--+--+--+--+--+

8 | |##| Q|##| |##| |##| | |##| Q|##| |##| |##| | |##| | Q| |##| |##|

 

=={{header|Nim}}==

 

proc underAttack(col: int; queens: seq[int]): bool =

{{trans|Java}}

 

class NQueens {

b : static : Int[];

{{libheader|FaCiLe}}

 

Copyright 2004 CENA. All rights reserved.

This code is distributed under the terms of the GNU LGPL *)

queens (int_of_string Sys.argv.(1));;</syntaxhighlight>

===A stand-alone OCaml solution===

 

let show board =

=={{header|Oz}}==

A pretty naive solution, using constraint programming:

fun {Queens N}

proc {$ Board}

 

=={{header|Pascal}}==

 

const l=16;

Solution found</pre>

{$IFDEF FPC}

{$MODE DELPHI}

 

=={{header|PDP-11 Assembly}}==

; "eight queens problem" benchmark test

 

 

=={{header|Perl}}==

 

sub try_column {

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PHP}}==

<html>

<head>

<h2>Solution with recursion</h2>

 

<html>

<body>

===0/1 encoding a N x N matrix===

Using constraint modelling using an 0/1 encoding of an N x N matrix. It is the probably the fastest approach when using SAT and MIP solvers.

% import mip.

 

===Constraint programming===

This is the "standard" model using constraint programming (in contract to the SAT 0/1 approach). Instead of an NxN matrix, this encoding uses a single list representing the columns. The three <code>all_different/1</code> then ensures that the rows, and the two diagonals are distinct.

 

queens(N, Q) =>

==="Naive" approach===

This approach might be called "naive" (in the constraint programming context) since it doesn't use the (general) faster <code>all_different/1</code> constraint.

Q = new_list(N),

Q :: 1..N,

=={{header|PicoLisp}}==

===Calling 'permute'===

 

(de queens (N)

'permute', but creates them recursively. Also, it directly checks for

duplicates, instead of calling 'uniq' and 'length'. This is much faster.

(let (R (range 1 N) L (copy R) X L Cnt 0)

(recur (X) # Permute

=={{header|PL/I}}==

This code compiles with PL/I compilers ranging from the ancient IBM MVT PL/I F compiler of the 1960s, the IBM PL/I Optimizing compiler, thru the IBM PL/I compiler for MVS and VM, to the z/OS Enterprise PL/I v4.60 compiler;spanning 50 years of PL/I compilers. It only outputs the number of solutions found for a given N instead of printing out each individual chess board solution to avoid filling up spool space for large values of N. It's trivial to add a print-out of the individual solutions.

NQUEENS: PROC OPTIONS (MAIN);

DCL A(35) BIN FIXED(31) EXTERNAL;

=== Recursive version ===

{{trans|Stata}}

#DIM ALL

 

=== Iterative version ===

{{trans|Stata}}

#DIM ALL

 

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

function PlaceQueen ( [ref]$Board, $Row, $N )

{

}

</syntaxhighlight>

Get-NQueensBoard 8

''

=={{header|Processing}}==

{{trans|Java}}

int n = 8;

int[] b = new int[n];

This solution, originally by Raymond Hettinger for demonstrating the power of the itertools module, generates all solutions.

 

 

n = 8

 

Solution #1:

solution([X/Y|Others]) :-

 

Solution #2:

permutation([1,2,3,4,5,6,7,8], Queens),

safe(Queens).

 

Solution #3:

sol(Ylist,[1,2,3,4,5,6,7,8],

[1,2,3,4,5,6,7,8],

===Alternative version===

Uses non-ISO predicates between/3 and select/3 (available in SWI Prolog and GNU Prolog).

 

 

Uses backtracking- a highly efficient mechanism in Prolog to find all solutions.

{{works with|SWI Prolog|version 6.2.6 by Jan Wielemaker, University of Amsterdam}}

% q(Row) represents a queen, allocated one per row. No rows ever clash.

% The columns are chosen iteratively from available columns held in a

===Short version===

SWI-Prolog 7.2.3

maplist(plus, X, N, Z1), maplist(plus, X, Z2, N), is_set(Z1), is_set(Z2).

 

 

===SWISH Prolog version===

% John Devou: 26-Nov-2021

% Short solution to use on https://swish.swi-prolog.org/.

</ul>

<br/>

 

% DOC: http://www.pathwayslms.com/swipltuts/clpfd/clpfd.html

From the Pure (programming language) Wikipedia page

 

n-queens.pure

Tectonics:

=={{header|PureBasic}}==

A recursive approach is taken. A queen is placed in an unused column for each new row. An array keeps track if a queen has already been placed in a given column so that no duplicate columns result. That handles the Rook attacks. Bishop attacks are handled by checking the diagonal alignments of each new placement against the previously placed queens and if an attack is possible the solution backtracks. The solutions are kept track of in a global variable and the routine <tt>queens(n)</tt> is called with the required number of queens specified.

 

Procedure showBoard(Array queenCol(1))

This solution, originally by [http://code.activestate.com/recipes/576647/ Raymond Hettinger] for demonstrating the power of the itertools module, generates all solutions. On a regular 8x8 board only 40,320 possible queen positions are examined.

 

 

n = 8

The output is presented in vector form (each number represents the column position of a queen on consecutive rows).

The vector can be pretty printed by substituting a call to <code>board</code> instead of <code>print</code>, with the same argument, and where board is pre-defined as:

print ("\n".join('.' * i + 'Q' + '.' * (n-i-1) for i in vec) + "\n===\n")</syntaxhighlight>

 

On a regular 8x8 board only 15,720 possible queen positions are examined.

{{works with|Python|2.6, 3.x}}

BOARD_SIZE = 8

 

to a generator expression) produces a backtracking solution. On a regular 8x8 board only 15,720 possible queen positions are examined.

{{works with|Python|2.6, 3.x}}

 

def under_attack(col, queens):

print(list(enumerate(first_answer, start=1)))</syntaxhighlight>

 

if i < n:

for j in range(n):

else:

yield a

 

for solution in queens(8, 0, [], [], []):

print(solution)</syntaxhighlight>

for j in a:

if i + j not in b and i - j not in c:

else:

yield x

 

print(solution)</syntaxhighlight>

 

Queens positions on a n x n board are encoded as permutations of [0, 1, ..., n]. The algorithms consists in building a permutation from left to right, by swapping elements of the initial [0, 1, ..., n], recursively calling itself unless the current position is not possible. The test is done by checking only diagonals, since rows/columns have by definition of a permutation, only one queen.

 

 

 

for k in range(i, n):

j = a[k]

a[i], a[k] = a[k], a[i]

yield from sub(i + 1)

a[i], a[k] = a[k], a[i]

yield from sub(0)

 

92</syntaxhighlight>

 

 

However, it may be interesting to look at the first solution in lexicographic order: for growing n, and apart from a +1 offset, it gets closer and closer to the sequence [http://oeis.org/A065188 A065188] at OEIS. The first n for which the first solutions differ is n=26.

 

for k in range(i, n):

a[i], a[k] = a[k], a[i]

yield from sub(i + 1)

yield from sub(0)

 

next(queens(31))

 

next(queens_lex(31))

 

#Compare to A065188

Expressed in terms of nested folds, allowing for graphic display of results, and listing the number of solutions found for boards of various sizes. On a regular 8x8 board only 15,720 possible queen positions are examined.

{{Works with|Python|3.7}}

 

from functools import reduce

9 -> 352

10 -> 724</pre>

 

=={{header|QBasic}}==

{{works with|QBasic}}

{{trans|QB64}}

CLS

COLOR 15

 

=={{header|QB64}}==

DIM SHARED QUEENS AS INTEGER

PRINT "# of queens:";: INPUT QUEENS

This solution uses recursive backtracking.

 

a <- seq(n)

u <- rep(T, 2 * n - 1)

Show the first solution found for size 8 as a permutation matrix.

 

a <- queens(8)

as(a[, 1], "pMatrix")</syntaxhighlight>

Count solutions for board size 4 to 12.

 

 

{{out}}

Backtracking algorithm; returns one solution

 

#lang racket

 

 

Show result with "How to Design Programs" GUI.

(require htdp/show-queen)

 

Computes all solutions.

 

#lang racket

 

Taking the first solution does not compute the other solutions:

 

(car (nqueens 8))

;; => (list (Q 7 3) (Q 6 1) (Q 5 6) (Q 4 2) (Q 3 5) (Q 2 7) (Q 1 4) (Q 0 0))

Computing all solutions is also possible:

 

(define (force-and-print qs)

(define forced (force qs))

 

Logic borrowed from the Ruby example

#lang racket

(define (remove x lst)

Neither pretty nor efficient, a simple backtracking solution

 

sub collision(@field, $row) {

for ^$row -> $i {

=={{header|Rascal}}==

 

 

public set[list[int]] Nqueens(int n){

 

About half of the REXX code involves presentation (and colorization achieved through dithering) of the chessboard and queens.

parse arg N . /*obtain optional argument from the CL.*/

if N=='' | N=="," then N= 8 /*Not specified: Then use the default.*/

 

=={{header|Ring}}==

 

// Bert Mariani 2020-07-17

 

=={{header|Ring}}==

load "stdlib.ring"

load "guilib.ring"

=={{header|Ruby}}==

This implements the heuristics found on the wikipedia page to return just one solution

# puzzle).

# 2. Write a list of the even numbers from 2 to n in order.

===Alternate solution===

If there is not specification, it outputs all solutions.

attr_reader :count

 

'''Example:'''

puzzle = Queen.new(n)

puts " #{n} Queen : #{puzzle.count}"

 

=={{header|Run BASIC}}==

input "How many queens (N>=4)";n

if n < 4 then

 

=={{header|Rust}}==

 

fn try(mut board: &mut [[bool; N]; N], row: usize, mut count: &mut i64) {

===Using Iterators===

Solution to the puzzle using an iterator that yields the 92 solutions for 8 queens.

use std::iter::IntoIterator;

 

}

 

where I: 'a + IntoIterator<Item=T> + Clone,

T: 'a + PartialEq + Copy + Clone {

 

pub struct NQueens {

}

 

str

}

 

=={{header|SAS}}==

data queens;

array a{8} p1-p8;

Lazily generates permutations with an <code>Iterator</code>.

 

object NQueens {

 

This is a simple breadth-first technique to retrieve all solutions.

 

(import (scheme base)

(scheme write)

=={{header|Scilab}}==

Naive brute-force search.

Board_size = 8;

 

 

=={{header|Seed7}}==

 

var array integer: board is 8 times 0;

=={{header|Sidef}}==

{{trans|Raku}}

 

func collision(field, row) {

 

=={{header|SNOBOL4}}==

* N queens problem

* Set N to the desired number. The program prints out all solution boards.

This is somewhat a transliteration of the "shortened" C++ code above.

 

pos.foreach(function (_, i) {

stdout.printf(" %c", 'a' + i);

This implementation, which solves the problem for n=8, makes use of Common Table Expressions and has been tested with SQLite (>=3.8.3) and Postgres (please note the related comment in the code). It might be compatible with other SQL dialects as well. A gist with the SQL file and a Python script that runs it using SQLite is available on Github: https://gist.github.com/adewes/5e5397b693eb50e67f07

 

WITH RECURSIVE

positions(i) as (

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

-- A column of a matrix.

CREATE TYPE INTEGER_ARRAY AS INTEGER ARRAY[]@

=={{header|Standard ML}}==

This implementation uses failure continuations for backtracking.

(*

* val threat : (int * int) -> (int * int) -> bool

Adapted from the Fortran 77 program, to illustrate the '''[http://www.stata.com/help.cgi?m2_goto goto]''' statement in Stata.

 

real matrix queens(real scalar n) {

real scalar i, j, k, p, q

It's also possible to save the solutions to a Stata dataset:

 

mata: a=queens(8)

getmata (a*)=a

The recursive solution is adapted from one of the Python programs.

 

real matrix queens_rec(real scalar n) {

real rowvector a, u, v

The iterative and the recursive programs are equivalent:

 

1</syntaxhighlight>

 

=={{header|Swift}}==

Port of the optimized C code above

let maxn = 31

 

=={{header|SystemVerilog}}==

Create a random board configuration, with the 8-queens as a constraint

 

parameter SIZE_LOG2 = 3;

=={{header|Tailspin}}==

A functional-ish solution utilising tailspin's data flows

templates queens

def n: $;

 

A solution using state to find one solution if any exist

templates queens

def n: $;

 

{{works with|Tcl|8.5}}

 

proc unsafe {y} {

The total number of solutions for 8 queens is displayed at the end of the run. The code could be adapted to display a selected solution or multiple solutions. This code runs anywhere you can get bash to run.

 

# variable declaration

n is a number greater than 3. Multiple solutions may be reported

but reflections and rotations thereof are omitted.

#import nat

 

=={{header|VBA}}==

{{trans|BBC BASIC}}

Sub n_queens()

Const l = 15 'number of queens

{{trans|BBC BASIC}}

To have the solutions printed (raw format) uncomment the ad hoc statement.

const l=15

dim a(),s(),u(): redim a(l),s(l),u(4*l-2)

{{works with|Visual Basic|VB6 Standard}}

{{trans|BBC BASIC}}

Sub n_queens()

Const l = 15 'number of queens

=={{header|Visual Basic .NET}}==

{{trans|BBC BASIC}}

Module Mod_n_queens

Sub n_queens()

 

=={{header|Wart}}==

prn "step: " queens # show progress

if (len.queens = n)

{{trans|Kotlin}}

Very slow for the larger boards.

var c = []

var f = []

 

Copied from http://www.cs.bu.edu/~hwxi/Xanadu/Examples/

int abs(i: int) {

if (i >= 0) return i; else return -i;

=={{header|XPL0}}==

[[File:NQueensXPL0.GIF|right]]

int R, C; \row and column of board

char B(N,N); \board

(either by XSLT processors saxon-6.5.5, xsltproc, xalan,

or any of the big5 browsers):

15863724

16837425

83162574

84136275

 

You can view the results directly in your browser (Chrome/FF/IE/Opera/Safari) here: [[http://stamm-wilbrandt.de/en/xsl-list/n-queens/8-queens.xsl.xml]]

 

Here is stylesheet 8-queens.xsl.xml which produces the (simple) output by having itself as input: [[http://stamm-wilbrandt.de/en/xsl-list/n-queens/8-queens.xsl.xml]]

<!-- 8-queens.xsl disguised as XML file for the browsers -->

 

 

=={{header|Yabasic}}==

DOCU Place N Queens on an NxN chess board

DOCU such that they don't threaten each other.

=={{header|Zig}}==

Outputs all 92 solutions.

const std = @import("std");

const stdout = std.io.getStdOut().outStream();

=={{header|zkl}}==

Modified from a Haskell version (if I remember correctly)

{ r,c:=q; (r==x or c==y or r+c==x+y or r-c==x-y) }

fcn isSafe(r,c,qs) // queen safe at (r,c)?, qs=( (r,c),(r,c)..) solution so far

return(qs.apply(self.fcn.fp(N,row+1)).flatten());

}</syntaxhighlight>

println(queens.len()," solution(s):");

queens.apply2(Console.println);</syntaxhighlight>