I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Peaceful chess queen armies

Peaceful chess queen armies
You are encouraged to solve this task according to the task description, using any language you may know.

In chess, a queen attacks positions from where it is, in straight lines up-down and left-right as well as on both its diagonals. It attacks only pieces not of its own colour.

 ⇖ ⇑ ⇗ ⇐ ⇐ ♛ ⇒ ⇒ ⇙ ⇓ ⇘ ⇙ ⇓ ⇘ ⇓

The goal of Peaceful chess queen armies is to arrange `m` black queens and `m` white queens on an `n-by-n` square grid, (the board), so that no queen attacks another of a different colour.

1. Create a routine to represent two-colour queens on a 2-D board. (Alternating black/white background colours, Unicode chess pieces and other embellishments are not necessary, but may be used at your discretion).
2. Create a routine to generate at least one solution to placing `m` equal numbers of black and white queens on an `n` square board.
3. Display here results for the `m=4, n=5` case.

References

## 11l

Translation of: D
`T.enum Piece   EMPTY   BLACK   WHITE F isAttacking(queen, pos)   R queen.x == pos.x   | queen.y == pos.y   | abs(queen.x - pos.x) == abs(queen.y - pos.y) F place(m, n, &pBlackQueens, &pWhiteQueens)   I m == 0      R 1B    V placingBlack = 1B   L(i) 0 .< n      L(j) 0 .< n         V pos = (i, j)         L(queen) pBlackQueens            I queen == pos | (!placingBlack & isAttacking(queen, pos))               L.break         L.was_no_break            L(queen) pWhiteQueens               I queen == pos | (placingBlack & isAttacking(queen, pos))                  L.break            L.was_no_break               I placingBlack                  pBlackQueens [+]= pos                  placingBlack = 0B               E                  pWhiteQueens [+]= pos                  I place(m - 1, n, &pBlackQueens, &pWhiteQueens)                     R 1B                  pBlackQueens.pop()                  pWhiteQueens.pop()                  placingBlack = 1B    I !placingBlack      pBlackQueens.pop()   R 0B F printBoard(n, blackQueens, whiteQueens)   V board = [Piece.EMPTY] * (n * n)    L(queen) blackQueens      board[queen.x * n + queen.y] = Piece.BLACK    L(queen) whiteQueens      board[queen.x * n + queen.y] = Piece.WHITE    L(b) board      V i = L.index      I i != 0 & i % n == 0         print()      I b == BLACK         print(‘B ’, end' ‘’)      E I b == WHITE         print(‘W ’, end' ‘’)      E         V j = i I/ n         V k = i - j * n         I j % 2 == k % 2            print(‘x ’, end' ‘’)         E            print(‘o ’, end' ‘’)   print("\n") V nms = [          (2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3),          (5, 1), (5, 2), (5, 3), (5, 4), (5, 5),          (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6),          (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)        ] L(nm) nms   print(‘#. black and #. white queens on a #. x #. board:’.format(nm[1], nm[1], nm[0], nm[0]))   [(Int, Int)] blackQueens, whiteQueens   I place(nm[1], nm[0], &blackQueens, &whiteQueens)      printBoard(nm[0], blackQueens, whiteQueens)   E      print("No solution exists.\n")`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B o x
o x W
x o x

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B o x o
o x W x
x o x o
o x o x

2 black and 2 white queens on a 4 x 4 board:
B o x o
o x W x
B o x o
o x W x

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B o x o x
o x W x o
x o x o x
o x o x o
x o x o x

2 black and 2 white queens on a 5 x 5 board:
B o x o B
o x W x o
x W x o x
o x o x o
x o x o x

3 black and 3 white queens on a 5 x 5 board:
B o x o B
o x W x o
x W x o x
o x o B o
x W x o x

4 black and 4 white queens on a 5 x 5 board:
x B x B x
o x o x B
W o W o x
o x o x B
W o W o x

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B o x o x o
o x W x o x
x o x o x o
o x o x o x
x o x o x o
o x o x o x

2 black and 2 white queens on a 6 x 6 board:
B o x o B o
o x W x o x
x W x o x o
o x o x o x
x o x o x o
o x o x o x

3 black and 3 white queens on a 6 x 6 board:
B o x o B B
o x W x o x
x W x o x o
o x o x o x
x o W o x o
o x o x o x

4 black and 4 white queens on a 6 x 6 board:
B o x o B B
o x W x o x
x W x o x o
o x o x o B
x o W W x o
o x o x o x

5 black and 5 white queens on a 6 x 6 board:
x B x o B o
o x o B o B
W o x o x o
W x W x o x
x o x o x B
W x W x o x

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B o x o x o x
o x W x o x o
x o x o x o x
o x o x o x o
x o x o x o x
o x o x o x o
x o x o x o x

2 black and 2 white queens on a 7 x 7 board:
B o x o B o x
o x W x o x W
x o x o x o x
o x o x o x o
x o x o x o x
o x o x o x o
x o x o x o x

3 black and 3 white queens on a 7 x 7 board:
B o x o B o x
o x W x o x W
B o x o x o x
o x W x o x o
x o x o x o x
o x o x o x o
x o x o x o x

4 black and 4 white queens on a 7 x 7 board:
B o x o B o x
o x W x o x W
B o x o B o x
o x W x o x W
x o x o x o x
o x o x o x o
x o x o x o x

5 black and 5 white queens on a 7 x 7 board:
B o x o B o x
o x W x o x W
B o x o B o x
o x W x o x W
B o x o x o x
o x W x o x o
x o x o x o x

6 black and 6 white queens on a 7 x 7 board:
B o x o B o x
o x W x o x W
B o x o B o x
o x W x o x W
B o x o B o x
o x W x o x W
x o x o x o x

7 black and 7 white queens on a 7 x 7 board:
x B x o x B x
o B o x B x o
x B x o x B x
o x o x B x o
W o W o x o W
o x o W o x o
W o W W x o x

```

## C

Translation of: C#
`#include <math.h>#include <stdbool.h>#include <stdio.h>#include <stdlib.h> enum Piece {    Empty,    Black,    White,}; typedef struct Position_t {    int x, y;} Position; /////////////////////////////////////////////// struct Node_t {    Position pos;    struct Node_t *next;}; void releaseNode(struct Node_t *head) {    if (head == NULL) return;     releaseNode(head->next);    head->next = NULL;     free(head);} typedef struct List_t {    struct Node_t *head;    struct Node_t *tail;    size_t length;} List; List makeList() {    return (List) { NULL, NULL, 0 };} void releaseList(List *lst) {    if (lst == NULL) return;     releaseNode(lst->head);    lst->head = NULL;    lst->tail = NULL;} void addNode(List *lst, Position pos) {    struct Node_t *newNode;     if (lst == NULL) {        exit(EXIT_FAILURE);    }     newNode = malloc(sizeof(struct Node_t));    if (newNode == NULL) {        exit(EXIT_FAILURE);    }     newNode->next = NULL;    newNode->pos = pos;     if (lst->head == NULL) {        lst->head = lst->tail = newNode;    } else {        lst->tail->next = newNode;        lst->tail = newNode;    }     lst->length++;} void removeAt(List *lst, size_t pos) {    if (lst == NULL) return;     if (pos == 0) {        struct Node_t *temp = lst->head;         if (lst->tail == lst->head) {            lst->tail = NULL;        }         lst->head = lst->head->next;        temp->next = NULL;         free(temp);        lst->length--;    } else {        struct Node_t *temp = lst->head;        struct Node_t *rem;        size_t i = pos;         while (i-- > 1) {            temp = temp->next;        }         rem = temp->next;        if (rem == lst->tail) {            lst->tail = temp;        }         temp->next = rem->next;         rem->next = NULL;        free(rem);         lst->length--;    }} /////////////////////////////////////////////// bool isAttacking(Position queen, Position pos) {    return queen.x == pos.x        || queen.y == pos.y        || abs(queen.x - pos.x) == abs(queen.y - pos.y);} bool place(int m, int n, List *pBlackQueens, List *pWhiteQueens) {    struct Node_t *queenNode;    bool placingBlack = true;    int i, j;     if (pBlackQueens == NULL || pWhiteQueens == NULL) {        exit(EXIT_FAILURE);    }     if (m == 0) return true;    for (i = 0; i < n; i++) {        for (j = 0; j < n; j++) {            Position pos = { i, j };             queenNode = pBlackQueens->head;            while (queenNode != NULL) {                if ((queenNode->pos.x == pos.x && queenNode->pos.y == pos.y) || !placingBlack && isAttacking(queenNode->pos, pos)) {                    goto inner;                }                queenNode = queenNode->next;            }             queenNode = pWhiteQueens->head;            while (queenNode != NULL) {                if ((queenNode->pos.x == pos.x && queenNode->pos.y == pos.y) || placingBlack && isAttacking(queenNode->pos, pos)) {                    goto inner;                }                queenNode = queenNode->next;            }             if (placingBlack) {                addNode(pBlackQueens, pos);                placingBlack = false;            } else {                addNode(pWhiteQueens, pos);                if (place(m - 1, n, pBlackQueens, pWhiteQueens)) {                    return true;                }                removeAt(pBlackQueens, pBlackQueens->length - 1);                removeAt(pWhiteQueens, pWhiteQueens->length - 1);                placingBlack = true;            }         inner: {}        }    }    if (!placingBlack) {        removeAt(pBlackQueens, pBlackQueens->length - 1);    }    return false;} void printBoard(int n, List *pBlackQueens, List *pWhiteQueens) {    size_t length = n * n;    struct Node_t *queenNode;    char *board;    size_t i, j, k;     if (pBlackQueens == NULL || pWhiteQueens == NULL) {        exit(EXIT_FAILURE);    }     board = calloc(length, sizeof(char));    if (board == NULL) {        exit(EXIT_FAILURE);    }     queenNode = pBlackQueens->head;    while (queenNode != NULL) {        board[queenNode->pos.x * n + queenNode->pos.y] = Black;        queenNode = queenNode->next;    }     queenNode = pWhiteQueens->head;    while (queenNode != NULL) {        board[queenNode->pos.x * n + queenNode->pos.y] = White;        queenNode = queenNode->next;    }     for (i = 0; i < length; i++) {        if (i != 0 && i % n == 0) {            printf("\n");        }        switch (board[i]) {        case Black:            printf("B ");            break;        case White:            printf("W ");            break;        default:            j = i / n;            k = i - j * n;            if (j % 2 == k % 2) {                printf("  ");            } else {                printf("# ");            }            break;        }    }     printf("\n\n");} void test(int n, int q) {    List blackQueens = makeList();    List whiteQueens = makeList();     printf("%d black and %d white queens on a %d x %d board:\n", q, q, n, n);    if (place(q, n, &blackQueens, &whiteQueens)) {        printBoard(n, &blackQueens, &whiteQueens);    } else {        printf("No solution exists.\n\n");    }     releaseList(&blackQueens);    releaseList(&whiteQueens);} int main() {    test(2, 1);     test(3, 1);    test(3, 2);     test(4, 1);    test(4, 2);    test(4, 3);     test(5, 1);    test(5, 2);    test(5, 3);    test(5, 4);    test(5, 5);     test(6, 1);    test(6, 2);    test(6, 3);    test(6, 4);    test(6, 5);    test(6, 6);     test(7, 1);    test(7, 2);    test(7, 3);    test(7, 4);    test(7, 5);    test(7, 6);    test(7, 7);     return EXIT_SUCCESS;}`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B #
#   W
#

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B #   #
#   W
#   #
#   #

2 black and 2 white queens on a 4 x 4 board:
B #   #
#   W
B #   #
#   W

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B #   #
#   W   #
#   #
#   #   #
#   #

2 black and 2 white queens on a 5 x 5 board:
B #   # B
#   W   #
W   #
#   #   #
#   #

3 black and 3 white queens on a 5 x 5 board:
B #   # B
#   W   #
W   #
#   # B #
W   #

4 black and 4 white queens on a 5 x 5 board:
B   B
#   #   B
W # W #
#   #   B
W # W #

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B #   #   #
#   W   #
#   #   #
#   #   #
#   #   #
#   #   #

2 black and 2 white queens on a 6 x 6 board:
B #   # B #
#   W   #
W   #   #
#   #   #
#   #   #
#   #   #

3 black and 3 white queens on a 6 x 6 board:
B #   # B B
#   W   #
W   #   #
#   #   #
# W #   #
#   #   #

4 black and 4 white queens on a 6 x 6 board:
B #   # B B
#   W   #
W   #   #
#   #   # B
# W W   #
#   #   #

5 black and 5 white queens on a 6 x 6 board:
B   # B #
#   # B # B
W #   #   #
W   W   #
#   #   B
W   W   #

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B #   #   #
#   W   #   #
#   #   #
#   #   #   #
#   #   #
#   #   #   #
#   #   #

2 black and 2 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
#   #   #
#   #   #   #
#   #   #
#   #   #   #
#   #   #

3 black and 3 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
B #   #   #
#   W   #   #
#   #   #
#   #   #   #
#   #   #

4 black and 4 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
B #   # B #
#   W   #   W
#   #   #
#   #   #   #
#   #   #

5 black and 5 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
B #   # B #
#   W   #   W
B #   #   #
#   W   #   #
#   #   #

6 black and 6 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
B #   # B #
#   W   #   W
B #   # B #
#   W   #   W
#   #   #

7 black and 7 white queens on a 7 x 7 board:
B   #   B
# B #   B   #
B   #   B
#   #   B   #
W # W #   # W
#   # W #   #
W # W W   #```

## C#

Translation of: D
`using System;using System.Collections.Generic; namespace PeacefulChessQueenArmies {    using Position = Tuple<int, int>;     enum Piece {        Empty,        Black,        White    }     class Program {        static bool IsAttacking(Position queen, Position pos) {            return queen.Item1 == pos.Item1                || queen.Item2 == pos.Item2                || Math.Abs(queen.Item1 - pos.Item1) == Math.Abs(queen.Item2 - pos.Item2);        }         static bool Place(int m, int n, List<Position> pBlackQueens, List<Position> pWhiteQueens) {            if (m == 0) {                return true;            }            bool placingBlack = true;            for (int i = 0; i < n; i++) {                for (int j = 0; j < n; j++) {                    var pos = new Position(i, j);                    foreach (var queen in pBlackQueens) {                        if (queen.Equals(pos) || !placingBlack && IsAttacking(queen, pos)) {                            goto inner;                        }                    }                    foreach (var queen in pWhiteQueens) {                        if (queen.Equals(pos) || placingBlack && IsAttacking(queen, pos)) {                            goto inner;                        }                    }                    if (placingBlack) {                        pBlackQueens.Add(pos);                        placingBlack = false;                    } else {                        pWhiteQueens.Add(pos);                        if (Place(m - 1, n, pBlackQueens, pWhiteQueens)) {                            return true;                        }                        pBlackQueens.RemoveAt(pBlackQueens.Count - 1);                        pWhiteQueens.RemoveAt(pWhiteQueens.Count - 1);                        placingBlack = true;                    }                inner: { }                }            }            if (!placingBlack) {                pBlackQueens.RemoveAt(pBlackQueens.Count - 1);            }            return false;        }         static void PrintBoard(int n, List<Position> blackQueens, List<Position> whiteQueens) {            var board = new Piece[n * n];             foreach (var queen in blackQueens) {                board[queen.Item1 * n + queen.Item2] = Piece.Black;            }            foreach (var queen in whiteQueens) {                board[queen.Item1 * n + queen.Item2] = Piece.White;            }             for (int i = 0; i < board.Length; i++) {                if (i != 0 && i % n == 0) {                    Console.WriteLine();                }                switch (board[i]) {                    case Piece.Black:                        Console.Write("B ");                        break;                    case Piece.White:                        Console.Write("W ");                        break;                    case Piece.Empty:                        int j = i / n;                        int k = i - j * n;                        if (j % 2 == k % 2) {                            Console.Write("  ");                        } else {                            Console.Write("# ");                        }                        break;                }            }             Console.WriteLine("\n");        }         static void Main() {            var nms = new int[,] {                {2, 1}, {3, 1}, {3, 2}, {4, 1}, {4, 2}, {4, 3},                {5, 1}, {5, 2}, {5, 3}, {5, 4}, {5, 5},                {6, 1}, {6, 2}, {6, 3}, {6, 4}, {6, 5}, {6, 6},                {7, 1}, {7, 2}, {7, 3}, {7, 4}, {7, 5}, {7, 6}, {7, 7},            };            for (int i = 0; i < nms.GetLength(0); i++) {                Console.WriteLine("{0} black and {0} white queens on a {1} x {1} board:", nms[i, 1], nms[i, 0]);                List<Position> blackQueens = new List<Position>();                List<Position> whiteQueens = new List<Position>();                if (Place(nms[i, 1], nms[i, 0], blackQueens, whiteQueens)) {                    PrintBoard(nms[i, 0], blackQueens, whiteQueens);                } else {                    Console.WriteLine("No solution exists.\n");                }            }        }    }}`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B #
#   W
#

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B #   #
#   W
#   #
#   #

2 black and 2 white queens on a 4 x 4 board:
B #   #
#   W
B #   #
#   W

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B #   #
#   W   #
#   #
#   #   #
#   #

2 black and 2 white queens on a 5 x 5 board:
B #   # B
#   W   #
W   #
#   #   #
#   #

3 black and 3 white queens on a 5 x 5 board:
B #   # B
#   W   #
W   #
#   # B #
W   #

4 black and 4 white queens on a 5 x 5 board:
B   B
#   #   B
W # W #
#   #   B
W # W #

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B #   #   #
#   W   #
#   #   #
#   #   #
#   #   #
#   #   #

2 black and 2 white queens on a 6 x 6 board:
B #   # B #
#   W   #
W   #   #
#   #   #
#   #   #
#   #   #

3 black and 3 white queens on a 6 x 6 board:
B #   # B B
#   W   #
W   #   #
#   #   #
# W #   #
#   #   #

4 black and 4 white queens on a 6 x 6 board:
B #   # B B
#   W   #
W   #   #
#   #   # B
# W W   #
#   #   #

5 black and 5 white queens on a 6 x 6 board:
B   # B #
#   # B # B
W #   #   #
W   W   #
#   #   B
W   W   #

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B #   #   #
#   W   #   #
#   #   #
#   #   #   #
#   #   #
#   #   #   #
#   #   #

2 black and 2 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
#   #   #
#   #   #   #
#   #   #
#   #   #   #
#   #   #

3 black and 3 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
B #   #   #
#   W   #   #
#   #   #
#   #   #   #
#   #   #

4 black and 4 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
B #   # B #
#   W   #   W
#   #   #
#   #   #   #
#   #   #

5 black and 5 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
B #   # B #
#   W   #   W
B #   #   #
#   W   #   #
#   #   #

6 black and 6 white queens on a 7 x 7 board:
B #   # B #
#   W   #   W
B #   # B #
#   W   #   W
B #   # B #
#   W   #   W
#   #   #

7 black and 7 white queens on a 7 x 7 board:
B   #   B
# B #   B   #
B   #   B
#   #   B   #
W # W #   # W
#   # W #   #
W # W W   #```

## C++

Translation of: D
`#include <iostream>#include <vector> enum class Piece {    empty,    black,    white}; typedef std::pair<int, int> position; bool isAttacking(const position &queen, const position &pos) {    return queen.first == pos.first        || queen.second == pos.second        || abs(queen.first - pos.first) == abs(queen.second - pos.second);} bool place(const int m, const int n, std::vector<position> &pBlackQueens, std::vector<position> &pWhiteQueens) {    if (m == 0) {        return true;    }    bool placingBlack = true;    for (int i = 0; i < n; i++) {        for (int j = 0; j < n; j++) {            auto pos = std::make_pair(i, j);            for (auto queen : pBlackQueens) {                if (queen == pos || !placingBlack && isAttacking(queen, pos)) {                    goto inner;                }            }            for (auto queen : pWhiteQueens) {                if (queen == pos || placingBlack && isAttacking(queen, pos)) {                    goto inner;                }            }            if (placingBlack) {                pBlackQueens.push_back(pos);                placingBlack = false;            } else {                pWhiteQueens.push_back(pos);                if (place(m - 1, n, pBlackQueens, pWhiteQueens)) {                    return true;                }                pBlackQueens.pop_back();                pWhiteQueens.pop_back();                placingBlack = true;            }         inner: {}        }    }    if (!placingBlack) {        pBlackQueens.pop_back();    }    return false;} void printBoard(int n, const std::vector<position> &blackQueens, const std::vector<position> &whiteQueens) {    std::vector<Piece> board(n * n);    std::fill(board.begin(), board.end(), Piece::empty);     for (auto &queen : blackQueens) {        board[queen.first * n + queen.second] = Piece::black;    }    for (auto &queen : whiteQueens) {        board[queen.first * n + queen.second] = Piece::white;    }     for (size_t i = 0; i < board.size(); ++i) {        if (i != 0 && i % n == 0) {            std::cout << '\n';        }        switch (board[i]) {        case Piece::black:            std::cout << "B ";            break;        case Piece::white:            std::cout << "W ";            break;        case Piece::empty:        default:            int j = i / n;            int k = i - j * n;            if (j % 2 == k % 2) {                std::cout << "x ";            } else {                std::cout << "* ";            }            break;        }    }     std::cout << "\n\n";} int main() {    std::vector<position> nms = {        {2, 1}, {3, 1}, {3, 2}, {4, 1}, {4, 2}, {4, 3},        {5, 1}, {5, 2}, {5, 3}, {5, 4}, {5, 5},        {6, 1}, {6, 2}, {6, 3}, {6, 4}, {6, 5}, {6, 6},        {7, 1}, {7, 2}, {7, 3}, {7, 4}, {7, 5}, {7, 6}, {7, 7},    };     for (auto nm : nms) {        std::cout << nm.second << " black and " << nm.second << " white queens on a " << nm.first << " x " << nm.first << " board:\n";        std::vector<position> blackQueens, whiteQueens;        if (place(nm.second, nm.first, blackQueens, whiteQueens)) {            printBoard(nm.first, blackQueens, whiteQueens);        } else {            std::cout << "No solution exists.\n\n";        }    }     return 0;}`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B * x
* x W
x * x

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B * x *
* x W x
x * x *
* x * x

2 black and 2 white queens on a 4 x 4 board:
B * x *
* x W x
B * x *
* x W x

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B * x * x
* x W x *
x * x * x
* x * x *
x * x * x

2 black and 2 white queens on a 5 x 5 board:
B * x * B
* x W x *
x W x * x
* x * x *
x * x * x

3 black and 3 white queens on a 5 x 5 board:
B * x * B
* x W x *
x W x * x
* x * B *
x W x * x

4 black and 4 white queens on a 5 x 5 board:
x B x B x
* x * x B
W * W * x
* x * x B
W * W * x

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B * x * x *
* x W x * x
x * x * x *
* x * x * x
x * x * x *
* x * x * x

2 black and 2 white queens on a 6 x 6 board:
B * x * B *
* x W x * x
x W x * x *
* x * x * x
x * x * x *
* x * x * x

3 black and 3 white queens on a 6 x 6 board:
B * x * B B
* x W x * x
x W x * x *
* x * x * x
x * W * x *
* x * x * x

4 black and 4 white queens on a 6 x 6 board:
B * x * B B
* x W x * x
x W x * x *
* x * x * B
x * W W x *
* x * x * x

5 black and 5 white queens on a 6 x 6 board:
x B x * B *
* x * B * B
W * x * x *
W x W x * x
x * x * x B
W x W x * x

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B * x * x * x
* x W x * x *
x * x * x * x
* x * x * x *
x * x * x * x
* x * x * x *
x * x * x * x

2 black and 2 white queens on a 7 x 7 board:
B * x * B * x
* x W x * x W
x * x * x * x
* x * x * x *
x * x * x * x
* x * x * x *
x * x * x * x

3 black and 3 white queens on a 7 x 7 board:
B * x * B * x
* x W x * x W
B * x * x * x
* x W x * x *
x * x * x * x
* x * x * x *
x * x * x * x

4 black and 4 white queens on a 7 x 7 board:
B * x * B * x
* x W x * x W
B * x * B * x
* x W x * x W
x * x * x * x
* x * x * x *
x * x * x * x

5 black and 5 white queens on a 7 x 7 board:
B * x * B * x
* x W x * x W
B * x * B * x
* x W x * x W
B * x * x * x
* x W x * x *
x * x * x * x

6 black and 6 white queens on a 7 x 7 board:
B * x * B * x
* x W x * x W
B * x * B * x
* x W x * x W
B * x * B * x
* x W x * x W
x * x * x * x

7 black and 7 white queens on a 7 x 7 board:
x B x * x B x
* B * x B x *
x B x * x B x
* x * x B x *
W * W * x * W
* x * W * x *
W * W W x * x```

## D

Translation of: Go
`import std.array;import std.math;import std.stdio;import std.typecons; enum Piece {    empty,    black,    white,} alias position = Tuple!(int, "i", int, "j"); bool place(int m, int n, ref position[] pBlackQueens, ref position[] pWhiteQueens) {    if (m == 0) {        return true;    }    bool placingBlack = true;    foreach (i; 0..n) {        inner:        foreach (j; 0..n) {            auto pos = position(i, j);            foreach (queen; pBlackQueens) {                if (queen == pos || !placingBlack && isAttacking(queen, pos)) {                    continue inner;                }            }            foreach (queen; pWhiteQueens) {                if (queen == pos || placingBlack && isAttacking(queen, pos)) {                    continue inner;                }            }            if (placingBlack) {                pBlackQueens ~= pos;                placingBlack = false;            } else {                pWhiteQueens ~= pos;                if (place(m - 1, n, pBlackQueens, pWhiteQueens)) {                    return true;                }                pBlackQueens.length--;                pWhiteQueens.length--;                placingBlack = true;            }        }    }    if (!placingBlack) {        pBlackQueens.length--;    }    return false;} bool isAttacking(position queen, position pos) {    return queen.i == pos.i        || queen.j == pos.j        || abs(queen.i - pos.i) == abs(queen.j - pos.j);} void printBoard(int n, position[] blackQueens, position[] whiteQueens) {    auto board = uninitializedArray!(Piece[])(n * n);    board[] = Piece.empty;     foreach (queen; blackQueens) {        board[queen.i * n + queen.j] = Piece.black;    }    foreach (queen; whiteQueens) {        board[queen.i * n + queen.j] = Piece.white;    }    foreach (i,b; board) {        if (i != 0 && i % n == 0) {            writeln;        }        final switch (b) {            case Piece.black:                write("B ");                break;            case Piece.white:                write("W ");                break;            case Piece.empty:                int j = i / n;                int k = i - j * n;                 if (j % 2 == k % 2) {                    write("• "w);                } else {                    write("◦ "w);                }                break;        }    }    writeln('\n');} void main() {    auto nms = [        [2, 1], [3, 1], [3, 2], [4, 1], [4, 2], [4, 3],        [5, 1], [5, 2], [5, 3], [5, 4], [5, 5],        [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6],        [7, 1], [7, 2], [7, 3], [7, 4], [7, 5], [7, 6], [7, 7],    ];    foreach (nm; nms) {        writefln("%d black and %d white queens on a %d x %d board:", nm[1], nm[1], nm[0], nm[0]);        position[] blackQueens;        position[] whiteQueens;        if (place(nm[1], nm[0], blackQueens, whiteQueens)) {            printBoard(nm[0], blackQueens, whiteQueens);        } else {            writeln("No solution exists.\n");        }    }}`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B ◦ •
◦ • W
• ◦ •

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B ◦ • ◦
◦ • W •
• ◦ • ◦
◦ • ◦ •

2 black and 2 white queens on a 4 x 4 board:
B ◦ • ◦
◦ • W •
B ◦ • ◦
◦ • W •

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • W • ◦
• ◦ • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

2 black and 2 white queens on a 5 x 5 board:
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

3 black and 3 white queens on a 5 x 5 board:
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ B ◦
• W • ◦ •

4 black and 4 white queens on a 5 x 5 board:
• B • B •
◦ • ◦ • B
W ◦ W ◦ •
◦ • ◦ • B
W ◦ W ◦ •

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

2 black and 2 white queens on a 6 x 6 board:
B ◦ • ◦ B ◦
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

3 black and 3 white queens on a 6 x 6 board:
B ◦ • ◦ B B
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ W ◦ • ◦
◦ • ◦ • ◦ •

4 black and 4 white queens on a 6 x 6 board:
B ◦ • ◦ B B
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ B
• ◦ W W • ◦
◦ • ◦ • ◦ •

5 black and 5 white queens on a 6 x 6 board:
• B • ◦ B ◦
◦ • ◦ B ◦ B
W ◦ • ◦ • ◦
W • W • ◦ •
• ◦ • ◦ • B
W • W • ◦ •

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

2 black and 2 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

3 black and 3 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

4 black and 4 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

5 black and 5 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •

6 black and 6 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •

7 black and 7 white queens on a 7 x 7 board:
• B • ◦ • B •
◦ B ◦ • B • ◦
• B • ◦ • B •
◦ • ◦ • B • ◦
W ◦ W ◦ • ◦ W
◦ • ◦ W ◦ • ◦
W ◦ W W • ◦ • ```

## Go

This is based on the C# code here.

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.

`package main import "fmt" const (    empty = iota    black    white) const (    bqueen  = 'B'    wqueen  = 'W'    bbullet = '•'    wbullet = '◦') type position struct{ i, j int } func iabs(i int) int {    if i < 0 {        return -i    }    return i} func place(m, n int, pBlackQueens, pWhiteQueens *[]position) bool {    if m == 0 {        return true    }    placingBlack := true    for i := 0; i < n; i++ {    inner:        for j := 0; j < n; j++ {            pos := position{i, j}            for _, queen := range *pBlackQueens {                if queen == pos || !placingBlack && isAttacking(queen, pos) {                    continue inner                }            }            for _, queen := range *pWhiteQueens {                if queen == pos || placingBlack && isAttacking(queen, pos) {                    continue inner                }            }            if placingBlack {                *pBlackQueens = append(*pBlackQueens, pos)                placingBlack = false            } else {                *pWhiteQueens = append(*pWhiteQueens, pos)                if place(m-1, n, pBlackQueens, pWhiteQueens) {                    return true                }                *pBlackQueens = (*pBlackQueens)[0 : len(*pBlackQueens)-1]                *pWhiteQueens = (*pWhiteQueens)[0 : len(*pWhiteQueens)-1]                placingBlack = true            }        }    }    if !placingBlack {        *pBlackQueens = (*pBlackQueens)[0 : len(*pBlackQueens)-1]    }    return false} func isAttacking(queen, pos position) bool {    if queen.i == pos.i {        return true    }    if queen.j == pos.j {        return true    }    if iabs(queen.i-pos.i) == iabs(queen.j-pos.j) {        return true    }    return false} func printBoard(n int, blackQueens, whiteQueens []position) {    board := make([]int, n*n)    for _, queen := range blackQueens {        board[queen.i*n+queen.j] = black    }    for _, queen := range whiteQueens {        board[queen.i*n+queen.j] = white    }     for i, b := range board {        if i != 0 && i%n == 0 {            fmt.Println()        }        switch b {        case black:            fmt.Printf("%c ", bqueen)        case white:            fmt.Printf("%c ", wqueen)        case empty:            if i%2 == 0 {                fmt.Printf("%c ", bbullet)            } else {                fmt.Printf("%c ", wbullet)            }        }    }    fmt.Println("\n")} func main() {    nms := [][2]int{        {2, 1}, {3, 1}, {3, 2}, {4, 1}, {4, 2}, {4, 3},        {5, 1}, {5, 2}, {5, 3}, {5, 4}, {5, 5},        {6, 1}, {6, 2}, {6, 3}, {6, 4}, {6, 5}, {6, 6},        {7, 1}, {7, 2}, {7, 3}, {7, 4}, {7, 5}, {7, 6}, {7, 7},    }    for _, nm := range nms {        n, m := nm[0], nm[1]        fmt.Printf("%d black and %d white queens on a %d x %d board:\n", m, m, n, n)        var blackQueens, whiteQueens []position        if place(m, n, &blackQueens, &whiteQueens) {            printBoard(n, blackQueens, whiteQueens)        } else {            fmt.Println("No solution exists.\n")        }    }}`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B ◦ •
◦ • W
• ◦ •

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B ◦ • ◦
• ◦ W ◦
• ◦ • ◦
• ◦ • ◦

2 black and 2 white queens on a 4 x 4 board:
B ◦ • ◦
• ◦ W ◦
B ◦ • ◦
• ◦ W ◦

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • W • ◦
• ◦ • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

2 black and 2 white queens on a 5 x 5 board:
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

3 black and 3 white queens on a 5 x 5 board:
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ B ◦
• W • ◦ •

4 black and 4 white queens on a 5 x 5 board:
• B • B •
◦ • ◦ • B
W ◦ W ◦ •
◦ • ◦ • B
W ◦ W ◦ •

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
• ◦ W ◦ • ◦
• ◦ • ◦ • ◦
• ◦ • ◦ • ◦
• ◦ • ◦ • ◦
• ◦ • ◦ • ◦

2 black and 2 white queens on a 6 x 6 board:
B ◦ • ◦ B ◦
• ◦ W ◦ • ◦
• W • ◦ • ◦
• ◦ • ◦ • ◦
• ◦ • ◦ • ◦
• ◦ • ◦ • ◦

3 black and 3 white queens on a 6 x 6 board:
B ◦ • ◦ B B
• ◦ W ◦ • ◦
• W • ◦ • ◦
• ◦ • ◦ • ◦
• ◦ W ◦ • ◦
• ◦ • ◦ • ◦

4 black and 4 white queens on a 6 x 6 board:
B ◦ • ◦ B B
• ◦ W ◦ • ◦
• W • ◦ • ◦
• ◦ • ◦ • B
• ◦ W W • ◦
• ◦ • ◦ • ◦

5 black and 5 white queens on a 6 x 6 board:
• B • ◦ B ◦
• ◦ • B • B
W ◦ • ◦ • ◦
W ◦ W ◦ • ◦
• ◦ • ◦ • B
W ◦ W ◦ • ◦

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

2 black and 2 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

3 black and 3 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

4 black and 4 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

5 black and 5 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •

6 black and 6 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •

7 black and 7 white queens on a 7 x 7 board:
• B • ◦ • B •
◦ B ◦ • B • ◦
• B • ◦ • B •
◦ • ◦ • B • ◦
W ◦ W ◦ • ◦ W
◦ • ◦ W ◦ • ◦
W ◦ W W • ◦ •
```

## Java

Translation of: Kotlin
`import java.util.ArrayList;import java.util.Arrays;import java.util.List; public class Peaceful {    enum Piece {        Empty,        Black,        White,    }     public static class Position {        public int x, y;         public Position(int x, int y) {            this.x = x;            this.y = y;        }         @Override        public boolean equals(Object obj) {            if (obj instanceof Position) {                Position pos = (Position) obj;                return pos.x == x && pos.y == y;            }            return false;        }    }     private static boolean place(int m, int n, List<Position> pBlackQueens, List<Position> pWhiteQueens) {        if (m == 0) {            return true;        }        boolean placingBlack = true;        for (int i = 0; i < n; ++i) {            inner:            for (int j = 0; j < n; ++j) {                Position pos = new Position(i, j);                for (Position queen : pBlackQueens) {                    if (pos.equals(queen) || !placingBlack && isAttacking(queen, pos)) {                        continue inner;                    }                }                for (Position queen : pWhiteQueens) {                    if (pos.equals(queen) || placingBlack && isAttacking(queen, pos)) {                        continue inner;                    }                }                if (placingBlack) {                    pBlackQueens.add(pos);                    placingBlack = false;                } else {                    pWhiteQueens.add(pos);                    if (place(m - 1, n, pBlackQueens, pWhiteQueens)) {                        return true;                    }                    pBlackQueens.remove(pBlackQueens.size() - 1);                    pWhiteQueens.remove(pWhiteQueens.size() - 1);                    placingBlack = true;                }            }        }        if (!placingBlack) {            pBlackQueens.remove(pBlackQueens.size() - 1);        }        return false;    }     private static boolean isAttacking(Position queen, Position pos) {        return queen.x == pos.x            || queen.y == pos.y            || Math.abs(queen.x - pos.x) == Math.abs(queen.y - pos.y);    }     private static void printBoard(int n, List<Position> blackQueens, List<Position> whiteQueens) {        Piece[] board = new Piece[n * n];        Arrays.fill(board, Piece.Empty);         for (Position queen : blackQueens) {            board[queen.x + n * queen.y] = Piece.Black;        }        for (Position queen : whiteQueens) {            board[queen.x + n * queen.y] = Piece.White;        }        for (int i = 0; i < board.length; ++i) {            if ((i != 0) && i % n == 0) {                System.out.println();            }             Piece b = board[i];            if (b == Piece.Black) {                System.out.print("B ");            } else if (b == Piece.White) {                System.out.print("W ");            } else {                int j = i / n;                int k = i - j * n;                if (j % 2 == k % 2) {                    System.out.print("• ");                } else {                    System.out.print("◦ ");                }            }        }        System.out.println('\n');    }     public static void main(String[] args) {        List<Position> nms = List.of(            new Position(2, 1),            new Position(3, 1),            new Position(3, 2),            new Position(4, 1),            new Position(4, 2),            new Position(4, 3),            new Position(5, 1),            new Position(5, 2),            new Position(5, 3),            new Position(5, 4),            new Position(5, 5),            new Position(6, 1),            new Position(6, 2),            new Position(6, 3),            new Position(6, 4),            new Position(6, 5),            new Position(6, 6),            new Position(7, 1),            new Position(7, 2),            new Position(7, 3),            new Position(7, 4),            new Position(7, 5),            new Position(7, 6),            new Position(7, 7)        );        for (Position nm : nms) {            int m = nm.y;            int n = nm.x;            System.out.printf("%d black and %d white queens on a %d x %d board:\n", m, m, n, n);            List<Position> blackQueens = new ArrayList<>();            List<Position> whiteQueens = new ArrayList<>();            if (place(m, n, blackQueens, whiteQueens)) {                printBoard(n, blackQueens, whiteQueens);            } else {                System.out.println("No solution exists.\n");            }        }    }}`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B ◦ •
◦ • ◦
• W •

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B ◦ • ◦
◦ • ◦ •
• W • ◦
◦ • ◦ •

2 black and 2 white queens on a 4 x 4 board:
B ◦ B ◦
◦ • ◦ •
• W • W
◦ • ◦ •

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • ◦ • ◦
• W • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

2 black and 2 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • W • ◦
• W • ◦ •
◦ • ◦ • ◦
B ◦ • ◦ •

3 black and 3 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • W • W
• W • ◦ •
◦ • ◦ B ◦
B ◦ • ◦ •

4 black and 4 white queens on a 5 x 5 board:
• ◦ W ◦ W
B • ◦ • ◦
• ◦ W ◦ W
B • ◦ • ◦
• B • B •

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • ◦ • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

2 black and 2 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
B ◦ • ◦ • ◦
◦ • ◦ • ◦ •

3 black and 3 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• W • ◦ W ◦
◦ • ◦ • ◦ •
B ◦ • ◦ • ◦
B • ◦ • ◦ •

4 black and 4 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• W • ◦ W ◦
◦ • ◦ • W •
B ◦ • ◦ • ◦
B • ◦ B ◦ •

5 black and 5 white queens on a 6 x 6 board:
• ◦ W W • W
B • ◦ • ◦ •
• ◦ • W • W
◦ B ◦ • ◦ •
B ◦ • ◦ • ◦
◦ B ◦ • B •

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

2 black and 2 white queens on a 7 x 7 board:
B ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
B ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • ◦ • ◦ •

3 black and 3 white queens on a 7 x 7 board:
B ◦ B ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • W • ◦ •
◦ • ◦ • ◦ • ◦
B ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • ◦ • ◦ •

4 black and 4 white queens on a 7 x 7 board:
B ◦ B ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • W • ◦ •
◦ • ◦ • ◦ • ◦
B ◦ B ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • W • ◦ •

5 black and 5 white queens on a 7 x 7 board:
B ◦ B ◦ B ◦ •
◦ • ◦ • ◦ • ◦
• W • W • W •
◦ • ◦ • ◦ • ◦
B ◦ B ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • W • ◦ •

6 black and 6 white queens on a 7 x 7 board:
B ◦ B ◦ B ◦ •
◦ • ◦ • ◦ • ◦
• W • W • W •
◦ • ◦ • ◦ • ◦
B ◦ B ◦ B ◦ •
◦ • ◦ • ◦ • ◦
• W • W • W •

7 black and 7 white queens on a 7 x 7 board:
• ◦ • ◦ W ◦ W
B B B • ◦ • ◦
• ◦ • ◦ W ◦ W
◦ • ◦ • ◦ W W
• B • B • ◦ •
B • B • ◦ • ◦
• ◦ • ◦ W ◦ • ```

## Julia

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

`using Gtk struct Position    row::Int    col::Intend function place!(numeach, bsize, bqueens, wqueens)    isattack(q, pos) = (q.row == pos.row || q.col == pos.col ||                        abs(q.row - pos.row) == abs(q.col - pos.col))    noattack(qs, pos) = !any(x -> isattack(x, pos), qs)    positionopen(bqs, wqs, p) = !any(x -> x == p, bqs) && !any(x -> x == p, wqs)     placingbqueens = true    if numeach < 1        return true    end    for i in 1:bsize, j in 1:bsize        bpos = Position(i, j)        if positionopen(bqueens, wqueens, bpos)            if placingbqueens && noattack(wqueens, bpos)                push!(bqueens, bpos)                placingbqueens = false            elseif !placingbqueens && noattack(bqueens, bpos)                push!(wqueens, bpos)                if place!(numeach - 1, bsize, bqueens, wqueens)                    return true                end                pop!(bqueens)                pop!(wqueens)                placingbqueens = true            end        end    end    if !placingbqueens        pop!(bqueens)    end    falseend function peacefulqueenapp()    win = GtkWindow("Peaceful Chess Queen Armies", 800, 800) |> (GtkFrame() |> (box = GtkBox(:v)))    boardsize = 5    numqueenseach = 4    hbox = GtkBox(:h)    boardscale = GtkScale(false, 2:16)    set_gtk_property!(boardscale, :hexpand, true)    blabel = GtkLabel("Choose Board Size")    nqueenscale = GtkScale(false, 1:24)    set_gtk_property!(nqueenscale, :hexpand, true)    qlabel = GtkLabel("Choose Number of Queens Per Side")    solveit = GtkButton("Solve")    set_gtk_property!(solveit, :label, "   Solve   ")    solvequeens(wid) = (boardsize = Int(GAccessor.value(boardscale));        numqueenseach = Int(GAccessor.value(nqueenscale)); update!())    signal_connect(solvequeens, solveit, :clicked)    map(w->push!(hbox, w),[blabel, boardscale, qlabel, nqueenscale, solveit])    scrwin = GtkScrolledWindow()    grid = GtkGrid()    push!(scrwin, grid)    map(w -> push!(box, w),[hbox, scrwin])    piece = (white = "\u2655", black = "\u265B", blank = "   ")    stylist = GtkStyleProvider(Gtk.CssProviderLeaf(data="""        label {background-image: image(cornsilk); font-size: 48px;}        button {background-image: image(tan); font-size: 48px;}"""))     function update!()        bqueens, wqueens = Vector{Position}(), Vector{Position}()        place!(numqueenseach, boardsize, bqueens, wqueens)        if length(bqueens) == 0            warn_dialog("No solution for board size \$boardsize and \$numqueenseach queens each.", win)            return        end        empty!(grid)        labels = Array{Gtk.GtkLabelLeaf, 2}(undef, (boardsize, boardsize))        buttons = Array{GtkButtonLeaf, 2}(undef, (boardsize, boardsize))        for i in 1:boardsize, j in 1:boardsize            if isodd(i + j)                grid[i, j] = buttons[i, j] = GtkButton(piece.blank)                set_gtk_property!(buttons[i, j], :expand, true)                push!(Gtk.GAccessor.style_context(buttons[i, j]), stylist, 600)            else                grid[i, j] = labels[i, j] = GtkLabel(piece.blank)                set_gtk_property!(labels[i, j], :expand, true)                push!(Gtk.GAccessor.style_context(labels[i, j]), stylist, 600)            end            pos = Position(i, j)            if pos in bqueens                set_gtk_property!(grid[i, j], :label, piece.black)            elseif pos in wqueens                set_gtk_property!(grid[i, j], :label, piece.white)            end        end        showall(win)    end     update!()    cond = Condition()    endit(w) = notify(cond)    signal_connect(endit, win, :destroy)    showall(win)    wait(cond)end peacefulqueenapp() `

## Kotlin

Translation of: D
`import kotlin.math.abs enum class Piece {    Empty,    Black,    White,} typealias Position = Pair<Int, Int> fun place(m: Int, n: Int, pBlackQueens: MutableList<Position>, pWhiteQueens: MutableList<Position>): Boolean {    if (m == 0) {        return true    }    var placingBlack = true    for (i in 0 until n) {        inner@        for (j in 0 until n) {            val pos = Position(i, j)            for (queen in pBlackQueens) {                if (queen == pos || !placingBlack && isAttacking(queen, pos)) {                    continue@inner                }            }            for (queen in pWhiteQueens) {                if (queen == pos || placingBlack && isAttacking(queen, pos)) {                    continue@inner                }            }            placingBlack = if (placingBlack) {                pBlackQueens.add(pos)                false            } else {                pWhiteQueens.add(pos)                if (place(m - 1, n, pBlackQueens, pWhiteQueens)) {                    return true                }                pBlackQueens.removeAt(pBlackQueens.lastIndex)                pWhiteQueens.removeAt(pWhiteQueens.lastIndex)                true            }        }    }    if (!placingBlack) {        pBlackQueens.removeAt(pBlackQueens.lastIndex)    }    return false} fun isAttacking(queen: Position, pos: Position): Boolean {    return queen.first == pos.first            || queen.second == pos.second            || abs(queen.first - pos.first) == abs(queen.second - pos.second)} fun printBoard(n: Int, blackQueens: List<Position>, whiteQueens: List<Position>) {    val board = MutableList(n * n) { Piece.Empty }     for (queen in blackQueens) {        board[queen.first * n + queen.second] = Piece.Black    }    for (queen in whiteQueens) {        board[queen.first * n + queen.second] = Piece.White    }    for ((i, b) in board.withIndex()) {        if (i != 0 && i % n == 0) {            println()        }        if (b == Piece.Black) {            print("B ")        } else if (b == Piece.White) {            print("W ")        } else {            val j = i / n            val k = i - j * n            if (j % 2 == k % 2) {                print("• ")            } else {                print("◦ ")            }        }    }    println('\n')} fun main() {    val nms = listOf(        Pair(2, 1), Pair(3, 1), Pair(3, 2), Pair(4, 1), Pair(4, 2), Pair(4, 3),        Pair(5, 1), Pair(5, 2), Pair(5, 3), Pair(5, 4), Pair(5, 5),        Pair(6, 1), Pair(6, 2), Pair(6, 3), Pair(6, 4), Pair(6, 5), Pair(6, 6),        Pair(7, 1), Pair(7, 2), Pair(7, 3), Pair(7, 4), Pair(7, 5), Pair(7, 6), Pair(7, 7)    )    for ((n, m) in nms) {        println("\$m black and \$m white queens on a \$n x \$n board:")        val blackQueens = mutableListOf<Position>()        val whiteQueens = mutableListOf<Position>()        if (place(m, n, blackQueens, whiteQueens)) {            printBoard(n, blackQueens, whiteQueens)        } else {            println("No solution exists.\n")        }    }}`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B ◦ •
◦ • W
• ◦ •

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B ◦ • ◦
◦ • W •
• ◦ • ◦
◦ • ◦ •

2 black and 2 white queens on a 4 x 4 board:
B ◦ • ◦
◦ • W •
B ◦ • ◦
◦ • W •

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • W • ◦
• ◦ • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

2 black and 2 white queens on a 5 x 5 board:
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

3 black and 3 white queens on a 5 x 5 board:
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ B ◦
• W • ◦ •

4 black and 4 white queens on a 5 x 5 board:
• B • B •
◦ • ◦ • B
W ◦ W ◦ •
◦ • ◦ • B
W ◦ W ◦ •

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

2 black and 2 white queens on a 6 x 6 board:
B ◦ • ◦ B ◦
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

3 black and 3 white queens on a 6 x 6 board:
B ◦ • ◦ B B
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ W ◦ • ◦
◦ • ◦ • ◦ •

4 black and 4 white queens on a 6 x 6 board:
B ◦ • ◦ B B
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ B
• ◦ W W • ◦
◦ • ◦ • ◦ •

5 black and 5 white queens on a 6 x 6 board:
• B • ◦ B ◦
◦ • ◦ B ◦ B
W ◦ • ◦ • ◦
W • W • ◦ •
• ◦ • ◦ • B
W • W • ◦ •

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

2 black and 2 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

3 black and 3 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

4 black and 4 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

5 black and 5 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •

6 black and 6 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •

7 black and 7 white queens on a 7 x 7 board:
• B • ◦ • B •
◦ B ◦ • B • ◦
• B • ◦ • B •
◦ • ◦ • B • ◦
W ◦ W ◦ • ◦ W
◦ • ◦ W ◦ • ◦
W ◦ W W • ◦ • ```

## Mathematica/Wolfram Language

`ClearAll[ValidSpots, VisibleByQueen, SolveQueen, GetSolution]VisualizeState[state_] := Module[{q, cells},  q = MapIndexed[If[#["q"] == -1, {}, Text[Style[#["q"], 24], #2]] &, state, {2}];  cells = MapIndexed[{If[OddQ[Total[#2]], FaceForm[],        FaceForm[GrayLevel[0.8]]], EdgeForm[Black],       Rectangle[#2 - 0.5, #2 + 0.5]} &, state, {2}];  Graphics[{cells, q}] ]ValidSpots[state_, tp_Integer] := Module[{vals},  vals = [email protected][If[#1["q"] == -1 \[And] DeleteCases[#1["v"], tp] == {}, #2, Missing[]] &, state, {2}];  DeleteMissing[vals] ]VisibleByQueen[{i_, j_}, {a_, b_}] := i == a \[Or] j == b \[Or] i + j == a + b \[Or] i - j == a - bPlaceQueen[state_, pos : {i_Integer, j_Integer}, tp_Integer] := Module[{vals, out},  out = state;  out[[i, j]] = Association[out[[i, j]], "q" -> tp];  out = MapIndexed[If[VisibleByQueen[{i, j}, #2], <|#1, "v" -> Append[#1["v"], tp]|>, #1] &, out, {2}];  out  ]SolveQueen[state_, toplace_List] :=  Module[{len = Length[toplace], next, valid, newstate},  If[len == 0,   Print[[email protected]];   Print[StringRiffle[StringJoin /@ Map[ToString, state[[All, All, "q"]] /. -1 -> ".", {2}], "\n"]];   Abort[];   ,   next = First[toplace];   valid = ValidSpots[state, next];   Do[    newstate = PlaceQueen[state, v, next];    SolveQueen[newstate, Rest[toplace]]    ,    {v, valid}    ]   ]  ]GetSolution[n_Integer?Positive, m_Integer?Positive, numcol_ : 2] :=  Module[{state, tp},  state = ConstantArray[<|"q" -> -1, "v" -> {}|>, {n, n}];  tp = Flatten[Transpose[ConstantArray[#, m] & /@ Range[numcol]]];  SolveQueen[state, tp]  ]GetSolution[8, 4, 3](* Solves placing 3 armies of each 4 queens on an 8*8 board*)GetSolution[5, 4, 2](* Solves placing 2 armies of each 4 queens on an 5*5 board*)`
Output:
```[Graphical object]
1....1..
..2....2
....3...
.3....3.
...1....
1.......
..2....2
....3...

[Graphical object]
1...1
..2..
.2.2.
..2..
1...1```

## Nim

Translation of: Kotlin

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

`import sequtils, strformat type   Piece {.pure.} = enum Empty, Black, White  Position = tuple[x, y: int]  func isAttacking(queen, pos: Position): bool =  queen.x == pos.x or queen.y == pos.y or abs(queen.x - pos.x) == abs(queen.y - pos.y)  func place(m, n: int; blackQueens, whiteQueens: var seq[Position]): bool =   if m == 0: return true   var placingBlack = true  for i in 0..<n:    for j in 0..<n:       block inner:        let pos: Position = (i, j)        for queen in blackQueens:          if queen == pos or not placingBlack and queen.isAttacking(pos):            break inner        for queen in whiteQueens:          if queen == pos or placingBlack and queen.isAttacking(pos):            break inner         if placingBlack:          blackQueens.add pos        else:          whiteQueens.add pos          if place(m - 1, n, blackQueens, whiteQueens): return true          discard blackQueens.pop()          discard whiteQueens.pop()        placingBlack = not placingBlack   if not placingBlack:    discard blackQueens.pop()  proc printBoard(n: int; blackQueens, whiteQueens: seq[Position]) =   var board = newSeqWith(n, newSeq[Piece](n))   # Initialized to Empty.   for queen in blackQueens:    board[queen.x][queen.y] = Black  for queen in whiteQueens:    board[queen.x][queen.y] = White   for i in 0..<n:    for j in 0..<n:      stdout.write case board[i][j]                   of Black: "B "                   of White: "W "                   of Empty: (if (i and 1) == (j and 1): "• " else: "◦ ")    stdout.write '\n'   echo ""  const Nms = [(2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3),             (5, 1), (5, 2), (5, 3), (5, 4), (5, 5),             (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6),             (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)] for (n, m) in Nms:  echo &"{m} black and {m} white queens on a {n} x {n} board:"  var blackQueens, whiteQueens: seq[Position]  if place(m, n, blackQueens, whiteQueens):    printBoard(n, blackQueens, whiteQueens)  else:    echo "No solution exists.\n"`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B ◦ •
◦ • W
• ◦ •

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B ◦ • ◦
◦ • W •
• ◦ • ◦
◦ • ◦ •

2 black and 2 white queens on a 4 x 4 board:
B ◦ • ◦
◦ • W •
B ◦ • ◦
◦ • W •

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • W • ◦
• ◦ • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

2 black and 2 white queens on a 5 x 5 board:
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

3 black and 3 white queens on a 5 x 5 board:
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ B ◦
• W • ◦ •

4 black and 4 white queens on a 5 x 5 board:
• B • B •
◦ • ◦ • B
W ◦ W ◦ •
◦ • ◦ • B
W ◦ W ◦ •

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

2 black and 2 white queens on a 6 x 6 board:
B ◦ • ◦ B ◦
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

3 black and 3 white queens on a 6 x 6 board:
B ◦ • ◦ B B
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ W ◦ • ◦
◦ • ◦ • ◦ •

4 black and 4 white queens on a 6 x 6 board:
B ◦ • ◦ B B
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ B
• ◦ W W • ◦
◦ • ◦ • ◦ •

5 black and 5 white queens on a 6 x 6 board:
• B • ◦ B ◦
◦ • ◦ B ◦ B
W ◦ • ◦ • ◦
W • W • ◦ •
• ◦ • ◦ • B
W • W • ◦ •

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

2 black and 2 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

3 black and 3 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

4 black and 4 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

5 black and 5 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •

6 black and 6 white queens on a 7 x 7 board:
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •

7 black and 7 white queens on a 7 x 7 board:
• B • ◦ • B •
◦ B ◦ • B • ◦
• B • ◦ • B •
◦ • ◦ • B • ◦
W ◦ W ◦ • ◦ W
◦ • ◦ W ◦ • ◦
W ◦ W W • ◦ •
```

## Perl

### Terse

`use strict;use warnings; my \$m = shift // 4;my \$n = shift // 5;my %seen;my \$gaps = join '|', qr/-*/, map qr/.{\$_}(?:-.{\$_})*/s, \$n-1, \$n, \$n+1;my \$attack = qr/(\w)(?:\$gaps)(?!\1)\w/; place( scalar ('-' x \$n . "\n") x \$n );print "No solution to \$m \$n\n"; sub place  {  local \$_ = shift;  \$seen{\$_}++ || /\$attack/ and return; # previously or attack  (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  }`
Output:
```Solution to 4 5

W---W
--B--
-B-B-
--B--
W---W```

### Verbose

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

`use strict;use warnings;use feature 'say';use feature 'state';use utf8;binmode(STDOUT, ':utf8'); # recursively place the next queensub place {    my(\$board, \$n, \$m, \$empty_square) = @_;    state(%seen,\$attack,\$solution);     # logic of 'attack' regex: queen ( ... paths between queens containing only empty squares ... ) queen of other color    unless (\$attack) {      \$attack =        '([WB])' .      # 1st queen        '(?:' .            join('|',                "[\$empty_square]*",                map {                    "(?^s:.{\$_}(?:[\$empty_square].{\$_})*)"                } \$n-1, \$n, \$n+1            ) .        ')' .        '(?!\1)[WB]';   # 2nd queen    }     # pass first result found back up the stack (omit this line to get last result found)    return \$solution if \$solution;     # bail out if seen this configuration previously, or attack detected    return if \$seen{\$board}++ or \$board =~ /\$attack/;     # success if queen count is m×2    \$solution = \$board and return if \$m * 2 == (my \$have = \$board =~ tr/WB//);     # place the next queen (alternating colors each time)    place(   \$board =~ s/[\$empty_square]\G/ qw<W B>[\$have % 2] /er, \$n, \$m, \$empty_square )        while \$board =~  /[\$empty_square]/g;     return \$solution} my(\$m, \$n) = \$#ARGV == 1 ? @ARGV : (4, 5);my \$empty_square = '◦•';my \$board = join "\n", map { substr \$empty_square x \$n, \$_%2, \$n } 1..\$n; my \$solution = place \$board, \$n, \$m, \$empty_square; say \$solution    ? sprintf "Solution to \$m \$n\n\n%s", map { s/(.)/\$1 /gm; s/B /♛/gm; s/W /♕/gmr } \$solution    : "No solution to \$m \$n";`
Output:
```Solution to 4 5

♕◦ • ◦ ♕
◦ • ♛• ◦
• ♛• ♛•
◦ • ♛• ◦
♕◦ • ◦ ♕```

## Phix

Translation of: Go
Translation of: Python
`-- demo\rosetta\Queen_Armies.exwstring html = ""constant as_html = trueconstant queens = {``,                   `&#x265b;`,                    `<font color="green">&#x2655;</font>`,                   `<span style="color:red">?</span>`} procedure showboard(integer n, sequence blackqueens, whitequeens)    sequence board = repeat(repeat('-',n),n)    for i=1 to length(blackqueens) do        integer {qi,qj} = blackqueens[i]        board[qi,qj] = 'B'        {qi,qj} = whitequeens[i]        board[qi,qj] = 'W'    end for    if as_html then        string out = sprintf("<br><b>## %d black and %d white queens on a %d-by-%d board</b><br>\n",                             {length(blackqueens),length(whitequeens),n,n}),               tbl = ""        out &= "<table style=\"font-weight:bold\">\n  "        for x=1 to n do            for y=1 to n do                if y=1 then tbl &= "  </tr>\n  <tr valign=\"middle\" align=\"center\">\n" end if                integer xw = find({x,y},blackqueens)!=0,                        xb = find({x,y},whitequeens)!=0,                        dx = xw+xb*2+1                string ch = queens[dx],                       bg = iff(mod(x+y,2)?"":` bgcolor="silver"`)                tbl &= sprintf("    <td style=\"width:14pt; height:14pt;\"%s>%s</td>\n",{bg,ch})            end for        end for        out &= tbl[11..\$]        out &= "  </tr>\n</table>\n<br>\n"        html &= out    else        integer b = length(blackqueens),                w = length(whitequeens)        printf(1,"%d black and %d white queens on a %d x %d board:\n", {b, w, n, n})        puts(1,join(board,"\n")&"\n")--      ?{n,blackqueens, whitequeens}    end ifend procedure  function isAttacking(sequence queen, pos)    integer {qi,qj} = queen, {pi,pj} = pos    return qi=pi or qj=pj or abs(qi-pi)=abs(qj-pj)end function function place(integer m, n, sequence blackqueens = {}, whitequeens = {})    if m == 0 then showboard(n,blackqueens,whitequeens) return true end if    bool placingBlack := true    for i=1 to n do        for j=1 to n do            sequence pos := {i, j}            for q=1 to length(blackqueens) do                sequence queen := blackqueens[q]                if queen == pos or ((not placingBlack) and isAttacking(queen, pos)) then                    pos = {}                    exit                end if            end for            if pos!={} then                for q=1 to length(whitequeens) do                    sequence queen := whitequeens[q]                    if queen == pos or (placingBlack and isAttacking(queen, pos)) then                        pos = {}                        exit                    end if                end for                if pos!={} then                    if placingBlack then                        blackqueens = append(blackqueens, pos)                        placingBlack = false                    else                        whitequeens = append(whitequeens, pos)                        if place(m-1, n, blackqueens, whitequeens) then return true end if                        blackqueens = blackqueens[1..\$-1]                        whitequeens = whitequeens[1..\$-1]                        placingBlack = true                    end if                end if            end if        end for    end for    return falseend function for n=2 to 7 do    for m=1 to n-(n<5) do        if not place(m,n) then            string no = sprintf("Cannot place %d+ queen armies on a %d-by-%d board",{m,n,n})            if as_html then                html &= sprintf("<b># %s</b><br><br>\n\n",{no})            else                printf(1,"%s.\n", {no})            end if        end if    end forend for constant html_header = """<!DOCTYPE html><html lang="en"> <head>  <meta charset="utf-8" />  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />  <title>Rosettacode Rank Languages by popularity</title> </head> <body>  <h2>queen armies</h2>""", -- or <div style="overflow:scroll; height:250px;">         html_footer = """ </body></html>""" -- or </div> if as_html then    integer fn = open("queen_armies.html","w")    puts(fn,html_header)    puts(fn,html)    puts(fn,html_footer)    close(fn)    printf(1,"See queen_armies.html\n")end if ?"done"{} = wait_key()`
Output:

with as_html = false

```Cannot place 1+ queen armies on a 2-by-2 board.
1 black and 1 white queens on a 3 x 3 board:
B--
--W
---
Cannot place 2+ queen armies on a 3-by-3 board.
<snip>
7 black and 7 white queens on a 7 x 7 board:
-B---B-
-B--B--
-B---B-
----B--
W-W---W
---W---
W-WW---
```
Output:

with as_html = true

# Cannot place 1+ queen armies on a 2-by-2 board

## 1 black and 1 white queens on a 3-by-3 board

 ♛ ♕

# Cannot place 2+ queen armies on a 3-by-3 board

<snip>

## 7 black and 7 white queens on a 7-by-7 board

 ♛ ♛ ♛ ♛ ♛ ♛ ♛ ♕ ♕ ♕ ♕ ♕ ♕ ♕

## Python

### Python: Textual output

`from itertools import combinations, product, countfrom functools import lru_cache, reduce  _bbullet, _wbullet = '\u2022\u25E6'_or = set.__or__ def place(m, n):    "Place m black and white queens, peacefully, on an n-by-n board"    board = set(product(range(n), repeat=2))  # (x, y) tuples    placements = {frozenset(c) for c in combinations(board, m)}    for blacks in placements:        black_attacks = reduce(_or,                                (queen_attacks_from(pos, n) for pos in blacks),                                set())        for whites in {frozenset(c)     # Never on blsck attacking squares                       for c in combinations(board - black_attacks, m)}:            if not black_attacks & whites:                return blacks, whites    return set(), set() @lru_cache(maxsize=None)def queen_attacks_from(pos, n):    x0, y0 = pos    a = set([pos])    # Its position    a.update((x, y0) for x in range(n))    # Its row    a.update((x0, y) for y in range(n))    # Its column    # Diagonals    for x1 in range(n):        # l-to-r diag        y1 = y0 -x0 +x1        if 0 <= y1 < n:             a.add((x1, y1))        # r-to-l diag        y1 = y0 +x0 -x1        if 0 <= y1 < n:             a.add((x1, y1))    return a def pboard(black_white, n):    "Print board"    if black_white is None:         blk, wht = set(), set()    else:        blk, wht = black_white    print(f"## {len(blk)} black and {len(wht)} white queens "          f"on a {n}-by-{n} board:", end='')    for x, y in product(range(n), repeat=2):        if y == 0:            print()        xy = (x, y)        ch = ('?' if xy in blk and xy in wht               else 'B' if xy in blk              else 'W' if xy in wht              else _bbullet if (x + y)%2 else _wbullet)        print('%s' % ch, end='')    print() if __name__ == '__main__':    n=2    for n in range(2, 7):        print()        for m in count(1):            ans = place(m, n)            if ans[0]:                pboard(ans, n)            else:                print (f"# Can't place {m} queens on a {n}-by-{n} board")                break    #    print('\n')    m, n = 5, 7    ans = place(m, n)    pboard(ans, n)`
Output:
```# Can't place 1 queens on a 2-by-2 board

## 1 black and 1 white queens on a 3-by-3 board:
◦•◦
B◦•
◦•W
# Can't place 2 queens on a 3-by-3 board

## 1 black and 1 white queens on a 4-by-4 board:
◦•W•
B◦•◦
◦•◦•
•◦•◦
## 2 black and 2 white queens on a 4-by-4 board:
◦B◦•
•B•◦
◦•◦•
W◦W◦
# Can't place 3 queens on a 4-by-4 board

## 1 black and 1 white queens on a 5-by-5 board:
◦•◦•◦
W◦•◦•
◦•◦•◦
•◦•◦B
◦•◦•◦
## 2 black and 2 white queens on a 5-by-5 board:
◦•◦•W
•◦B◦•
◦•◦•◦
•◦•B•
◦W◦•◦
## 3 black and 3 white queens on a 5-by-5 board:
◦W◦•◦
•◦•◦W
B•B•◦
B◦•◦•
◦•◦W◦
## 4 black and 4 white queens on a 5-by-5 board:
◦•B•B
W◦•◦•
◦W◦W◦
W◦•◦•
◦•B•B
# Can't place 5 queens on a 5-by-5 board

## 1 black and 1 white queens on a 6-by-6 board:
◦•◦•◦•
W◦•◦•◦
◦•◦•◦•
•◦•◦B◦
◦•◦•◦•
•◦•◦•◦
## 2 black and 2 white queens on a 6-by-6 board:
◦•◦•◦•
•◦B◦•◦
◦•◦•◦•
•◦•B•◦
◦•◦•◦•
W◦•◦W◦
## 3 black and 3 white queens on a 6-by-6 board:
◦•B•◦•
•B•◦•◦
◦•◦W◦W
•◦•◦•◦
W•◦•◦•
•◦•◦B◦
## 4 black and 4 white queens on a 6-by-6 board:
WW◦•W•
•W•◦•◦
◦•◦•◦B
•◦B◦•◦
◦•◦B◦•
•◦•B•◦
## 5 black and 5 white queens on a 6-by-6 board:
◦•W•W•
B◦•◦•◦
◦•W•◦W
B◦•◦•◦
◦•◦•◦W
BB•B•◦
# Can't place 6 queens on a 6-by-6 board

## 5 black and 5 white queens on a 7-by-7 board:
◦•◦•B•◦
•W•◦•◦W
◦•◦•B•◦
B◦•◦•◦•
◦•B•◦•◦
•◦•B•◦•
◦W◦•◦WW```

### Python: HTML output

Uses the solver function `place` from the above textual output case.

`from peaceful_queen_armies_simpler import placefrom itertools import product, count _bqueenh, _wqueenh = '&#x265b;', '<font color="green">&#x2655;</font>' def hboard(black_white, n):    "HTML board generator"    if black_white is None:         blk, wht = set(), set()    else:        blk, wht = black_white    out = (f"<br><b>## {len(blk)} black and {len(wht)} white queens "           f"on a {n}-by-{n} board</b><br>\n")    out += '<table style="font-weight:bold">\n  '    tbl = ''    for x, y in product(range(n), repeat=2):        if y == 0:            tbl += '  </tr>\n  <tr valign="middle" align="center">\n'        xy = (x, y)        ch = ('<span style="color:red">?</span>' if xy in blk and xy in wht               else _bqueenh if xy in blk              else _wqueenh if xy in wht              else "")        bg = "" if (x + y)%2 else ' bgcolor="silver"'        tbl += f'    <td style="width:14pt; height:14pt;"{bg}>{ch}</td>\n'    out += tbl[7:]    out += '  </tr>\n</table>\n<br>\n'    return out if __name__ == '__main__':    n=2    html = ''    for n in range(2, 7):        print()        for m in count(1):            ans = place(m, n)            if ans[0]:                html += hboard(ans, n)            else:                html += (f"<b># Can't place {m} queen armies on a "                         f"{n}-by-{n} board</b><br><br>\n\n" )                break    #    html += '<br>\n'    m, n = 6, 7    ans = place(m, n)    html += hboard(ans, n)    with open('peaceful_queen_armies.htm', 'w') as f:        f.write(html)`
Output:

# Can't place 1 queen armies on a 2-by-2 board

## 1 black and 1 white queens on a 3-by-3 board

 ♛ ♕

# Can't place 2 queen armies on a 3-by-3 board

## 1 black and 1 white queens on a 4-by-4 board

 ♕ ♛

## 2 black and 2 white queens on a 4-by-4 board

 ♛ ♛ ♕ ♕

# Can't place 3 queen armies on a 4-by-4 board

## 1 black and 1 white queens on a 5-by-5 board

 ♕ ♛

## 2 black and 2 white queens on a 5-by-5 board

 ♕ ♛ ♛ ♕

## 3 black and 3 white queens on a 5-by-5 board

 ♕ ♕ ♛ ♛ ♛ ♕

## 4 black and 4 white queens on a 5-by-5 board

 ♛ ♛ ♕ ♕ ♕ ♕ ♛ ♛

# Can't place 5 queen armies on a 5-by-5 board

## 1 black and 1 white queens on a 6-by-6 board

 ♕ ♛

## 2 black and 2 white queens on a 6-by-6 board

 ♛ ♛ ♕ ♕

## 3 black and 3 white queens on a 6-by-6 board

 ♛ ♛ ♕ ♕ ♕ ♛

## 4 black and 4 white queens on a 6-by-6 board

 ♕ ♕ ♕ ♕ ♛ ♛ ♛ ♛

## 5 black and 5 white queens on a 6-by-6 board

 ♕ ♕ ♛ ♕ ♕ ♛ ♕ ♛ ♛ ♛

# Can't place 6 queen armies on a 6-by-6 board

## 6 black and 6 white queens on a 7-by-7 board

 ♛ ♛ ♕ ♕ ♕ ♕ ♕ ♛ ♛ ♕ ♛ ♛

## Raku

(formerly Perl 6)

Translation of: Perl
`# recursively place the next queensub place (\$board, \$n, \$m, \$empty-square) {    my \$cnt;    state (%seen,\$attack);    state \$solution = False;     # logic of regex: queen ( ... paths between queens containing only empty squares ... ) queen of other color    once {      my %Q = 'WBBW'.comb; # return the queen of alternate color      my \$re =        '(<[WB]>)' ~                # 1st queen        '[' ~          join(' |',            qq/<[\$empty-square]>*/,            map {              qq/ . ** {\$_}[<[\$empty-square]> . ** {\$_}]*/            }, \$n-1, \$n, \$n+1          ) ~        ']' ~        '<{%Q{\$0}}>';               # 2nd queen      \$attack = "rx/\$re/".EVAL;    }     # return first result found (omit this line to get last result found)    return \$solution if \$solution;     # bail out if seen this configuration previously, or attack detected    return if %seen{\$board}++ or \$board ~~ \$attack;     # success if queen count is m×2, set state variable and return from recursion    \$solution = \$board and return if \$m * 2 == my \$queens = \$board.comb.Bag{<W B>}.sum;     # place the next queen (alternating colors each time)    place( \$board.subst( /<[◦•]>/, {<W B>[\$queens % 2]}, :nth(\$cnt) ), \$n, \$m, \$empty-square )        while \$board ~~ m:nth(++\$cnt)/<[◦•]>/;     return \$solution} my (\$m, \$n) = @*ARGS == 2 ?? @*ARGS !! (4, 5);my \$empty-square = '◦•';my \$board = (\$empty-square x \$n**2).comb.rotor(\$n)>>.join[^\$n].join: "\n"; my \$solution = place \$board, \$n, \$m, \$empty-square; say \$solution    ?? "Solution to \$m \$n\n\n{S:g/(\N)/\$0 / with \$solution}"    !! "No solution to \$m \$n";`
Output:
```W • ◦ • W
• ◦ B ◦ •
◦ B ◦ B ◦
• ◦ B ◦ •
W • ◦ • W```

## Ruby

Translation of: Java
`class Position    attr_reader :x, :y     def initialize(x, y)        @x = x        @y = y    end     def ==(other)        self.x == other.x &&        self.y == other.y    end     def to_s        '(%d, %d)' % [@x, @y]    end     def to_str        to_s    endend def isAttacking(queen, pos)    return queen.x == pos.x ||           queen.y == pos.y ||           (queen.x - pos.x).abs() == (queen.y - pos.y).abs()end def place(m, n, blackQueens, whiteQueens)    if m == 0 then        return true    end    placingBlack = true    for i in 0 .. n-1        for j in 0 .. n-1            catch :inner do                pos = Position.new(i, j)                for queen in blackQueens                    if pos == queen || !placingBlack && isAttacking(queen, pos) then                        throw :inner                    end                end                for queen in whiteQueens                    if pos == queen || placingBlack && isAttacking(queen, pos) then                        throw :inner                    end                end                if placingBlack then                    blackQueens << pos                    placingBlack = false                else                    whiteQueens << pos                    if place(m - 1, n, blackQueens, whiteQueens) then                        return true                    end                    blackQueens.pop                    whiteQueens.pop                    placingBlack = true                end            end        end    end    if !placingBlack then        blackQueens.pop    end    return falseend def printBoard(n, blackQueens, whiteQueens)    # initialize the board    board = Array.new(n) { Array.new(n) { ' ' } }    for i in 0 .. n-1        for j in 0 .. n-1            if i % 2 == j % 2 then                board[i][j] = '•'            else                board[i][j] = '◦'            end        end    end     # insert the queens    for queen in blackQueens        board[queen.y][queen.x] = 'B'    end    for queen in whiteQueens        board[queen.y][queen.x] = 'W'    end     # print the board    for row in board        for cell in row            print cell, ' '        end        print "\n"    end    print "\n"end nms = [    [2, 1],    [3, 1], [3, 2],    [4, 1], [4, 2], [4, 3],    [5, 1], [5, 2], [5, 3], [5, 4], [5, 5],    [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6],    [7, 1], [7, 2], [7, 3], [7, 4], [7, 5], [7, 6], [7, 7]]for nm in nms    m = nm[1]    n = nm[0]    print "%d black and %d white queens on a %d x %d board:\n" % [m, m, n, n]     blackQueens = []    whiteQueens = []    if place(m, n, blackQueens, whiteQueens) then        printBoard(n, blackQueens, whiteQueens)    else        print "No solution exists.\n\n"    endend`
Output:
```1 black and 1 white queens on a 2 x 2 board:
No solution exists.

1 black and 1 white queens on a 3 x 3 board:
B ◦ •
◦ • ◦
• W •

2 black and 2 white queens on a 3 x 3 board:
No solution exists.

1 black and 1 white queens on a 4 x 4 board:
B ◦ • ◦
◦ • ◦ •
• W • ◦
◦ • ◦ •

2 black and 2 white queens on a 4 x 4 board:
B ◦ B ◦
◦ • ◦ •
• W • W
◦ • ◦ •

3 black and 3 white queens on a 4 x 4 board:
No solution exists.

1 black and 1 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • ◦ • ◦
• W • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

2 black and 2 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • W • ◦
• W • ◦ •
◦ • ◦ • ◦
B ◦ • ◦ •

3 black and 3 white queens on a 5 x 5 board:
B ◦ • ◦ •
◦ • W • W
• W • ◦ •
◦ • ◦ B ◦
B ◦ • ◦ •

4 black and 4 white queens on a 5 x 5 board:
• ◦ W ◦ W
B • ◦ • ◦
• ◦ W ◦ W
B • ◦ • ◦
• B • B •

5 black and 5 white queens on a 5 x 5 board:
No solution exists.

1 black and 1 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • ◦ • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

2 black and 2 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
B ◦ • ◦ • ◦
◦ • ◦ • ◦ •

3 black and 3 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• W • ◦ W ◦
◦ • ◦ • ◦ •
B ◦ • ◦ • ◦
B • ◦ • ◦ •

4 black and 4 white queens on a 6 x 6 board:
B ◦ • ◦ • ◦
◦ • W • ◦ •
• W • ◦ W ◦
◦ • ◦ • W •
B ◦ • ◦ • ◦
B • ◦ B ◦ •

5 black and 5 white queens on a 6 x 6 board:
• ◦ W W • W
B • ◦ • ◦ •
• ◦ • W • W
◦ B ◦ • ◦ •
B ◦ • ◦ • ◦
◦ B ◦ • B •

6 black and 6 white queens on a 6 x 6 board:
No solution exists.

1 black and 1 white queens on a 7 x 7 board:
B ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

2 black and 2 white queens on a 7 x 7 board:
B ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
B ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • ◦ • ◦ •

3 black and 3 white queens on a 7 x 7 board:
B ◦ B ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • W • ◦ •
◦ • ◦ • ◦ • ◦
B ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • ◦ • ◦ •

4 black and 4 white queens on a 7 x 7 board:
B ◦ B ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • W • ◦ •
◦ • ◦ • ◦ • ◦
B ◦ B ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • W • ◦ •

5 black and 5 white queens on a 7 x 7 board:
B ◦ B ◦ B ◦ •
◦ • ◦ • ◦ • ◦
• W • W • W •
◦ • ◦ • ◦ • ◦
B ◦ B ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• W • W • ◦ •

6 black and 6 white queens on a 7 x 7 board:
B ◦ B ◦ B ◦ •
◦ • ◦ • ◦ • ◦
• W • W • W •
◦ • ◦ • ◦ • ◦
B ◦ B ◦ B ◦ •
◦ • ◦ • ◦ • ◦
• W • W • W •

7 black and 7 white queens on a 7 x 7 board:
• ◦ • ◦ W ◦ W
B B B • ◦ • ◦
• ◦ • ◦ W ◦ W
◦ • ◦ • ◦ W W
• B • B • ◦ •
B • B • ◦ • ◦
• ◦ • ◦ W ◦ •```

## Swift

Translation of: Kotlin
`enum Piece {  case empty, black, white} typealias Position = (Int, Int) func place(_ m: Int, _ n: Int, pBlackQueens: inout [Position], pWhiteQueens: inout [Position]) -> Bool {  guard m != 0 else {    return true  }   var placingBlack = true   for i in 0..<n {    inner: for j in 0..<n {      let pos = (i, j)       for queen in pBlackQueens where queen == pos || !placingBlack && isAttacking(queen, pos) {        continue inner      }       for queen in pWhiteQueens where queen == pos || placingBlack && isAttacking(queen, pos) {        continue inner      }       if placingBlack {        pBlackQueens.append(pos)        placingBlack = false      } else {        placingBlack = true         pWhiteQueens.append(pos)         if place(m - 1, n, pBlackQueens: &pBlackQueens, pWhiteQueens: &pWhiteQueens) {          return true        } else {          pBlackQueens.removeLast()          pWhiteQueens.removeLast()        }      }    }  }   if !placingBlack {    pBlackQueens.removeLast()  }   return false} func isAttacking(_ queen: Position, _ pos: Position) -> Bool {  queen.0 == pos.0 || queen.1 == pos.1 || abs(queen.0 - pos.0) == abs(queen.1 - pos.1)} func printBoard(n: Int, pBlackQueens: [Position], pWhiteQueens: [Position]) {  var board = Array(repeating: Piece.empty, count: n * n)   for queen in pBlackQueens {    board[queen.0 * n + queen.1] = .black  }   for queen in pWhiteQueens {    board[queen.0 * n + queen.1] = .white  }   for (i, p) in board.enumerated() {    if i != 0 && i % n == 0 {      print()    }     switch p {    case .black:      print("B ", terminator: "")    case .white:      print("W ", terminator: "")    case .empty:      let j = i / n      let k = i - j * n       if j % 2 == k % 2 {        print("• ", terminator: "")      } else {        print("◦ ", terminator: "")      }    }  }   print("\n")} let nms = [  (2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3),  (5, 1), (5, 2), (5, 3), (5, 4), (5, 5),  (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6),  (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)] for (n, m) in nms {  print("\(m) black and white queens on \(n) x \(n) board")   var blackQueens = [Position]()  var whiteQueens = [Position]()   if place(m, n, pBlackQueens: &blackQueens, pWhiteQueens: &whiteQueens) {    printBoard(n: n, pBlackQueens: blackQueens, pWhiteQueens: whiteQueens)  } else {    print("No solution")  }}`
Output:
```1 black and white queens on 2 x 2 board
No solution
1 black and white queens on 3 x 3 board
B ◦ •
◦ • W
• ◦ •

2 black and white queens on 3 x 3 board
No solution
1 black and white queens on 4 x 4 board
B ◦ • ◦
◦ • W •
• ◦ • ◦
◦ • ◦ •

2 black and white queens on 4 x 4 board
B ◦ • ◦
◦ • W •
B ◦ • ◦
◦ • W •

3 black and white queens on 4 x 4 board
No solution
1 black and white queens on 5 x 5 board
B ◦ • ◦ •
◦ • W • ◦
• ◦ • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

2 black and white queens on 5 x 5 board
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ • ◦
• ◦ • ◦ •

3 black and white queens on 5 x 5 board
B ◦ • ◦ B
◦ • W • ◦
• W • ◦ •
◦ • ◦ B ◦
• W • ◦ •

4 black and white queens on 5 x 5 board
• B • B •
◦ • ◦ • B
W ◦ W ◦ •
◦ • ◦ • B
W ◦ W ◦ •

5 black and white queens on 5 x 5 board
No solution
1 black and white queens on 6 x 6 board
B ◦ • ◦ • ◦
◦ • W • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

2 black and white queens on 6 x 6 board
B ◦ • ◦ B ◦
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ • ◦ • ◦
◦ • ◦ • ◦ •

3 black and white queens on 6 x 6 board
B ◦ • ◦ B B
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ •
• ◦ W ◦ • ◦
◦ • ◦ • ◦ •

4 black and white queens on 6 x 6 board
B ◦ • ◦ B B
◦ • W • ◦ •
• W • ◦ • ◦
◦ • ◦ • ◦ B
• ◦ W W • ◦
◦ • ◦ • ◦ •

5 black and white queens on 6 x 6 board
• B • ◦ B ◦
◦ • ◦ B ◦ B
W ◦ • ◦ • ◦
W • W • ◦ •
• ◦ • ◦ • B
W • W • ◦ •

6 black and white queens on 6 x 6 board
No solution
1 black and white queens on 7 x 7 board
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

2 black and white queens on 7 x 7 board
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

3 black and white queens on 7 x 7 board
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

4 black and white queens on 7 x 7 board
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •
◦ • ◦ • ◦ • ◦
• ◦ • ◦ • ◦ •

5 black and white queens on 7 x 7 board
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ • ◦ •
◦ • W • ◦ • ◦
• ◦ • ◦ • ◦ •

6 black and white queens on 7 x 7 board
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
B ◦ • ◦ B ◦ •
◦ • W • ◦ • W
• ◦ • ◦ • ◦ •

7 black and white queens on 7 x 7 board
• B • ◦ • B •
◦ B ◦ • B • ◦
• B • ◦ • B •
◦ • ◦ • B • ◦
W ◦ W ◦ • ◦ W
◦ • ◦ W ◦ • ◦
W ◦ W W • ◦ •```

## Wren

Translation of: Kotlin
Library: Wren-dynamic
`import "/dynamic" for Enum, Tuple var Piece = Enum.create("Piece", ["empty", "black", "white"]) var Pos = Tuple.create("Pos", ["x", "y"]) var isAttacking = Fn.new { |q, pos|    return q.x == pos.x || q.y == pos.y || (q.x - pos.x).abs == (q.y - pos.y).abs} var place // recursiveplace = Fn.new { |m, n, blackQueens, whiteQueens|    if (m == 0) return true    var placingBlack = true    for (i in 0...n) {                for (j in 0...n) {            var pos = Pos.new(i, j)            var inner = false            for (queen in blackQueens) {                var equalPos = queen.x == pos.x && queen.y == pos.y                if (equalPos || !placingBlack && isAttacking.call(queen, pos)) {                    inner = true                    break                }            }            if (!inner) {                for (queen in whiteQueens) {                    var equalPos = queen.x == pos.x && queen.y == pos.y                    if (equalPos || placingBlack && isAttacking.call(queen, pos)) {                        inner = true                        break                    }                }                if (!inner) {                    if (placingBlack) {                        blackQueens.add(pos)                        placingBlack = false                    } else {                        whiteQueens.add(pos)                        if (place.call(m-1, n, blackQueens, whiteQueens)) return true                        blackQueens.removeAt(-1)                        whiteQueens.removeAt(-1)                        placingBlack = true                    }                }            }        }    }    if (!placingBlack) blackQueens.removeAt(-1)    return false} var printBoard = Fn.new { |n, blackQueens, whiteQueens|    var board = List.filled(n * n, 0)    for (queen in blackQueens) board[queen.x * n + queen.y] = Piece.black    for (queen in whiteQueens) board[queen.x * n + queen.y] = Piece.white    var i = 0    for (b in board) {        if (i != 0 && i%n == 0) System.print()        if (b == Piece.black) {            System.write("B ")        } else if (b == Piece.white) {            System.write("W ")        } else {            var j = (i/n).floor            var k = i - j*n            if (j%2 == k%2) {                System.write("• ")            } else {                System.write("◦ ")            }        }        i = i + 1    }    System.print("\n")} var nms = [    Pos.new(2, 1), Pos.new(3, 1), Pos.new(3, 2), Pos.new(4, 1), Pos.new(4, 2), Pos.new(4, 3),    Pos.new(5, 1), Pos.new(5, 2), Pos.new(5, 3), Pos.new(5, 4), Pos.new(5, 5),    Pos.new(6, 1), Pos.new(6, 2), Pos.new(6, 3), Pos.new(6, 4), Pos.new(6, 5), Pos.new(6, 6),    Pos.new(7, 1), Pos.new(7, 2), Pos.new(7, 3), Pos.new(7, 4), Pos.new(7, 5), Pos.new(7, 6), Pos.new(7, 7)]for (p in nms) {    System.print("%(p.y) black and %(p.y) white queens on a %(p.x) x %(p.x) board:")    var blackQueens = []    var whiteQueens = []    if (place.call(p.y, p.x, blackQueens, whiteQueens)) {        printBoard.call(p.x, blackQueens, whiteQueens)    } else {        System.print("No solution exists.\n")    }}`
Output:
```Same as Kotlin entry.
```

## zkl

`fcn isAttacked(q, x,y) // ( (r,c), x,y ) : is queen at r,c attacked by [email protected](x,y)?   { 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)..)   { ( not qs.filter1(isAttacked,r,c) ) }fcn isEmpty(r,c,qs){ (not (qs and qs.filter1('wrap([(x,y)]){ r==x and c==y })) ) }fcn _peacefulQueens(N,M,qa,qb){  //--> False | (True,((r,c)..),((r,c)..) )   // qa,qb -->  // ( (r,c),(r,c).. ), solution so far to last good spot   if(qa.len()==M==qb.len()) return(True,qa,qb);   n, x,y := N, 0,0;   if(qa) x,y = qa[-1]; else n=(N+1)/2;  // first queen, first quadrant only   foreach r in ([x..n-1]){      foreach c in ([y..n-1]){	 if(isEmpty(r,c,qa) and isSafe(r,c,qb)){	    qc,qd := qa.append(T(r,c)), self.fcn(N,M, qb,qc);	    if(qd) return( if(qd[0]==True) qd else T(qc,qd) );	 }      }      y=0   }   False} fcn peacefulQueens(N=5,M=4){ # NxN board, M white and black queens   qs:=_peacefulQueens(N,M, T,T);   println("Solution for %dx%d board with %d black and %d white queens:".fmt(N,N,M,M));   if(not qs)println("None");   else{      z:=Data(Void,"-"*N*N);      foreach r,c in (qs[1]){ z[r*N + c]="W" }      foreach r,c in (qs[2]){ z[r*N + c]="B" }      z.text.pump(Void,T(Void.Read,N-1),"println");   }   }`
`peacefulQueens();foreach n in ([4..10]){ peacefulQueens(n,n) }`
Output:
```Solution for 5x5 board with 4 black and 4 white queens:
W---W
--B--
-B-B-
--B--
W---W
Solution for 4x4 board with 4 black and 4 white queens:
None
Solution for 5x5 board with 5 black and 5 white queens:
None
Solution for 6x6 board with 6 black and 6 white queens:
None
Solution for 7x7 board with 7 black and 7 white queens:
W---W-W
--B----
-B-B-B-
--B----
W-----W
--BB---
W-----W
Solution for 8x8 board with 8 black and 8 white queens:
W---W---
--B---BB
W---W---
--B---B-
---B---B
-W---W--
W---W---
--B-----
Solution for 9x9 board with 9 black and 9 white queens:
W---W---W
--B---B--
-B---B---
---W---W-
-B---B---
---W---W-
-B---B---
---W---W-
-B-------
Solution for 10x10 board with 10 black and 10 white queens:
W---W---WW
--B---B---
-B-B------
-----W-W-W
-BBB------
-----W-W-W
-B--------
------B---
---B------
----------
```