Generate Chess960 starting position: Difference between revisions

 

* as in the standard chess game, all eight white pawns must be placed on the second rank.

** the bishops must be placed on opposite color squares (i.e. they must be an odd number of spaces apart or there must be an even number of spaces between them)

** the King must be between two rooks (with any number of other pieces between them all)

 

 

;Task:

 

=={{header|D}}==

 

===D: Indexing===

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

 

alias I = indexOf;

I(p, 'B') % 2 != I(p, 'b') % 2 && // Bishop constraint.

// King constraint.

.map!toUpper.array.sort().uniq;

writeln(starts.walkLength, "\n", starts.front);

{{out}}

<pre>960

 

===D: Regexp===

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

 

immutable bish = r"B(|..|....|......)B";

immutable king = r"R.*K.*R";

.filter!(p => p.match(bish) && p.match(king))

.array.sort().uniq;

writeln(starts3.walkLength, "\n", starts3.front);

The output is the same.

 

===D: Correct by construction===

import std.stdio, std.random, std.array, std.range;

 

start.insertInPlace(iota(bishpos % 2, start.length, 2)[uniform(0,$)], 'B');

start.writeln;

{{out}}

<pre>QBNNBRKR</pre>

 

=={{header|J}}==

 

king=: u:9812

rook=: u:9814

perm=: A.&i.~ !

valid=: (#~ ok"1) ~.row0{"1~perm 8

 

Example use:

 

♘♗♖♔♗♕♖♘

gen''

♖♗♔♘♘♕♗♖

gen''

 

=={{header|Java}}==

{{works with|Java|1.5+}}

Regex inspired by (original) [[#Python: Regexp|Python Regexp]], prints ten examples.

import java.util.Collections;

import java.util.List;

}

}

{{out}}

<pre>[R, N, K, N, R, B, B, Q]

[N, R, B, K, Q, B, N, R]

[N, Q, N, R, K, B, B, R]</pre>

 

=={{header|Perl}}==

Directly generates a configuration by inserting pieces at random appropriate places. Each config has an equal chance of being produced.

 

sub empties { grep !$_[0][$_], 0 .. 7 }

@s

}

{{out}}

N N R K B R Q B

N N Q R K R B B

N R N Q K R B B

R Q N K R B B N

 

{{out}}

 

{{out}}

 

=={{header|Python}}==

This uses indexing rather than regexps. Rooks and bishops are in upper and lower case to start with so they can be individually indexed to apply the constraints. This would lead to some duplication of start positions if not for the use of a set comprehension to uniquify the, (upper-cased), start positions.

 

>>> pieces = 'KQRrBbNN'

>>> starts = {''.join(p).upper() for p in permutations(pieces)

>>> starts.pop()

'QNBRNKRB'

 

===Python: Regexp===

This uses regexps to filter permutations of the start position pieces rather than indexing.

>>> pieces = 'KQRRBBNN'

>>> bish = re.compile(r'B(|..|....|......)B').search

>>> starts3.pop()

'QRNKBNRB'

 

===Python: Correct by construction===

Follows Perl algorithm of constructing one start position randomly, according to the rules.

(See talk page for tests).

 

def random960():

return ''.join(start).upper()

 

{{out}}

<pre>['N', 'R', 'K', 'N', 'B', 'Q', 'R', 'B']</pre>

 

<pre>

</pre>

 

 

 

'''output'''

2000 random generations: 707 unique starting positions.

3000 random generations: 796 unique starting positions.

13000 random generations: 959 unique starting positions.

14000 random generations: 959 unique starting positions.

</pre>

 

===Ruby: shuffle pieces until all regexes match===

Translation of Tcl.

regexes = [/♗(..)*♗/, /♖.*♔.*♖/]

row = pieces.shuffle.join until regexes.all?{|re| re.match(row)}

{{output}}

<big><big><big><big><pre>♕♖♗♘♔♖♘♗</pre></big></big></big></big>

===Ruby: Construct===

Uses the Perl idea of starting with [R,K,R] and inserting the rest:

[:♕, :♘, :♘].each{|piece| row.insert(rand(row.size+1), piece)}

[[0, 2, 4, 6].sample, [1, 3, 5, 7].sample].sort.each{|pos| row.insert(pos, :♗)}

 

{{output}}

<big><big><big><big><pre>♗♘♕♘♖♗♔♖</pre></big></big></big></big>

 

=={{header|Tcl}}==

Using regular expressions to filter a random permutation.

{{tcllib|struct::list}}

 

proc chess960 {} {

 

# Output multiple times just to show scope of positions

{{out}}

♖♔♘♘♗♕♖♗

♘♖♗♗♕♔♘♖

♘♕♗♖♔♖♘♗

</pre>