Generate random chess position: Difference between revisions

{{task}}

 

 

 

 

No requirement is made regarding the probability distribution of your method, but your program should be able to span a reasonably representative sample of all possible positions. For instance, programs that would always generate positions with say five pieces on the board, or with kings on a corner, would not be considered truly random.

 

 

=={{header|C}}==

{{trans|Java}}

#include <math.h>

#include <string.h>

createFen();

return 0;

 

{{out}}

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

 

#include <ctime>

#include <iostream>

return 0;

}

{{out}}

<pre>

=={{header|Crystal}}==

{{trans|Ruby}}

(-1..1).each do |g|

(-1..1).each do |f|

 

# Simpler for same output

{{out}}<pre>1n1P3p/1p1k2Pp/1ppPPprn/2rP4/KNRQ2b1/2Bp1PP1/3qPBN1/2Rp4 w - - 0 1

.n.P...p

 

=={{header|Factor}}==

math.parser math.ranges math.vectors prettyprint random

sequences sets splitting.monotonic strings ;

position [ position. ] [ position>fen print ] bi ;

 

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|Yabasic}}

Dim Shared As Byte grid(8, 8), r, c

 

toFen()

Sleep

{{out}}

<pre>

. . . N . B n .

8/6p1/2kP4/5b2/p1p2pK1/1Q2p1r1/1q6/3N1Bn1/ w - - 0 1

</pre>

 

=={{header|Go}}==

{{trans|Java}}

 

import (

rand.Seed(time.Now().UnixNano())

fmt.Println(createFen())

 

{{out}}

1q6/3p3K/7b/1r1b4/3k4/6p1/8/1nn5/ w - - 0 1

</pre>

 

=={{header|J}}==

Implementation:

 

whilst. NB. first two positions are non-adjacent kings

(0{pos) e. (1{pos)+(,-)1 7 8 9

)

 

 

Example use:

 

q6J/1pb1p1p1/1Jq2k2/4p1Pp/1pP5/1K2Bp2/5p2/1P4P1 w - - 0 1

randfen''

randfen''

b1Q1Bb1J/j1N1PpK1/PpB1P1Pp/2pp2PN/3nnk2/3J4/P6P/1N2Qb1J w - - 0 1

 

=={{header|Java}}==

import java.util.Random;

 

return fen.append(" w - - 0 1").toString();

}

<pre>(lol, the black king is in check, it couldn't possibly be white's turn)

. . . . . B . .

. . . . . . B K

5B2/P1P5/2k1R3/p1Pp4/7Q/P7/1N2rNP1/6BK/ w - - 0 1</pre>

 

=={{header|Julia}}==

 

'''Module''':

 

using Printf

printgrid(grid) = println(join((join(grid[r, :], ' ') for r in 1:size(grid, 1)), '\n'))

 

 

'''Main''':

Chess.randposition!(grid)

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.util.Random

fun main(args: Array<String>) {

println(createFen())

 

Sample output:

8/K7/1Pp1b1PP/1pP3P1/1p1q1pPP/3k3b/3np3/2r5/ w - - 0 1

</pre>

 

=={{header|Perl}}==

use warnings;

use feature 'say';

}

 

{{out}}

<pre>p5Nq/1nn5/3N2bp/PRBkQr2/1QB1Pn2/Q5pK/1NRb2rN/p1R2r1N w - - 0 1</pre>

 

=={{header|Phix}}==

To allow pawns that have "moved backwards", replace the inner test with

<code>if not find('P',board[1..8]) and not find('p',board[57..64]) then exit end if</code><br>

 

=={{header|PicoLisp}}==

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

(de pieceN (P)

(gt0 C)

(link C) ) ) ) ) ) ) )

{{out}}

<pre>

 

=={{header|Python}}==

import random

 

#entry point

start()

{{out}}<pre>

1p5k/1B4P1/1KN4R/nR3Nrb/Q1NrnpP1/7R/3PP3/1P5P w - - 0 1

[' ', 'P', ' ', ' ', ' ', ' ', ' ', 'P']

</pre>

 

=={{header|REXX}}==

If the number of chessboards specified is negative, then the number of chess pieces for each side will be random.

 

parse arg seed CBs . /*obtain optional arguments from the CL*/

if datatype(seed,'W') then call random ,,seed /*SEED given for RANDOM repeatability? */

do boards=1 for abs(CBs) /* [↓] maybe display separator & title*/

if sign(CBs)\==CBs then do; say; say center(' board' boards" ", 79, '▒'); end

do p=1 for random(2, 32) /*generate a random number of chessmen.*/

if p<3 then call piece 'k' /*a king of each color. */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

say $ /*display the board rank. */

say /*display a blank sep. line*/

say 'FEN='fen "w - - 0 1" /*Forsyth─Edwards Notation.*/

return /* [↑] display chessboard.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

if CBs<0 & p>2 then if random(1) then upper x /*CBs>0? Use balanced.*/

/*[↓] # isn't changed.*/

if @.r.f\==. then iterate /*is position occupied?*/

/*[↑] skip these pawns*/

if ux=='K' then do rr=r-1 for 3 /*[↓] neighbor ≡ king?*/

end /*rr*/ /*[↑] neighbor ≡ king?*/

end /*ff*/ /*[↑] we're all done. */

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here: &nbsp; ───► &nbsp; [[CHANGESTR.REX]]. <br><br>

'''output''' &nbsp; showing five chess positions (starting with a specific position by seeding the &nbsp; '''random''' &nbsp; BIF with &nbsp; '''96'''),

 

=={{header|Ruby}}==

def hasNK( board, a, b )

for g in -1 .. 1

puts

end

{{out}}<pre>

1bN1RK2/1Pp1pQbP/p2PpP2/8/1pkNP3/P1r1Pp1p/Bn1RPp1r/3qB3 w - - 0 1

 

=={{header|Rust}}==

 

use rand::{Rng, distributions::{Distribution, Standard}};

let b: Board = rand::random();

println!("{}", b.fen());

 

{{out}}

=={{header|Scala}}==

{{Out}}Best seen running in your browser [https://scastie.scala-lang.org/zdG9NQ4YSaShFRU7AS31GA Scastie (remote JVM)].

import scala.util.Random

 

println(createFen)

 

 

=={{header|Yabasic}}==

{{trans|C}}

sub placeKings()

createFen()

 

=={{header|zkl}}==

# First we chose how many pieces to place: 2 to 32

n := (0).random(2,33);

while(re.search(str,1)){ n,m:=re.matched[0]; str=String(str[0,n],m,str[n+m,*]) }

str

{{out}}

<pre>

5b2/1R6/r4b1q/3Q4/8/8/8/5b2 w - - 0 1

8/1BQ5/8/1q6/1q6/3B1Rq1/5b2/3N3R w - - 0 1</pre>