Drawing A Checkerboard Out Of 1s And 0s With A Nested For Loop

May 09, 2024 Post a Comment

I'm using just normal python to make a checkerboard grids out of alternating 1s and 0s. I know that I can use a nested for loop with the modulus operator but I don't know exactly w

Solution 1:

Here's my solution, using nested for loops. Note that whether i+j is even or odd is a good way to determine where it should be 1 and where it should be 0, as it always alternates between adjacent 'cells'.

def checkerboard(n):
    board = []
    for i in range(n):
        board.append([])
        for j in range(n):
            board[i].append((i+j) % 2)
    return board

for row in checkerboard(8):
    print(row)

Prints

[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]

Solution 2:

Perhaps we should first aim to solve a different problem: how to generate a list with checkboard patterns.

Such list thus has interleaved a [0,1,0,...] row, and an [1,0,1,...] row.

Let us first construct the first row with length n. We can do this like:

[i%2 for i in range(n)]

Now the next row should be:

[(i+1)%2 for i in range(n)]

the next one can be:

[(i+2)%2 for i in range(n)]

Do you see a pattern emerge? We can construct such a pattern like:

[[(i+j)%2 for i in range(n)] for j in range(m)]

Now the only thing that is left is producing it as a string. We can do this by converting the data in the list to strings, join them together (and optionally use generators instead of list comprehension). So:

'\n'.join(''.join(str((i+j)%2) for i inrange(n)) for j inrange(m))

So we can construct an m×n grid like:

def print_board(m,n):
    print('\n'.join(''.join(str((i+j)%2) for i in range(n)) for j in range(m)))

A 10x15 board then is:

Baca Juga

>>>print_board(10,15)
010101010101010
101010101010101
010101010101010
101010101010101
010101010101010
101010101010101
010101010101010
101010101010101
010101010101010
101010101010101

N.B.: we can make the code a bit more efficient, by using &1 instead of %2:

def print_board(m,n):
    print('\n'.join(''.join(str((i+j)&1) for i in range(n)) for j in range(m)))

Solution 3:

A simple approach

# Functionto draw checkerboard
def drawBoard(length):

    forrowin xrange(0, length):
        for col in xrange(0, length):

            # Even rows will startwith a 0 (Nooffset)
            # Odd rows will startwith a 1 (1offset)
            offset=0
            if row%2==0:
                offset=1

            # alterate eachcolumnin a rowby1and0
            if (col +offset) %2==0:
                print '1',
            else:
                print '0',

        # print new line at the endof a row
        print ""


drawBoard(8)

Solution 4:

For even widths, you could avoid loops all together and just multiply some strings:

defprint_board(width):
    print ('0 1 ' * (width // 2) + '\n' + '1 0 ' * (width // 2) + '\n') * (width // 2)

print_board(10)

Giving:

0 1 0 1 0 1 0 1 0 1 
1 0 1 0 1 0 1 0 1 0 
0 1 0 1 0 1 0 1 0 1 
1 0 1 0 1 0 1 0 1 0 
0 1 0 1 0 1 0 1 0 1 
1 0 1 0 1 0 1 0 1 0 
0 1 0 1 0 1 0 1 0 1 
1 0 1 0 1 0 1 0 1 0 
0 1 0 1 0 1 0 1 0 1 
1 0 1 0 1 0 1 0 1 0

This works as follows for a 10 x 10 grid:

Take the string 1 0
Multiply the string by 5 giving 1 0 1 0 1 0 1 0 1 0
Do the same with 0 1 giving: 0 1 0 1 0 1 0 1 0 1
Add a newline to the end of each and join them together: 1 0 1 0 1 0 1 0 1 0 \n0 1 0 1 0 1 0 1 0 1 \n
Now multiply this whole string by 5 to get the grid.

Solution 5:

You can use list comprehension and a modulo:

new_board = [[0 if b%2==0else1for b inrange(8)] if i%2==0else [1 if b%2==0else0for b inrange(8)] for i inrange(8)]
forrowin new_board:
   print(row)

Output:

[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]
[1, 0, 1, 0, 1, 0, 1, 0]

For a more custom finish:

for row in new_board:
   print(' '.join(map(str, row)))