Generate Chess960 starting position: Difference between revisions

From Rosetta Code
Content added Content deleted
(Added Mathematica)
(Added Julia version)
Line 365: Line 365:
[N, R, B, K, Q, B, N, R]
[N, R, B, K, Q, B, N, R]
[N, Q, N, R, K, B, B, R]</pre>
[N, Q, N, R, K, B, B, R]</pre>

=={{header|Julia}}==
<lang Julia># placeholder knights
rank1 = ['♘', '♘', '♘', '♘', '♘', '♘', '♘', '♘']

# function to check if a space is available
isfree(x::Int) = rank1[x] == '♘'

# place king
king = rand(2:7)
rank1[king] = '♔'

# place rooks
rook1 = rand(filter(isfree, 1:8))
rank1[rook1] = '♖'

if rook1 > king
rank1[rand(filter(x -> isfree(x) && x < king, 1:8))] = '♖'
else
rank1[rand(filter(x -> isfree(x) && x > king, 1:8))] = '♖'
end

# place bishops
bishop1 = rand(filter(isfree, 1:8))
rank1[bishop1] = '♗'
rank1[rand(filter(x -> isfree(x) && iseven(x) != iseven(bishop1), 1:8))] = '♗'

# place queen
rank1[rand(filter(isfree, 1:8))] = '♕'

# print first rank
println(join(rank1))</lang>

{{out}}

<big><big><big><big><pre>♘♗♘♖♗♕♔♖</pre></big></big></big></big>
Of course since the program is stochastic this is just one possible outcome.


=={{header|Mathematica}}==
=={{header|Mathematica}}==

Revision as of 01:48, 17 June 2015

Task
Generate Chess960 starting position
You are encouraged to solve this task according to the task description, using any language you may know.

Chess960 is a variant of chess created by world champion Bobby Fisher. Unlike other variants of the game, Chess960 does not require a different material, but instead relies on a random initial position, with a few constraints:

  • as in the standard chess game, all eight white pawns must be placed on the second rank.
  • White pieces must stand on the first rank as in the standard game, in random column order but with the two following constraints:
    • 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)
  • Black pawns and pieces must be placed respectively on the seventh and eighth ranks, mirroring the white pawns and pieces, just as in the standard game. (That is, their positions are not independently randomized.)

With those constraints there are 960 possible starting positions, thus the name of the variant.

Task

The purpose of this task is to write a program that can randomly generate any one of the 960 Chess960 initial positions. You will show the result as the first rank displayed with Chess symbols in Unicode: ♔♕♖♗♘ or with the letters King Queen Rook Bishop kNight.

AutoHotkey

Works with: AutoHotkey 1.1

<lang AutoHotkey>Loop, 5 Out .= Chess960() "`n" MsgBox, % RTrim(Out, "`n")

Chess960() { P := {} P[K := Rand(2, 7)] := Chr(0x2654) ; King P[Rand(1, K - 1)] := Chr(0x2656) ; Rook 1 P[Rand(K + 1, 8)] := Chr(0x2656) ; Rook 2 Loop, 8 Remaining .= P[A_Index] ? "" : A_Index "`n" Sort, Remaining, Random N P[Bishop1 := SubStr(Remaining, 1, 1)] := Chr(0x2657) ; Bishop 1 Remaining := SubStr(Remaining, 3) Loop, Parse, Remaining, `n if (Mod(Bishop1 - A_LoopField, 2)) Odd .= A_LoopField "`n" else Even .= A_LoopField "`n" X := StrSplit(Odd Even, "`n") P[X.1] := Chr(0x2657) ; Bishop 2 P[X.2] := Chr(0x2655) ; Queen P[X.3] := Chr(0x2658) ; Knight 1 P[X.4] := Chr(0x2658) ; Knight 2 for Key, Val in P Out .= Val return Out }

Rand(Min, Max) { Random, n, Min, Max return n }</lang>

Output:
♕♘♖♗♗♘♔♖
♗♖♔♕♘♖♘♗
♖♗♘♘♗♔♖♕
♗♗♘♖♔♕♘♖
♘♗♖♔♗♘♕♖

C++

<lang cpp>

  1. include <iostream>
  2. include <string>
  3. include <time.h>

using namespace std; class chess960 { public: 

   void generate( int c )
   {

for( int x = 0; x < c; x++ ) cout << startPos() << "\n"; 

   }

private: 

   string startPos()
   {

char p[8]; memset( p, 0, 8 ); int b1, b2; bool q;

// bishops while( 1 ) { b1 = rand() % 8; b2 = rand() % 8; if( !( b1 & 1 ) && b2 & 1 ) break; } p[b1] = 'B'; p[b2] = 'B';

// queen, knight, knight q = false; for( int x = 0; x < 3; x++ ) { do { b1 = rand() % 8; } while( p[b1] ); if( !q ) { p[b1] = 'Q'; q = true; } else p[b1] = 'N'; }

// rook king rook q = false; for( int x = 0; x < 3; x++ ) { int a = 0; for( ; a < 8; a++ ) if( !p[a] ) break;

if( !q ) { p[a] = 'R'; q = true; } else { p[a] = 'K'; q = false; } }

string s; for( int x = 0; x < 8; x++ ) s.append( 1, p[x] );

return s; 

   }

};

int main( int argc, char* argv[] ) { 

   srand( time( NULL ) );
   chess960 c;
   c.generate( 10 );
   cout << "\n\n";
   return system( "pause" );

} </lang>

Output:
BNNBRKRQ
NRBQKBNR
RNQKNBBR
RKRBBQNN
RNBKQNRB
RKQNRNBB
QRBKRNNB
RBNKNRBQ
RBKNBNRQ
NQNRKBBR

D

Translation of: Python

D: Indexing

<lang d>void main() { 

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

   const pieces = "KQRrBbNN";
   alias I = indexOf;
   auto starts = pieces.dup.permutations.filter!(p =>
           I(p, 'B') % 2 != I(p, 'b') % 2 && // Bishop constraint.
           // King constraint.
           ((I(p, 'r') < I(p, 'K') && I(p, 'K') < I(p, 'R')) ||
            (I(p, 'R') < I(p, 'K') && I(p, 'K') < I(p, 'r'))))
       .map!toUpper.array.sort().uniq;
   writeln(starts.walkLength, "\n", starts.front);

}</lang>

Output:
960
BBNNQRKR

D: Regexp

<lang d>void main() { 

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

   immutable pieces = "KQRRBBNN";
   immutable bish = r"B(|..|....|......)B";
   immutable king = r"R.*K.*R";
   auto starts3 = permutations(pieces.dup)
                  .filter!(p => p.match(bish) && p.match(king))
                  .array.sort().uniq;
   writeln(starts3.walkLength, "\n", starts3.front);

}</lang> The output is the same.

D: Correct by construction

<lang d>void main() { 

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

   // Subsequent order unchanged by insertions.
   auto start = "RKR".dup;
   foreach (immutable piece; "QNN")
       start.insertInPlace(uniform(0, start.length), piece);

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

}</lang>

Output:
QBNNBRKR

Go

Translation of: Ruby

<lang go>package main

import ( 

   "fmt"
   "math/rand"

)

type symbols struct{ k, q, r, b, n rune }

var A = symbols{'K', 'Q', 'R', 'B', 'N'} var W = symbols{'♔', '♕', '♖', '♗', '♘'} var B = symbols{'♚', '♛', '♜', '♝', '♞'}

var krn = []string{ 

   "nnrkr", "nrnkr", "nrknr", "nrkrn",
   "rnnkr", "rnknr", "rnkrn",
   "rknnr", "rknrn",
   "rkrnn"}

func (sym symbols) chess960(id int) string { 

   var pos [8]rune
   q, r := id/4, id%4
   pos[r*2+1] = sym.b
   q, r = q/4, q%4
   pos[r*2] = sym.b
   q, r = q/6, q%6
   for i := 0; ; i++ {
       if pos[i] != 0 {
           continue
       }
       if r == 0 {
           pos[i] = sym.q
           break
       }
       r--
   }
   i := 0
   for _, f := range krn[q] {
       for pos[i] != 0 {
           i++
       }
       switch f {
       case 'k':
           pos[i] = sym.k
       case 'r':
           pos[i] = sym.r
       case 'n':
           pos[i] = sym.n
       }
   }
   return string(pos[:])

}

func main() { 

   fmt.Println(" ID  Start position")
   for _, id := range []int{0, 518, 959} {
       fmt.Printf("%3d  %s\n", id, A.chess960(id))
   }
   fmt.Println("\nRandom")
   for i := 0; i < 5; i++ {
       fmt.Println(W.chess960(rand.Intn(960)))
   }

}</lang>

Output:
 ID  Start position
  0  BBQNNRKR
518  RNBQKBNR
959  RKRNNQBB

Random
♗♘♖♗♘♔♕♖
♕♘♖♔♘♖♗♗
♖♘♗♔♖♕♘♗
♘♘♖♕♗♔♖♗
♗♕♘♗♘♖♔♖

Haskell

<lang Haskell>import Data.List import qualified Data.Set as Set

data Piece = K | Q | R | B | N deriving (Eq, Ord, Show)

isChess960 :: [Piece] -> Bool isChess960 rank = 

 (odd . sum $ findIndices (== B) rank) && king > rookA && king < rookB
 where
   Just king      = findIndex (== K) rank
   [rookA, rookB] = findIndices (== R) rank

main :: IO () main = mapM_ (putStrLn . concatMap show) . Set.toList . Set.fromList 

      . filter isChess960 $ permutations [R,N,B,Q,K,B,N,R]</lang>
Output:
QRKRBBNN
QRKRBNNB
QRKRNBBN
QRKRNNBB
QRKBRNBN
...

J

Build a table of the starting positions then pick one at random. There are 40320 distinct permutations of 8 items and 5040 distinct permutations of these chess pieces, so little memory is needed to generate the table. Also, since the table is built at "compile time", execution is fast.

<lang J>row0=: u: 9812+2}.5|i.10 king=: u:9812 rook=: u:9814 bish=: u:9815 pos=: I.@e. bishok=: 1=2+/ .| pos&bish rookok=: pos&rook -: (<./,>./)@pos&(rook,king) ok=: bishok*rookok perm=: A.&i.~ ! valid=: (#~ ok"1) ~.row0{"1~perm 8 gen=: valid {~ ? bind 960</lang>

Example use:

<lang J> gen ♘♗♖♔♗♕♖♘ 

  gen

♗♘♘♗♖♔♖♕ 

  gen

♖♗♔♘♘♕♗♖ 

  gen

♖♔♕♗♗♘♖♘</lang>

Java

Works with: Java version 1.5+

Regex inspired by (original) Python Regexp, prints ten examples. <lang java5>import java.util.Arrays; import java.util.Collections; import java.util.List;

public class Chess960{ private static List<Character> pieces = Arrays.asList('R','B','N','Q','K','N','B','R');

public static List<Character> generateFirstRank(){ do{ Collections.shuffle(pieces); }while(!check(pieces.toString().replaceAll("[^\\p{Upper}]", ""))); //List.toString adds some human stuff, remove that

return pieces; }

private static boolean check(String rank){ if(!rank.matches(".*R.*K.*R.*")) return false; //king between rooks if(!rank.matches(".*B(..|....|......|)B.*")) return false; //all possible ways bishops can be placed return true; }

public static void main(String[] args){ for(int i = 0; i < 10; i++){ System.out.println(generateFirstRank()); } } }</lang>

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

Julia

<lang Julia># placeholder knights rank1 = ['♘', '♘', '♘', '♘', '♘', '♘', '♘', '♘']

  1. function to check if a space is available

isfree(x::Int) = rank1[x] == '♘'

  1. place king

king = rand(2:7) rank1[king] = '♔'

  1. place rooks

rook1 = rand(filter(isfree, 1:8)) rank1[rook1] = '♖'

if rook1 > king 

   rank1[rand(filter(x -> isfree(x) && x < king, 1:8))] = '♖'

else 

   rank1[rand(filter(x -> isfree(x) && x > king, 1:8))] = '♖'

end

  1. place bishops

bishop1 = rand(filter(isfree, 1:8)) rank1[bishop1] = '♗' rank1[rand(filter(x -> isfree(x) && iseven(x) != iseven(bishop1), 1:8))] = '♗'

  1. place queen

rank1[rand(filter(isfree, 1:8))] = '♕'

  1. print first rank

println(join(rank1))</lang>

Output:
♘♗♘♖♗♕♔♖

Of course since the program is stochastic this is just one possible outcome.

Mathematica

Generates all possible initial conditions, filters for validity, and chooses a random element. <lang Mathematica>Print[StringJoin[ 

  RandomChoice[
   Select[Union[
     Permutations[{"\[WhiteKing]", "\[WhiteQueen]", "\[WhiteRook]", 
       "\[WhiteRook]", "\[WhiteBishop]", "\[WhiteBishop]", 
       "\[WhiteKnight]", "\[WhiteKnight]"}]], 
    MatchQ[#, {___, "\[WhiteRook]", ___, "\[WhiteKing]", ___, 
        "\[WhiteRook]", ___}] && 
      OddQ[Subtract @@ Flatten[Position[#, "\[WhiteBishop]"]]] &]]]];</lang>

Perl

Directly generates a configuration by inserting pieces at random appropriate places. Each config has an equal chance of being produced. <lang perl>sub rnd($) { int(rand(shift)) }

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

sub chess960 { my @s = (undef) x 8; @s[2*rnd(4), 1 + 2*rnd(4)] = qw/B B/;

for (qw/Q N N/) { my @idx = empties \@s; $s[$idx[rnd(@idx)]] = $_; }

@s[empties \@s] = qw/R K R/; @s } print "@{[chess960]}\n" for 0 .. 10;</lang>

Output:
R N B K R N Q B
N N R K B R Q B
N N Q R K R B B
Q R N K B N R B
R K R B N Q B N
B R K B Q N R N
B R N B Q K N R
R B Q N N K B R
N R N Q K R B B
R Q N K R B B N
R K N Q B B R N

Perl 6

First, using a list with three rooks and no king, we keep generating a random piece order until the two bishops are on opposite colors. Then we sneakily promote the second of the three rooks to a king. <lang perl6>repeat until m/ '♗' [..]* '♗' / { $_ = < ♖ ♖ ♖ ♕ ♗ ♗ ♘ ♘ >.pick(*).join } s:2nd['♖'] = '♔'; say .comb;</lang>

Output:
♕ ♗ ♖ ♘ ♔ ♖ ♗ ♘

Here's a more "functional" solution that avoids side effects <lang perl6>sub chess960 { 

   .subst(:nth(2), /'♜'/, '♚') given
   first rx/ '♝' [..]* '♝' /,
   < ♛ ♜ ♜ ♜ ♝ ♝ ♞ ♞ >.pick(*).join xx *;

}

say chess960;</lang>

Output:
♛♝♜♚♝♞♞♜

We can also pregenerate the list of 960 positions, though the method we use below is a bit wasteful, since it generates 40320 candidates only to throw most of them away. This is essentially the same filtering algorithm but written in the form of a list comprehension rather than nested map and grep. (The list comprehension is actually faster currently.) Note that the constant is calculated at compile time, because, well, it's a constant. Just a big fancy one.

<lang perl6>constant chess960 = eager 

   .subst(:nth(2), /'♜'/, '♚') 
       if / '♝' [..]* '♝' /
           for < ♛ ♜ ♜ ♜ ♝ ♝ ♞ ♞ >.permutations».join.uniq;

.say for chess960;</lang> Here's a much faster way (about 30x) to generate all 960 variants by construction. No need to filter for uniqueness, since it produces exactly 960 entries. <lang perl6>sub insert(@a,$p,$e) { @a[^$p], $e, @a[$p..*] }

constant chess960 = eager gather for 0..3 -> $q { 

   my @q = insert <♜ ♚ ♜>, $q, '♛';
   for 0 .. @q -> $n1 {
       my @n1 = insert @q, $n1, '♞';
       for $n1 ^.. @n1 -> $n2 {
           my @n2 = insert @n1, $n2, '♞';
           for 0 .. @n2 -> $b1 {
               my @b1 = insert @n2, $b1, '♝';
               for $b1+1, $b1+3 ...^ * > @b1 -> $b2 {
                   my @b2 = insert @b1, $b2, '♝';
                   take @b2.join;
               }
           }
       }
   }

}

CHECK { note "done compiling" } note +chess960; say chess960.pick;</lang>

Output:
done compiling
960
♜♚♝♜♞♛♞♝

If you run this you'll see that most of the time is spent in compilation, so in the case of separate precompilation the table of 960 entries merely needs to be deserialized back into memory. Picking from those entries guarantees uniform distribution over all possible boards.

Objeck

Translation of: C++

<lang objeck>class Chess960 { 

 function : Main(args : String[]) ~ Nil {
   Generate(10);
 }
 
 function : Generate(c : Int) ~ Nil {
   for(x := 0; x < c; x += 1;) {
     StartPos()->PrintLine();
   };
 }
 
 function : StartPos() ~ String {
   p := Char->New[8];
   
   # bishops
   b1 : Int; b2 : Int;
   while(true) {
     b1 := GetPosition(); b2 := GetPosition(); 
     
     b1c := b1 and 1; b2c := b2 and 1;
     c := b1c = 0 & b2c <> 0;
     if(c) {
       break;
     };
   };
   p[b1] := 0x2657; p[b2] := 0x2657;

   # queen, knight, knight
   q := false;
   for(x := 0; x < 3; x += 1;) {
     do { 
       b1 := GetPosition(); 
     } while( p[b1] <> '\0');
     
     if(<>q) { 
       p[b1] := 0x2655; q := true; 
     }
     else { 
       p[b1] := 0x2658;
     };
   };

   # rook king rook
   q := false;
   for(x := 0; x < 3; x += 1;) {
     a := 0;
     while(a < 8) {
       if(p[a] = '\0') {
         break;
       };
       a += 1;
     };

     if(<>q) { 
       p[a] := 0x2656; q := true; 
     }
     else { 
       p[a] := 0x2654; q := false; 
     };
   };

   s := "";
   for(x := 0; x < 8; x += 1;) { s->Append(p[x]); };
   return s;
 }

 function : GetPosition() ~ Int {
   return (Float->Random() * 1000)->As(Int) % 8;
 }

}</lang>

Output: 

♗♖♕♔♖♗♘♘
♕♗♖♔♗♘♖♘
♖♘♔♘♕♖♗♗
♖♗♔♘♖♘♗♕
♖♔♖♘♕♗♗♘
♗♘♖♕♔♘♖♗
♗♖♔♕♖♘♘♗
♗♖♔♘♘♖♕♗
♖♕♔♖♘♘♗♗
♗♖♘♔♘♖♕♗

PicoLisp

<lang PicoLisp>(load "@lib/simul.l")

(seed (in "/dev/urandom" (rd 8)))

(loop 

  (match
     '(@A B @B B @C)
     (shuffle '(Q B B N N 0 0 0)) )
  (NIL (bit? 1 (length @B))) )

(let Rkr '(R K R) 

  (for I (append @A '(B) @B '(B) @C)
     (prin (if (=0 I) (pop 'Rkr) I)) )
  (prinl) )

(bye)</lang>

Python

Python: Indexing

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.

<lang python>>>> from itertools import permutations >>> pieces = 'KQRrBbNN' >>> starts = {.join(p).upper() for p in permutations(pieces) 

                    if p.index('B') % 2 != p.index('b') % 2 		# Bishop constraint
                    and ( p.index('r') < p.index('K') < p.index('R')	# King constraint	
                          or p.index('R') < p.index('K') < p.index('r') ) }

>>> len(starts) 960 >>> starts.pop() 'QNBRNKRB' >>> </lang>

Python: Regexp

This uses regexps to filter permutations of the start position pieces rather than indexing. <lang python>>>> import re >>> pieces = 'KQRRBBNN' >>> bish = re.compile(r'B(|..|....|......)B').search >>> king = re.compile(r'R.*K.*R').search >>> starts3 = {p for p in (.join(q) for q in permutations(pieces)) 

           if bish(p) and king(p)}

>>> len(starts3) 960 >>> starts3.pop() 'QRNKBNRB' >>> </lang>

Python: Correct by construction

Follows Perl algorithm of constructing one start position randomly, according to the rules. (See talk page for tests). <lang python>from random import choice

def random960(): 

   start = ['R', 'K', 'R']         # Subsequent order unchanged by insertions.
   #
   for piece in ['Q', 'N', 'N']:
       start.insert(choice(range(len(start)+1)), piece)
   #
   bishpos = choice(range(len(start)+1))
   start.insert(bishpos, 'B')
   start.insert(choice(range(bishpos + 1, len(start) + 1, 2)), 'B')
   return start
   return .join(start).upper()

print(random960())</lang>

Output:
['N', 'R', 'K', 'N', 'B', 'Q', 'R', 'B']

Python: Generate all positions then choose one randomly

<lang python>from random import choice

def generate960(): 

   start = ('R', 'K', 'R')         # Subsequent order unchanged by insertions.

   # Insert QNN in all combinations of places
   starts = {start}
   for piece in ['Q', 'N', 'N']:
       starts2 = set()
       for s in starts:
           for pos in range(len(s)+1):
               s2 = list(s)
               s2.insert(pos, piece)
               starts2.add(tuple(s2))
       starts = starts2
   
   # For each of the previous starting positions insert the bishops in their 16 positions
   starts2 = set()
   for s in starts:
       for bishpos in range(len(s)+1):
           s2 = list(s)
           s2.insert(bishpos, 'B')
           for bishpos2 in range(bishpos+1, len(s)+2, 2):
               s3 = s2[::]
               s3.insert(bishpos2, 'B')
               starts2.add(tuple(s3))
               
   return  list(starts2)

gen = generate960() print(.join(choice(gen)))</lang>

Output:
NRBQNKRB

Racket

Constructive:

<lang racket>#lang racket (define white (match-lambda ['P #\♙] ['R #\♖] ['B #\♗] ['N #\♘] ['Q #\♕] ['K #\♔])) (define black (match-lambda ['P #\♟] ['R #\♜] ['B #\♝] ['N #\♞] ['Q #\♛] ['K #\♚]))

(define (piece->unicode piece colour) 

 (match colour ('w white) ('b black)) piece)

(define (find/set!-random-slot vec val k (f values)) 

 (define r (f (random k)))
 (cond
   [(vector-ref vec r)
    (find/set!-random-slot vec val k f)]
   [else
    (vector-set! vec r val)
    r]))

(define (chess960-start-position) 

 (define v (make-vector 8 #f))  
 ;; Kings and Rooks
 (let ((k (find/set!-random-slot v (white 'K) 6 add1)))
   (find/set!-random-slot v (white 'R) k)
   (find/set!-random-slot v (white 'R) (- 7 k) (curry + k 1)))
 ;; Bishops -- so far only three squares allocated, so there is at least one of each colour left
 (find/set!-random-slot v (white 'B) 4 (curry * 2))
 (find/set!-random-slot v (white 'B) 4 (compose add1 (curry * 2)))
 ;; Everyone else
 (find/set!-random-slot v (white 'Q) 8)
 (find/set!-random-slot v (white 'N) 8)
 (find/set!-random-slot v (white 'N) 8)
 (list->string (vector->list v)))

(chess960-start-position)</lang>

Output:
"♖♘♗♕♔♗♘♖"

Well that's embarassing... the stupid thing has only gone and randomly generated a classic chess starting position.

Try again: 

"♘♖♔♕♗♗♖♘"


REXX

Random starting position is correct by construction   (both REXX entries).

generates one random position

<lang rexx>/*REXX pgm generates a random starting position for the Chess960 game.*/ parse arg seed . /*allow for (RAND) repeatability.*/ if seed\== then call random ,,seed /*if SEED specified, use the seed*/ @.=. /*define the (empty) first rank. */ r1=random(1,8) /*generate the first rook, rank 1*/ @.r1='R' /*place the first rook on rank1.*/ 

         do  until  r2\==r1  &  r2\==r1-1  &  r2\==r1+1
         r2=random(1,8)               /*find placement for the 2nd rook*/
         end   /*forever*/

@.r2='r' /*place the second rook on rank 1*/ _=random(min(r1, r2)+1, max(r1, r2)-1) /*find a random possition of king*/ @._='K' /*place king between the 2 rooks.*/ 

         do _=0      ; b1=random(1,8);  if @.b1\==. then iterate; c=b1//2
           do forever; b2=random(1,8) /* c=color of bishop ►──────┘    */
           if @.b2\==. | b2==b1 | b2//2==c  then iterate /*bad position*/
           leave _                    /*found position for the 2 clergy*/
           end   /*forever*/          /* [↑]  find a place: 1st bishop.*/
         end     /* _ */              /* [↑]    "  "   "    2nd    "   */

@.b1='B' /*place the 1st bishop on rank1*/ @.b2='b' /* " " 2nd " " " */ 

                                      /*place the two knights on rank 1*/
  do  until @._='N'; _=random(1,8); if @._\==. then iterate; @._='N'; end
  do  until @.!='n'; !=random(1,8); if @.!\==. then iterate; @.!='n'; end

_= /*only the queen is left to place*/ 

  do i=1  for 8;  _=_ || @.i;   end   /*construct output:  first rank. */

say translate(translate(_, 'q', .)) /*stick a fork in it, we're done.*/</lang> output 

NRQKBRNB

generates all 960 positions randomly

<lang rexx>/*REXX pgm generates all random starting positions for the Chess960 game*/ parse arg seed . /*allow for (RAND) repeatability.*/ if seed\== then call random ,,seed /*if SEED specified, use the seed*/ x.=0; #=0

do t=1 /*═══════════════════════════════════════════════════════════════*/ if t//1000==0 then say right(t,9) 'random generations: ' # " unique starting positions." @.=. /*define the (empty) first rank. */ r1=random(1,8) /*generate the first rook, rank 1*/ @.r1='R' /*place the first rook on rank1.*/ 

         do  until  r2\==r1  &  r2\==r1-1  &  r2\==r1+1
         r2=random(1,8)               /*find placement for the 2nd rook*/
         end   /*forever*/

@.r2='r' /*place the second rook on rank 1*/ _=random(min(r1, r2)+1, max(r1, r2)-1) /*find a random possition of king*/ @._='K' /*place king between the 2 rooks.*/ 

         do _=0      ; b1=random(1,8);  if @.b1\==. then iterate; c=b1//2
           do forever; b2=random(1,8) /* c=color of bishop ►──────┘    */
           if @.b2\==. | b2==b1 | b2//2==c  then iterate /*bad position*/
           leave _                    /*found position for the 2 clergy*/
           end   /*forever*/          /* [↑]  find a place: 1st bishop.*/
         end     /* _ */              /* [↑]    "  "   "    2nd    "   */

@.b1='B' /*place the 1st bishop on rank1*/ @.b2='b' /* " " 2nd " " " */ 

                                      /*place the two knights on rank 1*/
  do  until @._='N'; _=random(1,8); if @._\==. then iterate; @._='N'; end
  do  until @.!='n'; !=random(1,8); if @.!\==. then iterate; @.!='n'; end

_= /*only the queen is left to place*/ 

  do i=1  for 8;  _=_ || @.i;   end   /*construct output:  first rank. */

upper _ /*uppercase all the chess pieces.*/ if x._ then iterate /*was this position found before?*/ x._=1 /*define this position as found. */

  1. =#+1 /*bump the unique positions found*/

if #==960 then leave end /*t ══════════════════════════════════════════════════════════════*/

say # 'unique starting positions found after ' t "generations." 

                                      /*stick a fork in it, we're done.*/</lang>

output 

     1000 random generations:  515  unique starting positions.
     2000 random generations:  707  unique starting positions.
     3000 random generations:  796  unique starting positions.
     4000 random generations:  849  unique starting positions.
     5000 random generations:  883  unique starting positions.
     6000 random generations:  900  unique starting positions.
     7000 random generations:  922  unique starting positions.
     8000 random generations:  935  unique starting positions.
     9000 random generations:  942  unique starting positions.
    10000 random generations:  946  unique starting positions.
    11000 random generations:  953  unique starting positions.
    12000 random generations:  957  unique starting positions.
    13000 random generations:  959  unique starting positions.
    14000 random generations:  959  unique starting positions.
960 unique starting positions found after  14639 generations.

Ruby

Ruby: shuffle pieces until all regexes match

Translation of Tcl. <lang ruby>pieces = %i(♔ ♕ ♘ ♘ ♗ ♗ ♖ ♖) regexes = [/♗(..)*♗/, /♖.*♔.*♖/] row = pieces.shuffle.join until regexes.all?{|re| re.match(row)} puts row</lang>

Output:
♕♖♗♘♔♖♘♗

Ruby: Construct

Uses the Perl idea of starting with [R,K,R] and inserting the rest: <lang ruby>row = [:♖, :♔, :♖] [:♕, :♘, :♘].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, :♗)}

puts row</lang>

Output:
♗♘♕♘♖♗♔♖

Ruby: Generate from SP-ID

Chess960 numbering scheme <lang ruby>KRN = %w(NNRKR NRNKR NRKNR NRKRN RNNKR RNKNR RNKRN RKNNR RKNRN RKRNN)

def chess960(id=rand(960)) 

 pos = Array.new(8)
 q, r = id.divmod(4)
 pos[r * 2 + 1] = "B"
 q, r = q.divmod(4)
 pos[r * 2] = "B"
 q, r = q.divmod(6)
 pos[pos.each_index.reject{|i| pos[i]}[r]] = "Q"
 krn = KRN[q].each_char
 pos.each_index {|i| pos[i] ||= krn.next}
 pos.join

end

puts "Generate Start Position from id number" [0,518,959].each do |id| 

 puts "%3d : %s" % [id, chess960(id)]

end

puts "\nGenerate random Start Position" 5.times {puts chess960}</lang>

Output:
Generate Start Position from id number
  0 : BBQNNRKR
518 : RNBQKBNR
959 : RKRNNQBB

Generate random Start Position
RNBNKBRQ
RKRNBBNQ
BBRNQKNR
NBRKNRBQ
BRKQNNRB

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is func 

 local
   var string: start is "RKR";
   var char: piece is ' ';
   var integer: pos is 0;
 begin
   for piece range "QNN" do
     pos := rand(1, succ(length(start)));
     start := start[.. pred(pos)] & str(piece) & start[pos ..];
   end for;
   pos := rand(1, succ(length(start)));
   start := start[.. pred(pos)] & "B" & start[pos ..];
   pos := succ(pos) + 2 * rand(0, (length(start) - pos) div 2);
   start := start[.. pred(pos)] & "B" & start[pos ..];
   writeln(start);
 end func;</lang>
Output:
NQBNRBKR

Tcl

Using regular expressions to filter a random permutation.

Library: Tcllib (Package: struct::list)

<lang tcl>package require struct::list

proc chess960 {} { 

   while true {

set pos [join [struct::list shuffle {N N B B R R Q K}] ""] if {[regexp {R.*K.*R} $pos] && [regexp {B(..)*B} $pos]} { return $pos } 

   }

}

  1. A simple renderer

proc chessRender {position} { 

   string map {P ♙ N ♘ B ♗ R ♖ Q ♕ K ♔} $position

}

  1. Output multiple times just to show scope of positions

foreach - {1 2 3 4 5} {puts [chessRender [chess960]]}</lang>

Output:
♕♖♘♔♗♗♘♖
♖♔♘♘♗♕♖♗
♘♖♗♗♕♔♘♖
♘♕♗♖♔♖♘♗
♘♘♖♔♗♗♕♖

zkl

Translation of: D

<lang zkl>const pieces="KQRrBbNN"; starts:=pieces:Utils.Helpers.permuteW(_).filter(fcn(p){ 

  I:=p.index;
  I("B") % 2 != I("b") % 2 and // Bishop constraint.
  // King constraint.
  ((I("r") < I("K") and I("K") < I("R")) or
   (I("R") < I("K") and I("K") < I("r")))

}).pump(List,"concat","toUpper"):Utils.Helpers.listUnique(_);</lang> <lang zkl>N:=starts.len(); println(N); glyphs:=D("K","\u2654", "Q","\u2655", "R","\u2656", "B","\u2657", "N","\u2658"); // pick some random starts and transform BBNRKQRN to glyphs do(10){ starts[(0).random(N)].apply(glyphs.find).println() }</lang>

Output:
960
♗♕♘♖♘♔♖♗
♖♘♗♔♖♗♘♕
♖♗♘♔♗♕♖♘
♘♖♘♗♗♔♕♖
♘♘♗♖♕♔♖♗
♘♖♕♔♗♖♘♗
♘♖♗♘♕♔♖♗
♖♘♗♔♕♘♖♗
♖♔♖♕♘♘♗♗
♕♗♖♘♗♔♘♖
Retrieved from "https://rosettacode.org/wiki/Generate_Chess960_starting_position?oldid=246458"