How to build a game board [duplicate]

Question

I have - rather lazily - constructed a chessboard like this:

board :=
 With[
  {
   a = Flatten @ Table[{1, 1, 0, 0}, {4}],
   b = Flatten @ Table[{0, 0, 1, 1}, {4}]
   },
  {a, a, b, b, a, a, b, b, a, a, b, b, a, a, b, b}
  ]

board // MatrixForm

letters = 
   Transpose[{Range@15, Style[#, Bold, 16] & /@
     {"a", "", "b", "", "c", "", "d", "", "e", "", "f", "", "g", "", "h"}, Table[{0, 0}, {15}]}];

numbers = 
   Transpose[{Range@15, Style[#, Bold, 16] & /@
     {"8", "", "7", "", "6", "", "5", "", "4", "", "3", "", "2", "", "1"}, Table[{0, 0}, {15}]}];

MatrixPlot[
 board,
 ColorFunction -> "Monochrome",
 ImageSize -> 400,
 Mesh -> {{0, 16}, {0, 16}},
 PlotLabel -> Style["Chessboard\n", 16, Bold],
 FrameTicks -> {{False , numbers}, {letters , False}}]

(a) How could "board" be written in a functional style?

(b) How could such a functional solution be extended to include other boards (like a 10*10 draughtsboard or an odd 11*11 board)?

Clarification

In Mathematica it's not always easy to distinguish functional and "other" styles of programming because the language incorporates many imperative constructs such as Do, Table, Array etc. For the purposes of this question, reliance of such imperative constructs should be avoided to make the answer correspond to a more functional programming paradigm, and thereby to distinguish it from the closely related question How to make a resizable chess board?.

A particular feature of the functional approach is that loops are replaced by recursions.

Answer 1

At least internally, the following is a nice recursive way of thinking about the chess board:

MatrixPlot[CellularAutomaton[250, {0, 1}, {7, 7}]]

Not sure if this is what was meant by functional style. It's hard to make a one-liner functional.

To address extensibility: the dimensions of the board are directly dictated by the argument {7,7}, and the repeating pattern of the board is a consequence of the rule 250 together with an initial condition that has isolated 1s alternating with 0s on the first row. The beauty of cellular automata is of course that they can generate patterns of all sorts of boards, you just have to find the right rule (and starting point). But this difficulty of finding the right initial condition is precisely the tradeoff that you incur when trying to generate a complex result in a functional way. So I think this captures the "philosophy" of functional programming.

Answer 2

This seems much simpler than other answers presented:

Array[Plus, {8, 8}] ~Mod~ 2 // MatrixPlot

---

Attempting to comply with the requirements of the addendum here is a recursive solution:

board[n_] := board[n - 1, {{0}}]

board[n_, a_] := board[n - 1, ArrayFlatten[{{a, #\[Transpose]}, {#, 0}}] &[{1 - Last[a]}]]

board[0, a_] := a

Example:

board[8] // MatrixPlot

Answer 3

Pattern-based functional approach:

pat1 := n_Integer /; n > 1 :> Sequence[n, n - 1 /. pat1];
pat2 := v : List[__Integer] /; Max[v] > 1 :> Sequence[v, v - 1 /. pat2];

cb[n_] := MatrixPlot[
  {{n}} /. pat1 /. pat2,
  ColorFunction -> (GrayLevel@Mod[1 + #, 2] &),
  ColorFunctionScaling -> False,
  PlotRangePadding -> None,
  FrameTicks -> {
    {#, #} &@ Table[{i, n - i + 1, 0}, {i, n}],
    {#, #} &@ Table[{i, FromCharacterCode[ToCharacterCode["a"] + i - 1], 0}, {i, n}]},
  FrameStyle -> Bold]

cb[8]

Answer 4

Expanding eldos approach for even n to all integers > 0:

cb[n_?EvenQ] := 
 MatrixPlot[ArrayPad[DiagonalMatrix[{1, 1}], n/2 - 1, "Reflected"], 
  PlotTheme -> "Monochrome"]
cb[n_?OddQ] := 
 MatrixPlot[Most /@ Most @ ArrayPad[DiagonalMatrix[{1, 1}], (n + 1)/2 - 1, "Reflected"], 
  PlotTheme -> "Monochrome"]

Manipulate[
 cb[n],
 {n, 1, 11, 1}]

Answer 5

This is a functional version of board:

ones = {{1, 1}, {1, 1}};
zeros = {{0, 0}, {0, 0}};
board[n_] := Partition[Riffle[ConstantArray[ones, (n)^2/2], {zeros}], n, n - 1] // ArrayFlatten // Image[#, ImageSize -> 400] &
board[8]

(Defining ones and zeros is optional, so this side effect can be avoided. You will notice also that it only works for even n.)

Answer 6

Is what you mean by a functional solution a solution that uses functions? Or do you mean in the style of functional programming? If the former, then this works:

checked[n_] := Table[Mod[1 + (i + j), 2], {i, 1, n}, {j, 1, n}]
numbers[n_] := Transpose[{Range[1, n], ToString /@ (Reverse@Range[1, n])}]
letters[n_] := Transpose[{Range[1, n], Characters@StringTake["abcdefghijklmnopqrstuvwxyz", n]}]
(* letters needs to know what to do past n = 26. *)

board[n_] := ArrayPlot[checked[n],
  FrameTicks -> {{False, numbers[n]}, {letters[n], False}}
  ]

Then, board[8] produces an image like the one you posted, while board[11] for example, gives an 11 x 11 board. I have used the convention that a8 is always black, but the function checked[n] can be adjusted.

If you really need it in a functional programming style, you could do something like

squareColor = Function[{row, col}, Mod[row + col + 1, 2]]
checked = Function[n, Outer[squareColor, Range[1, n], Range[1, n]]]
board = Function[n, ArrayPlot[checked[n], 
   FrameTicks -> {{False, numbers@n}, {letters@n, False}}]
   ]

where I have left off the implementation of rank and file labeling for this style (but which can be easily redone in a functional style using the implementations above).