A *code-along* is a story about coding in which you are encouraged to “code up” all the examples in the story. In a code-along you should **not** cut-and-paste.

In this code-along we will take a look two different approaches for creating an 8×8 grid of crosses.

## Program 1 – An Arithmetic Algorithm

The program below contains three function declarations: *cross1*, *row*, and *rows*. When called, the function *cross1* will create a cross at a given location whose width and height are three 1-bit bricks. When called, the function *row* creates a row of eight crosses. It accomplishes this in a very direct manner by simply calling *cross1* eight times, each with a different column (i.e., x-value) location. When called, function *rows* constructs an 8×8 grid of crosses. It accomplishes this by leveraging the computation defined in the function *row*. Specifically, *rows* constructs a grid by called the *row* function eight times, each with a different row (i.e., y-value) location.

Note that the bodies of the user-defined functions collectively contain *4+8+8 = 20* function calls. Also note, that extending this approach to construct a 16×16 grid will increase the function calls in each of the bodies of *row* and *rows* by 8. Thus, the collective number of function calls in the bodies of the user-defined functions will total *4+16+16 = 36* when constructing a 16×16 grid.

Note that the coordinate shifting in both the *row* and *rows* functions follows an *arithmetic progression*. For this reason, we refer to this algorithm for creating a grid as an *arithmetic algorithm*.

```
open Level_2;
fun cross1 (x,z) =
(
put2D_2x1_BLUE(x ,z + 1);
put2D_1x1_BLUE(x + 2,z + 1);
put2D_1x1_BLUE(x + 1,z );
put2D_1x1_BLUE(x + 1,z + 2)
);
fun row (x,z) =
(
cross1(x + 0*4,z);
cross1(x + 1*4,z);
cross1(x + 2*4,z);
cross1(x + 3*4,z);
cross1(x + 4*4,z);
cross1(x + 5*4,z);
cross1(x + 6*4,z);
cross1(x + 7*4,z)
);
fun rows (x,z) =
(
row(x,z + 0*4);
row(x,z + 1*4);
row(x,z + 2*4);
row(x,z + 3*4);
row(x,z + 4*4);
row(x,z + 5*4);
row(x,z + 6*4);
row(x,z + 7*4)
);
build2D(64,64);
rows (0,0);
show2D "grid";
```

## Program 2 – A Geometric Algorithm

The program below contains four function declarations: *cross1*, *cross4*, *cross16*, and *cross64*. When called, the function *cross1* will create a cross at a given location whose width and height are three 1-bit bricks.

Note that the bodies of the user-defined functions collectively contain *4+4+4+4 = 16* function calls. Also note, that extending this approach to construct a 16×16 grid will require the declaration of an additional function, called *cross256*. The function *cross256* is similar to the declarations *cross4*, *cross16*, and *cross64*. In particular, it contains four calls to the function *cross16*. In this approach, the collective number of function calls in the bodies of the user-defined functions will total *4+4+4+4+4 = 20* when constructing a 16×16 grid.

Note that the coordinate shifting in the *cross4*, *cross16*, and *cross64* functions follows a *geometric progression*. For this reason, we refer to this algorithm for creating a grid as a *geometric algorithm*.

```
open Level_2;
fun cross1 (x,z) =
(
put2D_2x1_BLUE(x ,z + 1);
put2D_1x1_BLUE(x + 2,z + 1);
put2D_1x1_BLUE(x + 1,z );
put2D_1x1_BLUE(x + 1,z + 2)
);
fun cross4 (x,z) =
(
cross1(x ,z );
cross1(x + 2*2,z );
cross1(x + 2*2,z + 2*2);
cross1(x ,z + 2*2)
);
fun cross16 (x,z) =
(
cross4(x ,z );
cross4(x + 2*2*2,z );
cross4(x + 2*2*2,z + 2*2*2);
cross4(x ,z + 2*2*2)
);
fun cross64 (x,z) =
(
cross16(x ,z );
cross16(x + 2*2*2*2,z );
cross16(x + 2*2*2*2,z + 2*2*2*2);
cross16(x ,z + 2*2*2*2)
);
build2D(64,64);
cross64 (0,0);
show2D "grid";
```