Chess960 position generator

Question

Context

Chess960 (or Fischer Random Chess) is a variant of chess invented and advocated by former World Chess Champion Bobby Fischer, publicly announced on June 19, 1996 in Buenos Aires, Argentina. It employs the same board and pieces as standard chess; however, the starting position of the pieces on the players' home ranks is randomized

Rules

• White pawns are placed on the second rank as in standard chess
• All remaining white pieces are placed randomly on the first rank
• The bishops must be placed on opposite-color squares
• The king must be placed on a square between the rooks.
• Black's pieces are placed equal-and-opposite to White's pieces.

From: http://en.wikipedia.org/wiki/Chess960

For all the people that would like to post answers...

you have to make a Chess960 positions generator, capable of randomly generate one of the 960 positions following the rules described above (it has to be capable of outputting any of the 960, hardcoding one position is not accepted!), and you only need to output the white rank one pieces.

Example output:

rkrbnnbq

where:

• k king
• q queen
• b bishop
• n knight
• r rook

This will be code golf, and the tie breaker will be the upvotes.

Answer 1

Ruby 1.9, 67 65 characters

Ah, the old "keep randomizing until you generate something valid" technique...

$_=%w(r r n n b b q k).shuffle*''until/r.*k.*r/&&/b(..)*b/
$><<$_

(In Ruby 2.0, %w(r r n n b b q k) could be 'rrnnbbqk'.chars)

Answer 2

GolfScript 60 49

;'qbbnnxxx'{{9rand*}$.'b'/1=,2%}do'x'/'rkr'1/]zip

(shortened to 49 chars thanks to Peter Taylor's great tips)

Online test here.

An explanation of the code:

;'qbbnnxxx'         # push the string 'qbbnnxxx' on the clean stack
{

    {9rand*}$       # shuffle the string

    .'b'/1=,2%      # count the number of places between the 'b's
                    # (including the 'b's themselves)
                    # if this count is even, the bishops are on
                    # squares of different colors, so place a 0
                    # on the stack to make the do loop stop

}do                 # repeat the procedure above until a 
                    # good string is encountered

'x'/                # split the string where the 'x's are

'rkr'1/]zip         # and put 'r', 'k' and then 'r' again
                    # where the 'x's used to be

Answer 3

GolfScript (49 48 chars, or 47 for upper-case output)

'bbnnrrkq'{{;9rand}$.'b'/1=,1$'r'/1='k'?)!|1&}do

This uses the standard technique of permuting randomly until we meet the criteria. Unlike w0lf's GolfScript solution, this does both checks on the string, so it is likely to run through the loop more times.

Using upper case allows saving one char:

'BBNNRRKQ'{{;9rand}$.'B'/1=,1$'R'/1=75?)!|1&}do

Answer 4

J, 56 characters

{.(#~'(?=.*b(..)*b).*r.*k.*r.*'&rxeq"1)'kqbbnnrr'A.~?~!8

it takes several seconds on my machine due to the inefficient algorithm. Some speed may be gained by adding ~.(remove duplicates) before 'kqbbnnrr'.

explanation:

• ?~!8 deals 8! random elements from 0 ... 8!
• 'kqbbnnrr'A.~ uses them as anagram indexes to the string kqbbnnrr.
• (#~'...'&rxeq"1)' filters them by the regex in quotes.
• {. means "take the first element"

Answer 5

K,69

(-8?)/[{~*(*/~~':{m=_m:x%2}@&x="b")&(&x="k")within&"r"=x};"rrbbnnkq"]

Answer 6

Python, 105 chars

Basically chron's technique, minus the elegant Ruby stuff.

import re,random
a='rrbbnnkq'
while re.search('b.(..)*b|r[^k]*r',a):a=''.join(random.sample(a,8))
print a

Thanks to Peter Taylor for the shortening of the regex.

Answer 7

Retina, 36 30 bytes

6 bytes saved thanks to Neil

qbnbnrrr
/b.(..)*b/+V?`
1`r
k

Try it online!

Explanation

qbnbnrrr

Start with the list of pieces except we have three rooks and no king

/b.(..)*b/+V?`

Keep shuffling the list as long as it matches the regex b.(..)*b (odd number of pieces between bishops)

1`r
k

Replace the second rook with a king

Answer 8

Perl, 69 chars

$_=rrbbnnkq;/r[^k]*r|b.(..)*b/||say while s/(.{@{[time%8]}})(.)/$2$1/

To test it, add $|=1; at the beginning to see progress and keep tabs by pipeing into another perl process like this:

perl -E'$|=1;$_=rrbbnnkq;/r[^k]*r|b.(..)*b/||say while s/(.{@{[time%7]}})(.)/$2$1/' \
| perl -nlE'$a{$_}++ or say"$_ ".keys%a'

This will e v e n t u a l l y get the 960 valid permutations.

To run the test fast, swap out time%8 with int rand 8 like this:

perl -E'$_=rrbbnnkq;/r[^k]*r|b.(..)*b/||say while s/(.{@{[int rand 8]}})(.)/$2$1/' \
| perl -nlE'$a{$_}++||say"$_ ".keys%a'