Peaceful chess queen armies: Difference between revisions

{{trans|D}}

EMPTY

BLACK

printBoard(nm[0], blackQueens, whiteQueens)

E

{{out}}

(Commentary by the author: this program suffers similarly of slowness, in eliminating rotational equivalents, as does its Scheme ancestor. Some reasons: it uses backtracking and that is slow; it uses essentially the same inefficient storage format for solutions [one could for instance use integers], and it does not precompute rotational equivalents. However, it does satisfy the task requirements, and might be regarded as a good start. And it can solve the m=5, n=6 case in practical time on a fast machine. m=7, n=7 is a more annoying case.)

#define ATS_DYNLOADFLAG 0

end

{{out}}

=={{header|C}}==

{{trans|C#}}

#include <stdbool.h>

#include <stdio.h>

return EXIT_SUCCESS;

{{out}}

<pre>1 black and 1 white queens on a 2 x 2 board:

=={{header|C sharp|C#}}==

{{trans|D}}

using System.Collections.Generic;

}

}

{{out}}

<pre>1 black and 1 white queens on a 2 x 2 board:

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

{{trans|D}}

#include <vector>

return 0;

{{out}}

<pre>1 black and 1 white queens on a 2 x 2 board:

=={{header|D}}==

{{trans|Go}}

import std.math;

import std.stdio;

}

}

{{out}}

<pre>1 black and 1 white queens on a 2 x 2 board:

Here is the first program, '''peaceful_queens_elements_generator.f90''', which generates code (specialized for given m and n) to deal with the representations of the armies as integers:

use, intrinsic :: iso_fortran_env, only: int64

use, intrinsic :: iso_fortran_env, only: error_unit

end subroutine fill_queen_masks

Here is the second program, '''peaceful_queens.f90''':

use, non_intrinsic :: peaceful_queens_elements

& num_solutions, armies1, armies2)

Here is the driver script:

#

# Driver script for peaceful_queens in Fortran.

${FC} ${FCFLAGS} -c peaceful_queens.f90 &&

${FC} ${FCFLAGS} -o peaceful_queens peaceful_queens_elements.o peaceful_queens.o &&

{{out}}

Textual rather than HTML output. Whilst the unicode symbols for the black and white queens are recognized by the Ubuntu 16.04 terminal, I found it hard to visually distinguish between them so I've used 'B' and 'W' instead.

import "fmt"

}

}

{{out}}

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.Arrays;

import java.util.List;

}

}

{{out}}

<pre>1 black and 1 white queens on a 2 x 2 board:

=={{header|Julia}}==

GUI version, uses the Gtk library. The place! function is condensed from the C# example.

struct Position

peacefulqueenapp()

=={{header|Kotlin}}==

{{trans|D}}

enum class Piece {

}

}

{{out}}

<pre>1 black and 1 white queens on a 2 x 2 board:

=={{header|Mathematica}}/{{header|Wolfram Language}}==

VisualizeState[state_] := Module[{q, cells},

q = MapIndexed[If[#["q"] == -1, {}, Text[Style[#["q"], 24], #2]] &, state, {2}];

]

GetSolution[8, 4, 3](* Solves placing 3 armies of each 4 queens on an 8*8 board*)

{{out}}

<pre>[Graphical object]

Almost a direct translation except for "printBoard" where we have chosen to use a sequence of sequences to simplify the code.

type

printBoard(n, blackQueens, whiteQueens)

else:

{{out}}

=={{header|Perl}}==

===Terse===

use warnings;

(my $have = tr/WB//) < $m * 2 or exit !print "Solution to $m $n\n\n$_";

place( s/-\G/ qw(W B)[$have % 2] /er ) while /-/g; # place next queen

{{out}}

<pre>Solution to 4 5

===Verbose===

A refactored version of the same code, with fancier output.

use warnings;

use feature 'say';

say $solution

? sprintf "Solution to $m $n\n\n%s", map { s/(.)/$1 /gm; s/B /♛/gm; s/W /♕/gmr } $solution

{{out}}

<pre>Solution to 4 5

{{trans|Python}}

You can run this online [http://phix.x10.mx/p2js/QueenArmies.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Queen_Armies.exw

<span style="color: #0000FF;">?</span><span style="color: #008000;">"done"</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

{{out}}

with as_html = false

=={{header|Python}}==

===Python: Textual output===

from functools import lru_cache, reduce

m, n = 5, 7

ans = place(m, n)

{{out}}

===Python: HTML output===

Uses the solver function <code>place</code> from the above textual output case.

from itertools import product, count

html += hboard(ans, n)

with open('peaceful_queen_armies.htm', 'w') as f:

{{out}}

(formerly Perl 6)

{{trans|Perl}}

sub place ($board, $n, $m, $empty-square) {

my $cnt;

say $solution

?? "Solution to $m $n\n\n{S:g/(\N)/$0 / with $solution}"

{{out}}

<pre>W • ◦ • W

=={{header|Ruby}}==

{{trans|Java}}

attr_reader :x, :y

print "No solution exists.\n\n"

end

{{out}}

<pre>1 black and 1 white queens on a 2 x 2 board:

{{libheader|srfi-132}}

;;; Solutions to the Peaceful Chess Queen Armies puzzle, in R7RS

;;; Scheme (using also SRFI-132).

(newline)

(newline)

{{out}}

===All non-equivalent solutions===

{{works with|CHICKEN|5.3.0}}

;;; Solutions to the Peaceful Chess Queen Armies puzzle, in R7RS

;;; Scheme. This implementation returns only one of each equivalent

(newline)

(newline)

{{out}}

{{trans|Kotlin}}

case empty, black, white

}

print("No solution")

}

{{out}}

{{trans|Kotlin}}

{{libheader|Wren-dynamic}}

var Piece = Enum.create("Piece", ["empty", "black", "white"])

System.print("No solution exists.\n")

}

{{out}}

=={{header|zkl}}==

{ r,c:=q; (r==x or c==y or r+c==x+y or r-c==x-y) }

fcn isSafe(r,c,qs) // queen safe at (r,c)?, qs=( (r,c),(r,c)..)

z.text.pump(Void,T(Void.Read,N-1),"println");

}

{{out}}

<pre>