9.1.7 Checkerboard V2 Codehs Review

This problem is a classic introduction to Nested Loops and Modular Arithmetic. It asks you to draw a checkerboard pattern where the color of each square depends on its position (row and column).

Variation B: Color Cycling

Instead of two colors, use four colors repeating. Use (row + col) % 4 to choose from an array of colors.

Step-by-Step Plan

1. Set up the canvas and drawing parameters

   • Canvas size: 400x400
   • Square size: 50x50 (since 8 * 50 = 400)

2. Use nested loops

   • Outer loop: iterate over rows (0 to 7)
   • Inner loop: iterate over columns (0 to 7)

3. Track color using a boolean

   • Start with isBlack = true at the beginning of each row?
   • No — because each row alternates starting color.

   Better:

   • For row 0, start with isBlack = true
   • For row 1, start with isBlack = false
   • For row 2, start with isBlack = true
   • → Starting color = (row % 2 == 0)

   But wait — V2 often wants you to toggle based on previous square, not row+col.

4. Draw each square

   • Calculate x = col * size, y = row * size
   • Set fill color based on current boolean
   • Draw the rectangle
   • Toggle the boolean after each square

5. Reset boolean for next row

   • After finishing a row, toggle the starting color for the next row (or just set it based on even/odd row).

Step-by-Step Solution Plan

Let’s assume the following constants (typical in CodeHS):

private static final int ROWS = 8;
private static final int COLS = 8;
private static final int SQUARE_SIZE = 50;

Inside your run() method:

1. Loop through each row (0 to ROWS-1).
2. Loop through each column (0 to COLS-1).
3. Calculate x = col * SQUARE_SIZE, y = row * SQUARE_SIZE.
4. Determine color: if (row + col) % 2 == 0, use one color (e.g., Color.RED), else the other (Color.BLACK).
5. Draw a filled rectangle at (x, y) with size SQUARE_SIZE × SQUARE_SIZE and the chosen color.

3. Alternating Logic (The Pattern)

A checkerboard alternates on both axes. The formula (row + col) % 2 is the golden rule. The 9

• If (row + col) % 2 == 0, draw one color (e.g., black).
• If (row + col) % 2 == 1, draw the other color (e.g., red).

Important Adaptations:

• If your CodeHS environment uses JAVA_HOME without ACM, replace GraphicsProgram with JFrame and JPanel.
• For JavaScript graphics (CodeHS JS Graphics): use Rect objects and add().

Common Mistakes to Avoid

1. Forgetting the Modulo Operator (%): Students often try to use complicated boolean flags (like is_red = True) and flip them back and forth. While possible, it is prone to errors. Using (row + col) % 2 is the cleanest, "professional" way to solve grid patterns.
2. Overlap: If you don't move the turtle correctly between squares, you might draw squares on top of each other. Ensure your movement distance (forward(square_size)) matches the size of the square you just drew.
3. Grid Alignment: A common error is that the next row starts where the previous one ended (on the far right). You must explicitly move the turtle back to the starting X position (using backward or goto) before starting the next row.

In CodeHS 9.1.7: Checkerboard V2, the goal is to create a pattern of alternating 1s and 0s in a 2D list (grid). Unlike version 1, which often uses simple row filling, version 2 requires you to use nested for loops and the modulus operator ( ) to check for even and odd positions. Logic for the Pattern

To create a checkerboard, a cell should be a 1 if the sum of its row and column indices is even (or odd, depending on your starting preference). Even sum : Assign 1. Odd sum : Assign 0. Step-by-Step Implementation

Initialize the BoardCreate an empty list and fill it with eight sub-lists, each containing eight zeros. board = [] for i in range(8): board.append([0] * 8) Use code with caution. Copied to clipboard

Iterate and Assign ValuesUse nested loops to traverse every row ( ) and column (

). Use an if statement with the modulus operator to decide where to place a 1.

for i in range(8): for j in range(8): if (i + j) % 2 == 0: board[i][j] = 1 Use code with caution. Copied to clipboard

Print the BoardDefine or use a function to print each row of the list so it looks like a grid.

def print_board(board): for row in board: print(" ".join([str(x) for x in row])) print_board(board) Use code with caution. Copied to clipboard ✅ Result The final output will be an

grid where 1s and 0s alternate perfectly in every direction.

1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 Use code with caution. Copied to clipboard

CodeHS exercise 9.1.7 Checkerboard V2 requires students to generate an 8x8 2D list, using nested loops and the modulus operator to create an alternating pattern. The core logic involves evaluating (row + col) % 2 to determine if a cell receives a 0 or 1, a key differentiator from the simpler, row-based V1 assignment. Read user discussions on the solution at Reddit.

Checkerboard V2: An Exploration of Algorithmic Patterns and Grid-Based Design

Introduction

The Checkerboard V2 project, as presented in CodeHS's 9.1.7 exercise, offers a compelling exploration into the world of algorithmic patterns and grid-based design. This assignment requires students to create a visually striking checkerboard pattern using code, emphasizing the importance of logical thinking, problem-solving, and programming fundamentals. This paper will provide an in-depth analysis of the Checkerboard V2 project, discussing its key components, design considerations, and educational value.

Understanding the Project Requirements

The Checkerboard V2 project builds upon the foundational concepts of grid-based design and pattern creation. Students are tasked with writing a program that generates a checkerboard pattern consisting of alternating black and white squares, arranged in an 8x8 grid. The pattern should exhibit specific characteristics, such as:

• An 8x8 grid of squares
• Alternating black and white squares
• A clear and symmetrical pattern

Algorithmic Approach

To create the Checkerboard V2 pattern, students must employ a systematic and algorithmic approach. The solution involves using nested loops to iterate over the grid, making decisions about the color of each square based on its position. A common strategy involves using the sum of the row and column indices to determine whether a square should be black or white.

For example, in a simple implementation:

for row in range(8):
    for col in range(8):
        if (row + col) % 2 == 0:
            # Draw a white square
        else:
            # Draw a black square

This approach ensures that adjacent squares have different colors, resulting in the characteristic checkerboard pattern. Set up the canvas and drawing parameters

Design Considerations

When designing the Checkerboard V2, students must consider several key factors:

• Grid size: The 8x8 grid size provides a clear and recognizable checkerboard pattern. However, students may experiment with different grid sizes to explore how the pattern changes.
• Color selection: The choice of black and white as the primary colors provides a high-contrast and visually striking pattern. Students may choose to experiment with other color combinations to create different effects.
• Symmetry: The checkerboard pattern relies on symmetry to create a sense of order and balance. Students must ensure that their implementation maintains this symmetry.

Educational Value

The Checkerboard V2 project offers significant educational value, particularly in the areas of:

• Algorithmic thinking: Students develop problem-solving skills by breaking down the problem into manageable parts and creating a systematic approach to generating the pattern.
• Grid-based design: The project introduces students to the principles of grid-based design, which is a fundamental concept in computer graphics, game development, and visual design.
• Programming fundamentals: The Checkerboard V2 project reinforces essential programming concepts, such as nested loops, conditional statements, and variables.

Variations and Extensions

To further develop their skills, students can explore variations and extensions of the Checkerboard V2 project:

• Custom grid sizes: Students can create checkerboards with different grid sizes, exploring how the pattern changes.
• Alternative color schemes: Students can experiment with different color combinations to create unique and visually striking patterns.
• Interactive elements: Students can add interactive elements, such as user-controlled squares or animations, to enhance the user experience.

Conclusion

The Checkerboard V2 project, as presented in CodeHS's 9.1.7 exercise, provides a comprehensive exploration of algorithmic patterns and grid-based design. By understanding the project requirements, algorithmic approach, and design considerations, students develop essential skills in programming, problem-solving, and visual design. The educational value of this project extends beyond the specific task, providing a foundation for more complex and creative projects in the future.

Mastering the Checkerboard V2 (9.1.7) in CodeHS To successfully complete the 9.1.7 Checkerboard V2 exercise in CodeHS, you must generate an

s where the numbers alternate in a checkerboard pattern. The key is to use nested loops modulus operator ) to determine if a specific cell should be a based on its row and column indices. The Core Logic

A checkerboard pattern is mathematically defined by the sum of the row and column indices. If the sum is even, the cell is one "color" ( ); if it is odd, it is the other ( Step-by-Step Implementation 1. Initialize an Empty Board

First, create a variable to hold your grid. You will start with an empty list and then append rows to it. In CodeHS, you are typically expected to build an structure. 2. Create the Nested Loops You need two loops: one for the rows and one for the columns. outer loop iterates through the row indices ( inner loop iterates through the column indices ( 3. Apply the Alternating Pattern Inside the nested loop, check the sum of the current . Use the modulus operator to check for even or odd values. if (row + col) % 2 == 0 If true, set the cell to If false, set the cell to 4. Print the Result

After the loops have finished building your board, you must print it row by row. Using print " ".join(row)

is a common way to format the output so it looks like a clean grid in the console. Example Code Snippet The following logic illustrates how to construct the grid correctly: # 1. Initialize the board # 2. Outer loop for rows # 3. Inner loop for columns # 4. Check for even/odd sum : row.append( : row.append( ) board.append(row) # 5. Print the formatted board board: print .join([str(x) Use code with caution. Copied to clipboard Why version 2 is different

In earlier versions (like Checkerboard V1), you might have been asked to just fill specific regions (like the top and bottom rows) with

specifically tests your ability to use logic to create a repeating, alternating pattern across the entire grid. Procedural Solution Summary The final answer is a grid where cell is odd, and

The final result is an 8x8 list of lists where every adjacent element (horizontally and vertically) alternates between 0 and 1. modulus operator works for other patterns, or should we look at a different CodeHS exercise

Variation C: User Resizable Canvas

In the graphics version, recompute square size on window resize. This is rare for CodeHS but possible in advanced sections.

Java Solution (Text-Based)

import java.util.Scanner;
public class CheckerboardV2 
public static void main(String[] args) 
Scanner input = new Scanner(System.in);
    System.out.print("Enter number of rows: ");
    int rows = input.nextInt();
    System.out.print("Enter number of columns: ");
    int cols = input.nextInt();
for (int i = 0; i < rows; i++) 
        for (int j = 0; j < cols; j++) 
            if ((i + j) % 2 == 0) 
                System.out.print("@");
             else 
                System.out.print(".");
System.out.println(); // new line after each row

Sample Output (5x5):

@.@.@
.@.@.
@.@.@
.@.@.
@.@.@