# 5 Best Ways to Determine the Color of a Chessboard Square using Python

π‘ Problem Formulation: Chessboard squares alternate in color between light and dark. Given an input in the form of a chessboard square identifier (e.g., ‘a1’, ‘d5’), we want to programatically determine whether that square is light or dark. The desired output would be a string “light” or “dark”.

## Method 1: Using Basic Arithmetic and Modulus Operator

This method involves mapping the letter part of the square to a numerical value, adding it to the number part, and checking if the sum is even or odd using the modulus operator. If the sum is even, the square is dark; otherwise, it’s light. It’s a straightforward computational approach which is fast and easy to implement.

Here’s an example:

```def get_square_color(square):
letter, number = ord(square[0]) - ord('a'), int(square[1])
return 'dark' if (letter + number) % 2 == 0 else 'light'

# Example Usage
color = get_square_color('d5')
print(color)```

Output: light

This function `get_square_color()` takes a chessboard square as input, maps the letter to an integer, and adds it to the digit. It checks the sum’s parity using the modulus operator (`% 2`) to determine the color and returns the result.

## Method 2: Using ASCII Values Directly

Similar to the first method, this approach leverages the ASCII values of the characters directly, without the explicit mapping, and checks if the sum of the ASCII value of the letter and the number is even or odd. It is very succinct and eliminates an additional step of mapping done in Method 1.

Here’s an example:

```def square_color(square):
return 'dark' if (ord(square[0]) + int(square[1])) % 2 == 0 else 'light'

# Sample Call
print(square_color('a1'))```

Output: dark

In `square_color()`, the ASCII value obtained with `ord()` for the letter is directly used along with the integer value of the square number. The color is determined by the even or odd nature of their sum and returned.

## Method 3: Dictionary-Based Mapping

This method uses a dictionary to map each letter of the chessboard to its numerical equivalence, then utilizes arithmetic and modulus as in previous methods to determine color. This method can be more readable, particularly for individuals who are not comfortable with ASCII character manipulation.

Here’s an example:

```map_letters = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8}

def determine_color(position):
column, row = map_letters[position[0]], int(position[1])
return 'dark' if (column + row) % 2 == 0 else 'light'

# Test the function
print(determine_color('h8'))```

Output: dark

This `determine_color()` function uses a predefined dictionary `map_letters` to convert column letters to numbers, then computes the sum with the row number to ascertain the color.

## Method 4: Using a Function for Modularity

In this modular approach, a separate function is defined to map the letters to numbers, which is then called from within the main function to determine the color of the square. This enhances modularity and the function can be reused in different contexts or expanded upon for a more complex chessboard application.

Here’s an example:

```def letter_to_num(letter):
return ord(letter) - ord('a') + 1

def color_of_square(square):
column, row = letter_to_num(square[0]), int(square[1])
return 'dark' if (column + row) % 2 == 0 else 'light'

# Testing the function
print(color_of_square('c3'))```

Output: dark

This function `color_of_square()` calls `letter_to_num()`, which abstracts the detail of mapping letters to numbers and is used to find the color of the square, promoting cleaner code and reusability.

## Bonus One-Liner Method 5: Lambda Functions

For Python enthusiasts who appreciate conciseness, this method uses a lambda function to achieve the same result in a single line of code. This method is for those who prioritize brevity, although it may sacrifice some readability for less experienced programmers.

Here’s an example:

```square_color = lambda s: 'dark' if (ord(s[0]) - ord('a') + int(s[1])) % 2 == 0 else 'light'

# Test
print(square_color('b4'))```

Output: light

The lambda function `square_color` succinctly calculates the color by directly applying the letter-number arithmetic and modulus operation within a single expression.

## Summary/Discussion

• Method 1: Basic Arithmetic and Modulus Operator. Simple and efficient method. Least readable due to indirect character-to-number mapping.
• Method 2: ASCII Values Directly. More concise than Method 1. Still may be slightly confusing due to direct ASCII value usage.
• Method 3: Dictionary-Based Mapping. Higher readability, and good for beginners. Slower than direct ASCII value methods due to dictionary lookup overhead.
• Method 4: Function for Modularity. Improves code reuse and readability at the potential cost of slight performance overhead with function calls.
• Method 5: Lambda Functions. Extremely concise, demonstrating Python’s capabilities for writing compact code. However, it prioritizes brevity over clarity.