Generate Chess960 starting position: Difference between revisions

{{trans|Python: Correct by construction}}

V start = [‘R’, ‘K’, ‘R’]

R start

{{out}}

=={{header|Action!}}==

DEFINE MAX_LEN="20"

DEFINE MAX_FACTORS="5"

PutE()

PrintResult(max,n,factors,texts)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Generate_Chess960_starting_position_.png Screenshot from Atari 8-bit computer]

{{works with|GNU APL}}

divmod ← {(⌊⍺÷⍵),⍵|⍺}

indices ← {(⍺∊⍵)/⍳⍴⍺}

array ← place array 'R' 1

result ← spid, array

{{Out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

Out .= Chess960() "`n"

MsgBox, % RTrim(Out, "`n")

Random, n, Min, Max

return n

{{Output}}

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

==={{header|BASIC256}}===

{{trans|Yabasic}}

inicio$ = "RKR"

pieza$ = "QNN"

print inicio$

next i

==={{header|Commodore BASIC}}===

{{works with|Commodore BASIC|3.5,7.0}}

Besides the admittedly-trivial use of <tt>DO</tt>/<tt>LOOP</tt>, this implementation also exploits the BASIC 3.5+ ability to use <tt>MID$</tt> as an lvalue.

110 PRINT "SPID (-1 FOR RANDOM):";

120 OPEN 1,0:INPUT#1, SP$:CLOSE 1

510 NEXT I

520 RETURN

Here's a version that doesn't use the advanced features:

{{works with|Commodore BASIC|2.0}}

110 PRINT "SPID (-1 FOR RANDOM):";

120 OPEN 1,0:INPUT#1, SP$:CLOSE 1

480 : N=N-1

510 NEXT I

{{Out}}

==={{header|FreeBASIC}}===

{{trans|Yabasic}}

Randomize Timer

For i As Byte = 1 To 10

Print inicio

Next i

==={{header|QBasic}}===

{{trans|Yabasic}}

FOR i = 1 TO 10

PRINT inicio$

NEXT i

==={{header|Yabasic}}===

{{trans|Seed7}}

piece$ = "QNN"

start$ = left$(start$, pos-1) + "B" + right$(start$, len(start$) - pos + 1)

print start$

=={{header|Befunge}}==

Similar to the [[Generate_Chess960_starting_position#Ruby:_Generate_from_SP-ID|Ruby SP-ID solution]], this generates the start position for a random number in the [[wp:Chess960 numbering scheme|Chess960 numbering scheme]].

v,":".:%*8"x"$<^!:\*2<+<

>48*,:4%2*1#v+#02#\3#g<<

>"RKRNN"11g:!#v_\$\$\$\v

v _v#!`*86:g0:<^!:-1$\$<

{{out}}

<pre>856 : RBKNBRNQ</pre>

=={{header|C}}==

As noted in the C implementation for the [[Sparkline in unicode]] task, unicode output is reliable only on Linux/Unix systems. This implementation thus has compiler directives to check whether the underlying system is Windows or Linux, if Windows, only letters are printed, otherwise Unicode output is displayed. 9 rows are displayed.

#include<locale.h>

#include<wchar.h>

return 0;

}

Output on Linux :

<pre>♗♗♖♕♘♘♔♖

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

#include <string>

#include <time.h>

return system( "pause" );

}

{{out}}

<pre>NQBRNBKR

=={{header|Clojure}}==

(:gen-class)

(:require [clojure.string :as s]))

;; => "♖, ♕, ♘, ♔, ♗, ♗, ♘, ♖"

(c960 4)

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

===Common Lisp: generate from SP-ID===

{{trans|Raku}}

(&optional (sp-id (random 360 (make-random-state t))))

(labels

(format t "~a~%" (chess960-from-sp-id 518))

{{Out}}<pre>(518 #(♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜))

===D: Indexing===

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

.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;

.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|EchoLisp}}==

(define *pos* (list R N B Q K B N R)) ;; standard starter

(if (legal-pos *pos*)

(map unicode-piece *pos*) (c960)))

{{out}}

<pre>(define (unicode-piece i) (unicode->string (+ 0x2654 i)))

{{works with|Elixir|1.1}}

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

@pieces ~w(♔ ♕ ♘ ♘ ♗ ♗ ♖ ♖) # ~w(K Q N N B B R R)

@regexes [~r/♗(..)*♗/, ~r/♖.*♔.*♖/] # [~r/B(..)*B/, ~r/R.*K.*R/]

end

{{out}}

<pre>♘♗♘♖♗♔♕♖

===Elixir: Construct===

def construct do

row = Enum.reduce(~w[♕ ♘ ♘], ~w[♖ ♔ ♖], fn piece,acc ->

end

{{out}}

<pre>♖♔♗♘♖♕♘♗

===Elixir: Generate from SP-ID===

@krn ~w(NNRKR NRNKR NRKNR NRKRN RNNKR RNKNR RNKRN RKNNR RKNRN RKRNN)

end)

IO.puts "\nGenerate random Start Position"

{{out}}

<pre>Generate Start Position from ID number

===Single die method===

Using the single die method: https://en.wikipedia.org/wiki/Chess960_starting_position#Single_die_method

IN: rosetta-code.chess960

: chess960-demo ( -- ) 5 [ chess960 print ] times ;

{{out}}

<pre>

===Built-in===

Factor comes with a chess960 position generator:

{{out}}

<pre>

=={{header|Forth}}==

\ 0 1 2 3 4 5 6 7 8 9

959 chess960 \ RKRNNQBB ok

=={{header|Fortran}}==

This implementation simply iterates through all 960 positions.

implicit none

end program chess960

{{out}}

The first ten positions:

=={{header|Go}}==

{{trans|Ruby}}

import (

fmt.Println(W.chess960(rand.Intn(960)))

}

{{out}}

<pre> ID Start position

=={{header|Haskell}}==

import qualified Data.Set as Set

main :: IO ()

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

{{out}}

<pre>QRKRBBNN

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 and (as the task name points out) only 960 permutations which also satisfy the constraints on bishop and rook position, so little memory is needed to generate the table. Also, since the table is built at "compile time", execution is fast (though "compilation" is reasonably fast also).

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]

=={{header|JavaScript}}==

This conforms to Altendörfer's single die method[https://en.wikipedia.org/wiki/Chess960_starting_position#Single_die_method], though the die will give no "needless" numbers.

var rank = new Array(8),

// randomizer (our die)

// testing (10 times)

{{out}}

<p>The test-output (exemplary each):</p>

=={{header|Julia}}==

{{works with|Julia|0.6}}

# Placeholder knights

rank = ['♘', '♘', '♘', '♘', '♘', '♘', '♘', '♘']

end

{{out}}

<pre>generateposition() = ['♘', '♗', '♗', '♖', '♕', '♔', '♘', '♖']</pre>

=={{header|Kotlin}}==

override fun iterator() = patterns.iterator()

fun main(args: Array<String>) {

Chess960.forEachIndexed { i, s -> println("$i: $s") }

{{Out}}

<pre>0: BBNNQRKR

=={{header|Lua}}==

function randomInsert (t, str, left, right)

local pos

-- Main procedure

math.randomseed(os.time())

{{out}}

<pre>NNRQBBKR</pre>

{{Output?}}

Generates all possible initial conditions, filters for validity, and chooses a random element.

RandomChoice[

Select[Union[

MatchQ[#, {___, "\[WhiteRook]", ___, "\[WhiteKing]", ___,

"\[WhiteRook]", ___}] &&

=={{header|MiniScript}}==

This version uses the Unicode piece characters. If running in [[Mini Micro]] — which supports Unicode but does not have these characters in its font — just replace the the piece characters with letters.

rank = ["♘"] * 8

rank[randFree(0, 7)] = "♕"

{{out}}

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

=={{header|Nim}}==

type

for piece in Pieces:

row[pos[piece]] = $piece

{{out}}

=={{header|Objeck}}==

{{trans|C++}}

function : Main(args : String[]) ~ Nil {

Generate(10);

return (Float->Random() * 1000)->As(Int) % 8;

}

Output:

=={{header|PARI/GP}}==

{

my (C = vector(8), i, j, r);

for (i = 1, 8, if (!C[i], C[i] = Vec("RKR")[j++]));

C

Output:<pre>gp > for(i=1, 10, print(chess960()));

=={{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}}

<pre>R N B K R N Q B

For something faster, and truer to the task description, just use the commented out permute(rand(factorial(8) line,

and quit as soon as you find a valid one (but I wanted to check that I had found exactly 960).

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">solutions</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">solutions</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">solutions</span><span style="color: #0000FF;">))]</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>Found 960 solutions

=={{header|PicoLisp}}==

{{Output?}}

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

(prinl) )

=={{header|PowerShell}}==

{{works with|powershell|2}}

{

$Starts = @()

Get-RandomChess960Start

Get-RandomChess960Start

{{out}}

<pre>♘♕♖♔♖♘♗♗

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>

===Python: Generate all positions then choose one randomly===

def generate960():

gen = generate960()

{{out}}

<pre>NRBQNKRB</pre>

=={{header|R}}==

pieces <- c("R","B","N","Q","K","N","B","R")

cat(convert_to_unicode(generateFirstRank()), "\n")

{{out}}

<pre>

Constructive:

(define white (match-lambda ['P #\♙] ['R #\♖] ['B #\♗] ['N #\♘] ['Q #\♕] ['K #\♔]))

(define black (match-lambda ['P #\♟] ['R #\♜] ['B #\♝] ['N #\♞] ['Q #\♛] ['K #\♚]))

(list->string (vector->list v)))

{{out}}

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

(formerly 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.

s:2nd['♖'] = '♔';

{{out}}

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

Here's a more "functional" solution that avoids side effects

.subst(:nth(2), /'♜'/, '♚') given

first rx/ '♝' [..]* '♝' /,

}

{{out}}

<big><big><big><big><pre>♛♝♜♚♝♞♞♜</pre></big></big></big></big>

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.

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

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.

(my @q = <♜ ♚ ♜>).splice($q, 0, '♛');

for 0 .. @q -> $n1 {

CHECK { note "done compiling" }

note +chess960;

{{out}}

<pre>done compiling

There is a [https://en.wikipedia.org/wiki/Fischer_random_chess_numbering_scheme standard numbering scheme] for Chess960 positions, assigning each an index in the range 0..959. This function will generate the corresponding position from a given index number (or fall back to a random one if no index is specified, making it yet another solution to the general problem).

sub chess960(Pos960 $position = (^960).pick) {

# demo code

say chess960(518); #standard optning position

{{Out}}

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

===generates one random position===

parse arg seed . /*allow for (RANDOM BIF) repeatability.*/

if seed\=='' then call random ,,seed /*if SEED was specified, use the seed.*/

_= /*only the queen is left to be placed. */

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

'''output'''

<pre>NRQKBRNB</pre>

===generates all 960 positions randomly===

parse arg seed . /*allow for (RANDOM BIF) repeatability.*/

if seed\=='' then call random ,,seed /*if SEED was specified, use the seed.*/

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

'''output'''

<pre> 1000 random generations: 515 unique starting positions.

960 unique starting positions found after 14639 generations.</pre>

===version 3 COMPUTE all possibilities===

* Compute the 960 possible solutions

* There must be at least one field between the rooks

If cnt.1=4 Then

Say ' ...'

{{out}}

<pre> 1 45678 1 2 3 RKRQBBNN

===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>

===Ruby: Generate from SP-ID===

'''[[wp:Chess960 numbering scheme|Chess960 numbering scheme]]'''

def chess960(id=rand(960))

puts "\nGenerate random Start Position"

{{out}}

<pre>Generate Start Position from id number

{{Output?}}

{{trans|Kotlin}}

struct Chess960 ( BTreeSet<String> );

println!("{}: {}", i, p);

}

===Rust 1.57 nightly===

// Chess960: regex and unicode version, create 5 valid random positions.

println!("{:?}", create_rnd_candidate());

}

{{out}}

<pre>["♕", "♘", "♗", "♗", "♖", "♘", "♔", "♖"]

=={{header|Scala}}==

===Functional Programming, tail recursive, Unicode, RegEx===

object Chess960 extends App {

if (n <= 0) () else loop(n - 1)

}

{{Out}}See it running in your browser by [https://scalafiddle.io/sf/AkvVAlG/0 ScalaFiddle (JavaScript, non JVM)] or by [https://scastie.scala-lang.org/qpKdhOc4SkuAbze8kgU6zQ Scastie (JVM)].

===Imperative Programming===

{{trans|Kotlin}}

private def apply(b: String, e: String) {

if (e.length <= 1) {

apply("", "KQRRNNBB")

for ((s, i) <- patterns.zipWithIndex) println(s"$i: $s")

=={{header|Scheme}}==

{{libheader|Scheme/SRFIs}}

(srfi 1) ; list library

(srfi 27)) ; random numbers

(display "First rank: ") (display (random-piece-positions)) (newline)

{{out}}

Ten sample runs:

=={{header|Seed7}}==

const proc: main is func

start := start[.. pred(pos)] & "B" & start[pos ..];

writeln(start);

{{out}}

<pre>NQBNRBKR</pre>

=={{header|Sidef}}==

var king = backrank.index('♚')

var (rook1, rook2) = backrank.indices_of('♜')...

}

{{out}}

<pre>

=={{header|Swift}}==

var rooksPlaced = 0

var bishopColor = -1

}

{{out}}

Using regular expressions to filter a random permutation.

{{tcllib|struct::list}}

proc chess960 {} {

# Output multiple times just to show scope of positions

{{out}}

<pre>♕♖♘♔♗♗♘♖

{{libheader|Wren-dynamic}}

{{libheader|Wren-fmt}}

import "/dynamic" for Tuple

import "/fmt" for Fmt

System.print("\nRandom")

var rand = Random.new()

{{out}}

=={{header|XPL0}}==

func ColNum(Start, Piece); \Return column number of Piece

Text(0, Col); CrLf(0);

];

{{out}}

=={{header|zkl}}==

{{trans|D}}

starts:=pieces:Utils.Helpers.permuteW(_).filter(fcn(p){

I:=p.index;

((I("r") < I("K") and I("K") < I("R")) or

(I("R") < I("K") and I("K") < I("r")))

glyphs:=Dictionary("K","\u2654", "Q","\u2655", "R","\u2656", "B","\u2657", "N","\u2658");

// pick some random starts and transform BBNRKQRN to glyphs

{{out}}

<pre>960