Ever since I was a little boy and coded my first nested loop, I’ve enjoyed messing with grids in C. I’ve done monthly calendars in grids, rotated grids, manipulated grids mathematically — all sorts of fun girddy stuff. But I’m not done yet.
\n
\nPopulating a grid randomly fascinates me. I look for patterns in the randomness. To sate this desire, I wrote the program below. It outputs a two-dimensional array randomly populated with asterisks.<\/p>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <time.h>\r\n\r\n#define ROWS 16\r\n#define COLS ROWS*2\r\n#define PROB 5\r\n\r\nint main()\r\n{\r\n char grid[ROWS][COLS];\r\n int row,col;\r\n\r\n \/* seed the randomizer *\/<\/span>\r\n srand( (unsigned)time(NULL) );\r\n\r\n \/* fill the grid *\/<\/span>\r\n for( row=0; row<ROWS; row++ )\r\n {\r\n for( col=0; col<COLS; col++ )\r\n {\r\n if( rand() % PROB )\r\n grid[row][col] = '.';\r\n else\r\n grid[row][col] = '*';\r\n putchar(grid[row][col]);\r\n }\r\n putchar('\\n');\r\n }\r\n\r\n return 0;\r\n}<\/pre>\nThree defined constants set two aspects of the grid: its dimensions and the randomness of the asterisks. ROWS<\/code> sets the number rows and COLS<\/code> is set to twice the number of rows, which looks better on the standard text screen. PROB<\/code> sets the probability of a character being an asterisk as opposed to the default period.<\/p>\nNested for<\/em> loops fill the grid. In the inner loop, an if<\/em> statement bases its condition on the return value from the rand()<\/em> function modulo constant PROB<\/code>. For non-zero values (most of them), a period is set in the matrix. Otherwise, an asterisk is set. A putchar()<\/em> function outputs the character set in the grid.<\/p>\nHere’s sample output:<\/p>\n
...*.*......*...*........*...*..
\n................**...*...*..**..
\n.*.....*.*.....*...........*....
\n....**...........*..*...*......*
\n.......*..........*..**....*...*
\n.....*.*.........*......*....*..
\n*..............*..........*.*..*
\n.**.........*.........*..**..*.*
\n*....*........*....*.....*..*...
\n......**...**.....*..........*..
\n.....*......*.*..*..*.....*....*
\n**..*....*.*.....*......***....*
\n..............................*.
\n....*....*.......*..*....*..*...
\n*...........*.....*...*.....*..*
\n.*.......*...*.*......*.....**..<\/code><\/p>\nAdjusting the value of PROB<\/code> increases or decreases the density of the asterisk characters. If I set PROB<\/code> equal to 20, here is the output:<\/p>\n................*...............
\n.....................*..........
\n...........................*....
\n.................*......*.......
\n......................*.........
\n.......*........................
\n...............*................
\n......................*.........
\n*.............*.............*...
\n...........*....................
\n............*.......*...........
\n....*.....................*.....
\n................................
\n....*....................*..*...
\n............*...................
\n.*.............*......*.........<\/code><\/p>\nIf I set it to two, you see this grid:<\/p>\n
.*....**..*.*..*****.*..***....*
\n**...*.*....*.**.*.*.**.***...*.
\n*.*...*.*.*.**.*.*****..*.****.*
\n***..***...*.***.**...*.*.......
\n...*..*.*..**.*...***.*.*.*.*...
\n.***.*.*****.*.....**..*..*.*...
\n..**..*.**...*******...**.*.*.*.
\n**..**.***...**.**..****.*...**.
\n*****.*****.*****..**....*.**...
\n.*...**.*********..*.*.***..***.
\n*..*.....*..*..*.******.*.******
\n..*.***.****...**.**...**.**.*..
\n..*..**.*****.***.******.*...***
\n.**.***..*.....**.**.*..***.***.
\n*****....**.*..*...*.*..*..*....
\n.**....**..*.***..**.**.....*.*.<\/code><\/p>\nI think five is a good value. But going back to my point, what catches my eye in the grid are patterns. What I want to do with the grid is to find rectangles based on coordinates of the asterisks. For example:<\/p>\n
.......*--**---------*--*--*---*
\n....*--*--*----*-*-**---*..|...|
\n*...|..|..**---------|--*..|...|
\n....|*-|*-||-----*-|||*.|..|...|
\n....||*|**||-----*-|*||*|*-|*--*
\n..***--*----*----*-*---*----*--*
\n..|.*-*|--||------**|**-|*-||*..
\n..|.||.|..*|-*---|-|*|||||.|||..
\n..|.||.*--*------------**|-|||*.
\n**|.|*-|---|-----|-|||*|||*||**.
\n..|.|*-|---*--*--*---|--*|-|||*.
\n..|.*--|---|-----*-||*--|--*|||.
\n..*-|*-|---|-*---|-|||-**||||||.
\n....|..*----*------*-*--*||||||.
\n....*------|-----*--*----|-*|*|.
\n....*------*------*------****-*.<\/code><\/p>\nAbove you see output from the final rendition of this program. The program searches for a pair of asterisks that are in the same columns across two rows, which forms a rectangle. Once found, the program draws ASCII lines between the asterisks, setting them in the grid. Above, 79 rectangles are found in the grid. Each rectangle is marked, though you see a lot of overlap.<\/p>\n
Over the next few Lessons, I will modify the base program to scan for, document, and show the various rectangles in the random grid. This task took several generations of coding to accomplish. Many times I’d start down one path, then realize a better way exists. I document all of that, failures and successes, to show you how the final program was concocted.<\/p>\n
In next week’s Lesson<\/a>, I convert the two-dimensional array into pointer notation so that it can be easily passed to various functions. It’s my assumption that perhaps some form of recursion is necessary to accomplish this task. I’ll explain how it works (or not) as the program progresses.<\/p>\n","protected":false},"excerpt":{"rendered":"It’s time for me to sate my grid fascination. Continue reading