checkerboard.md

From Hardcoded Squares to Flexible Patterns

The humble checkerboard, with its alternating squares of light and dark, holds surprising depth when it comes to programming. Generating this familiar pattern can be tackled in various ways, each showcasing fundamental programming concepts and revealing their strengths and limitations. Let's embark on a journey through code, using the checkerboard as our canvas, to explore these concepts and discover the art of building flexible and efficient solutions.

A simple printf

This section presents the simplest approach to generating a checkerboard pattern using the printf function. Here, we directly print hardcoded strings representing alternating rows of "1"s and "0"s.

#include <stdio.h>

int main(void) {
  printf("10101010\n01010101\n10101010\n01010101\n10101010\n01010101\n10101010\n01010101\n10101010\n01010101\n");
  return 0;
}

Benefits:

• Easy to understand, especially for beginners.
• Requires minimal code.

Drawbacks:

• Inflexible: Modifying the size or pattern involves editing the strings directly, limiting adaptability and reuse.
• Repetitive code: Copy-pasting lines for additional rows increases code size and reduces maintainability.
• Limited control: Each cell is fixed (represented by a single character), and individual formatting or manipulation is impossible.

Separate lines in separate printf

This section builds upon the basic printf approach by printing each row on a separate line. While visually easier to grasp and debug, it still has limitations.

#include <stdio.h>

int main(void) {
  printf("10101010\n");
  printf("01010101\n");
  printf("10101010\n");
  printf("01010101\n");
  printf("10101010\n");
  printf("01010101\n");
  printf("10101010\n");
  printf("01010101\n");
  return 0;
}

Benefits:

• Improved visual clarity compared to the single-line approach.
• Easier to identify potential errors (e.g., extra or missing characters).

Drawbacks:

• Adding columns remains challenging, although adding rows is slightly easier.
• More lines of code, potentially impacting readability.

Extract variables

By introducing variables, we can store the alternating row patterns and improve the code's flexibility and maintainability. This approach eliminates repetitive printing and offers some advantages:

#include <stdio.h>

int main(void) {
  char *row_A = "10101010";
  char *row_B = "01010101";

  printf("%s\n", row_A);
  printf("%s\n", row_B);
  printf("%s\n", row_A);
  printf("%s\n", row_B);
  printf("%s\n", row_A);
  printf("%s\n", row_B);
  printf("%s\n", row_A);
  printf("%s\n", row_B);
  return 0;
}

Benefits:

• Reduces repetition by storing common patterns in variables.
• Modifying the pattern now involves changing the variable content, impacting all instances simultaneously.
• Easier to introduce additional columns by modifying the string length or creating new variables.
• Bugs tend to be localized within the variables, making them easier to identify and fix.

Drawbacks:

• Code is redundant. The same printf occurs multiple times.

Note: The newline character \n is not part of row_A or row_B strings. These variables represent only the alternating pattern, not the newline itself.

A simple loop

This section introduces a loop to automate the printing process, eliminating repetitive printf statements and offering:

#include <stdio.h>

int main(void) {
  char *row_A = "10101010";
  char *row_B = "01010101";
  for (int i = 0; i < 4; i++) {
    printf("%s\n", row_A);
    printf("%s\n", row_B);
  }
  return 0;
}

Benefits:

• Eliminates repetitive printing statements, making the code concise and easier to understand.
• Enables flexible size adjustment by modifying the loop condition or the length of row_A and row_B.

Limitations:

• Currently limited to even numbers of rows due to the loop iterating an even number of times.
• Calculating an arbitrary value of 4 from 8 rows requires additional logic within the loop or by adjusting the loop variable initialization.
• The newline character \n still needs to be addressed either by including it in the strings or adding it during printing using printf formatting options.
• Individual cell manipulation or formatting is not yet possible, as the strings represent complete rows.

Loop with a condition

This section incorporates a conditional statement (if) to overcome the even-row limitation and choose the correct row pattern based on the loop counter's parity (evenness or oddness):

#include <stdio.h>

int main(void) {
  char *row_A = "10101010";
  char *row_B = "01010101";

  for (int i = 0; i < 8; i++) {
    if(i % 2 == 0) {
      printf("%s\n", row_A);
    } else {
      printf("%s\n", row_B);
    }
  }
  return 0;
}

Improvements:

• Odd number of rows: By checking if the loop counter (i) is even or odd, we can print the appropriate row pattern for each iteration, enabling the generation of checkerboards with an odd number of rows.
• More direct relationship with the number of rows: The loop now iterates exactly once for each desired row, making the relationship between the loop and the final pattern more direct and easier to understand.

Drawbacks:

• A condition in the middle of a loop makes it a little harder to read and understand easily.
• It is unclear why we are checking if i is odd or even

Ternary Elegance: Concise Logic for the Win

This section replaces the if statement from the previous approach with a ternary operator, further condensing the code while maintaining the same functionality. The ternary operator acts as a condensed conditional expression, choosing between row_A and row_B based on the row value's parity:

#include <stdio.h>

int main(void) {
  char *row_A = "10101010";
  char *row_B = "01010101";

  for (int row = 0; row < 8; row++) {
    char *row_str = (row % 2 == 0) ? row_A : row_B;
    printf("%s\n", row_str);
  }
  return 0;
}

Benefits:

• More concise and readable code due to the compact ternary operator.
• Same functionality as the if statement approach, making it a stylistic choice for code efficiency.
• Better variable names

We can delve deeper into using functions to further separate the logic of determining the correct row pattern and improve code modularity.

Function Abstraction: Breaking Down Complexity

As our exploration progresses, the code can become more intricate. This section introduces function abstraction, a technique to break down complex logic into smaller, reusable functions. Here, we'll create a function named is_even to encapsulate the logic for determining the current row's color:

#include <stdio.h>

unsigned int is_even(int x) {
  return x % 2 == 0;
}

int main(void) {
  char *row_A = "10101010";
  char *row_B = "01010101";

  for (int row = 0; row < 8; row++) {
    char *row_str = is_even(row) ? row_A : row_B;
    printf("%s\n", row_str);
  }
  return 0;
}

Benefits:

• Improves code modularity by separating the row color determination logic from the main printing loop.
• Enhances code readability and maintainability.
• Makes the code more reusable, as this function can be used in other contexts where odd/even checking is needed.
• A function not only provide repeatable code, but it also improves readability and returns the value of a computation.

Introduce a Nested Loop to Gain Control Over Each Cell

In this section, we'll delve into a crucial concept in programming: nested loops. By incorporating a nested loop, we gain granular control over each individual cell within the checkerboard, unlocking exciting possibilities for customization and manipulation.

#include <stdio.h>

unsigned int is_even(int x) {
  return x % 2 == 0;
}

int main(void) {
  char *row_A = "10101010";
  char *row_B = "01010101";

  for (int row = 0; row < 8; row++) {
    char *row_str = is_even(row) ? row_A : row_B;

    for (int col = 0; col < 8; col++) {
      printf("%c", row_str[col]);  // Print each character within the current row
    }

    printf("\n");  // Move to the next line after printing a row
  }

  return 0;
}

Nested Loop Structure:

• The outer loop iterates over each row, determining the appropriate row pattern using the is_even function.
• The inner loop iterates over each column within the current row, printing individual characters one by one.

Individual Cell Control:

• We can now manipulate each cell independently, enabling customization options like:
• Formatting specific cells differently (e.g., adding spaces, using different characters).
• Applying conditional logic to alter cell content based on row or column values.

Increased Complexity:

• Nested loops introduce more intricate code structures, making it essential to understand their logic and nesting behavior.

Multiple printf Statements:

• One printf statement handles individual character printing within the inner loop.
• A separate printf("\n") statement outside the inner loop creates a newline after each row, ensuring proper formatting.

Benefits:

• Granular control over individual cells for enhanced customization and flexibility.
• Enables more complex checkerboard patterns and potential interactive features.

Drawbacks:

• Increased code complexity can make it challenging to understand and maintain.
• Potential performance implications due to nested loops, especially for larger checkerboards. The loop now runs 64 times instead of 8. A total of 72 printf statements are executed(64 for the cells, and an 8 additional ones for the newline)

Calculating the Cell Value Based on Row and Column

In this section, we'll explore a new function, get_cell, that abstracts the process of retrieving individual cell values. This abstraction enhances code modularity but introduces a potential inefficiency that we'll discuss in detail.

#include <stdio.h>

unsigned int is_even(int x) {
  return x % 2 == 0;
}

char get_cell(int row, int col) {
  char *row_A = "10101010";
  char *row_B = "01010101";

  char *row_str = is_even(row) ? row_A : row_B;
  return row_str[col];  // Return the character at the specified column within the correct row string
}

int main(void) {
  for (int row = 0; row < 8; row++) {
    for (int col = 0; col < 8; col++) {
      char cell = get_cell(row, col);  // Get the cell value for the current row and column
      printf("%c", cell);  // Print the retrieved cell value
    }

    printf("\n");
  }

  return 0;
}

Function Abstraction:

• The get_cell function encapsulates the logic for determining a cell's value based on its row and column coordinates.
• It abstracts this decision-making process away from the main function, promoting cleaner code organization.

Cleaner Main Function:

• The main function's primary responsibility is now loop management and printing, making its logic more straightforward.

Potential Inefficiency:

• There is an if check now for each of the cells. This is redundant and should be improved.

Benefits:

• Improved code modularity and readability.
• Enhanced potential for code reuse and testing.
• get_cell is an abstraction which allows us to use any mechanism to determine the color of the cell.

Replacing Strings with Integers

In this section, we'll shift from string-based representations to integer arrays for storing row patterns, aligning with more idiomatic C practices for modeling numerical data.

#include <stdio.h>

unsigned int is_even(int x) {
  return x % 2 == 0;
}

unsigned int get_cell(int row, int col) {
  unsigned int row_A[] = {1,0,1,0,1,0,1,0};
  unsigned int row_B[] = {0,1,0,1,0,1,0,1};
  unsigned int *row_arr = is_even(row) ? row_A : row_B;
  return row_arr[col];
}

int main(void) {
  for (int row = 0; row < 8; row++) {
    for(int col=0; col < 8; col++) {
      unsigned int cell = get_cell(row,col);
      printf("%d", cell);
    }
    printf("\n");
  }
  return 0;
}

Notice how our change now is limited only to get_cell

Integer Arrays for Rows:

• Instead of char arrays holding "1" and "0" characters, we now use unsigned int arrays to directly store 1 and 0 values, representing cell colors.
• This change aligns with C's preference for numerical data types when dealing with numbers.

Minimal Functional Impact:

• The code's overall behavior and output remain the same.

Idiomatic Approach:

• Using integers for numerical data is a common practice in C, promoting readability and consistency.
• It avoids potential type conversion overhead that might occur when working with numerical values stored as characters.

Benefits:

• Improves code clarity and aligns with C coding conventions.
• Potentially avoids unnecessary type conversions.

The Power of Math

Welcome to the realm of mathematical elegance! In this section, we witness the power of mathematics to simplify code and create efficient algorithms. Let's dive into the key transformations:

#include <stdio.h>

unsigned int is_even(int x) {
  return x % 2 == 0;
}

unsigned int get_cell(int row, int col) {
  unsigned int row_A[] = {1, 0};  // Only two elements for even/odd patterns
  unsigned int row_B[] = {0, 1};

  unsigned int *row_arr = is_even(row) ? row_A : row_B;
  return row_arr[col % 2];  // Use modulo 2 to determine the correct element within the 2-element array
}

int main(void) {
  // ... (same as previous sections)
}

Minimal Row Arrays:

• The row_A and row_B arrays now contain only two elements (1 and 0), representing the basic even/odd patterns.
• This reduction leverages the fact that checkerboard cell colors repeat every two columns.

Modulo Magic:

-The expression col % 2 isolates the column's parity (even or odd) by calculating its remainder after division by 2.

• This parity directly maps to the correct element within the 2-element row arrays.

Benefits:

• Concise Code: The code becomes more compact and readable due to the simplified array structures and modulo operation.
• Memory Efficiency: Smaller arrays potentially reduce memory usage, especially for large checkerboards.
• Efficient Calculation: The modulo operation offers a fast way to determine cell values without conditional logic or array lookups.

More Math, No More Arrays

#include <stdio.h>

unsigned int get_cell(int row, int col) {
  return (row + col) % 2;  // The heart of the checkerboard pattern, distilled into a single expression
}

int main(void) {
  // ... (same as previous sections)
}

Array Annihilation:

• The code no longer relies on arrays to store row patterns. Instead, it directly calculates cell values using a mathematical formula.

The Essence of Checkerboards:

• The expression (row + col) % 2 reveals the underlying pattern:
• The sum of row and column coordinates determines a cell's color.
• If the sum is even, the cell is black (0).
• If the sum is odd, the cell is white (1).

Compact and Efficient:

• This approach yields the most compact and potentially most efficient implementation for generating checkerboards in C.

Benefits:

• Concise and Elegant Code: The code is incredibly concise, making it easy to read, understand, and maintain.
• No Array Overhead: Eliminating arrays removes any overhead associated with array creation, memory allocation, and element access.
• Potential Performance Gains: The direct calculation using the modulo operation can be very efficient, especially for large checkerboards.

Bitwise Wisdom

In this section, we embrace the power of bitwise operations to unlock a more efficient and elegant approach to checkerboard generation.

#include <stdio.h>

unsigned int get_cell(int row, int col) {
  return (row + col) & 1;  // Bitwise magic for determining cell values
}

int main(void) {
  // ... (same as previous sections)
}

Bitwise AND for Even/Odd Check:

• The expression (row + col) & 1 leverages the bitwise AND operator (&) to efficiently determine whether the sum of row and column coordinates is even or odd.
• 1 in binary is 0001. Performing a bitwise AND with any number isolates its least significant bit (LSB).
• The LSB is 0 for even numbers and 1 for odd numbers, perfectly aligning with the checkerboard pattern.

Efficiency and Clarity:

• Bitwise operations often execute faster than modulo operations within modern processors.
• The code becomes more concise and potentially easier to understand for those familiar with bitwise operations.

Benefits:

• Potential Performance Improvement: Bitwise AND can be more efficient than the modulo operation, especially for large checkerboards.
• Concise and Expressive Code: The code becomes even more compact, expressing the checkerboard pattern's essence in a single, elegant expression.

Drawbacks:

• Not as readable for those unfamiliar with bitwise operations

Summary

We embarked on a journey, starting with simple printf statements and transitioning through various refinements. We witnessed the benefits of readability with separate lines, embraced modularity with functions, and gained granular control using nested loops. We discovered how strings for row patterns could be replaced with arrays, ultimately culminating in elegant mathematical formulas and bitwise operations for efficiency.

Each approach offered unique advantages and disadvantages:

• Early approaches: Easy to understand but repetitive and inflexible.
• Functions and loops: Increased modularity and control, but potentially less direct.
• Arrays: Improved memory efficiency over strings, but still relied on array lookups.
• Mathematical formulas: Achieved remarkable conciseness and potentially high performance, but might require deeper understanding.

This exploration highlights that problem-solving in programming is rarely a linear path. We can constantly iterate, seeking improvements in readability, maintainability, and efficiency. The "best" solution often depends on the specific context and priorities of the project. Remember, the journey of exploration and learning is just as valuable as the final destination!