# From Linear Array to Row/Column A chessboard is a gird, traditionally eight-by-eight squares for 64 positions. This game matrix can be implemented in code in a variety of ways, with a two-dimensional array being the most obvious. But this option isn’t what I chose when programming how a knight moves (from last week’s Lesson).

Trust me, I did a lot of trial and error.

At first I decided to eschew using a specific data structure for the chessboard. Instead, I would store the knight’s position in a structure, similar to the `position` structure from last week’s Lesson:

```struct position {     int row;     int col; };```

This structure would be filled with random values and bandied about various functions that manipulate the knight and plot where it can move. I wrote a lot of code around this approach — but it was clumsy and I grew annoyed and unhappy.

A two-dimensional array seems obvious, but it also adds some complexity I didn’t want to deal with. After all, a 2D array in C is really a one-dimensional array all gussied up. Even so, I abandoned both the structure and 2D array approaches and instead use a single integer value to represent the knight’s position based on the chessboard’s size.

To allow for a chessboard of varying size (one thing math geeks like to play with), I use the defined constant `SIZE` to set the matrix. Yet, I still need to know the row and column where a piece sits to calculate its potential moves. Therefore some translation is required.

The following code plows through all 64 (or `SIZE*SIZE`) possible locations on a chessboard, using two statements that report each square’s row and column position for the given grid size.

### 2022_11_05-Lesson-a.c

```#include <stdio.h>

#define SIZE 8

int main()
{
int square,row,column;

for( square=0; square<SIZE*SIZE; square++ )
{
/* calculate row and column */
column = square % SIZE;
row = (square-column)/SIZE;
printf("%d:%d ",row,column);
if( column==SIZE-1 )
putchar('\n');
}

return(0);
}```

The for loop processes each of the “squares” in the matrix. based on values from 0 through the matrix size (`SIZE*SIZE`). Line 12 calculates the column first, which is the square‘s value modulo `SIZE`. This value helps Line 13 find the row number: subtracting the column offset from the square value, then dividing by constant `SIZE`.

Line 15 adds a newline after each row of grid pairs is output:

```0:0 0:1 0:2 0:3 0:4 0:5 0:6 0:7 1:0 1:1 1:2 1:3 1:4 1:5 1:6 1:7 2:0 2:1 2:2 2:3 2:4 2:5 2:6 2:7 3:0 3:1 3:2 3:3 3:4 3:5 3:6 3:7 4:0 4:1 4:2 4:3 4:4 4:5 4:6 4:7 5:0 5:1 5:2 5:3 5:4 5:5 5:6 5:7 6:0 6:1 6:2 6:3 6:4 6:5 6:6 6:7 7:0 7:1 7:2 7:3 7:4 7:5 7:6 7:7```

This output represents the chessboard matrix as a series of row:column pairs, successfully translating sequential values zero through 63. The code confirms that I’m able to extract row/column pairs based on linear values.

My next task in building a program to plot how a knight moves is to set a virtual knight on the chessboard at a random position and report the position.

### 2022_11_05-Lesson-b.c

```#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define SIZE 8

int main()
{
int knight,row,column;

/* seed the randomizer */
srand( (unsigned)time(NULL) );

/* pick a random square */
knight = rand() % (SIZE*SIZE);
printf("The knight is at square %d\n",knight);

/* calculate row and column */
column = knight % SIZE;
row = (knight-column)/SIZE;
printf("That's row %d, column %d\n",row,column);

return(0);
}```

Position for variable knight is assigned at Line 15, a random value from zero to 63 inclusive. This value is reported (output) at Line 16. Then Lines 19 and 20 extract the row and column values. Here’s a sample run:

```The knight is at square 47 That's row 5, column 7```

This code represents the typical testing I do when I attempt a complex project like calculating where a knight can move on a chessboard.

The next step is to combine the solution from this month’s Exercise, so that the knight’s position is output in the color-coded chessboard on the text screen. This task is covered in next week’s Lesson.