problemeasyalgorithmsleetcode-3274leetcode 3274leetcode3274

Check if Two Chessboard Squares Have the Same Color

EasyUpdated: Jul 4, 2025
Practice on:
LeetCode

Problem

You are given two strings, coordinate1 and coordinate2, representing the coordinates of a square on an 8 x 8 chessboard.

Below is the chessboard for reference.

Return true if these two squares have the same color and false otherwise.

The coordinate will always represent a valid chessboard square. The coordinate will always have the letter first (indicating its column), and the number second (indicating its row).

Examples

Example 1

Input: coordinate1 = "a1", coordinate2 = "c3"
Output: true
Explanation:
Both squares are black.

Example 2

Input: coordinate1 = "a1", coordinate2 = "h3"
Output: false
Explanation:
Square `"a1"` is black and `"h3"` is white.

Constraints

  • coordinate1.length == coordinate2.length == 2
  • 'a' <= coordinate1[0], coordinate2[0] <= 'h'
  • '1' <= coordinate1[1], coordinate2[1] <= '8'

Solution

Method 1 – Parity Calculation

Intuition

On a chessboard, the color of a square is determined by the parity of the sum of its row and column indices. If two squares have the same parity, they have the same color.

Reasoning

Columns are labeled 'a' to 'h' (1 to 8) and rows '1' to '8'. For a square, if (column index + row index) is even, it's black; if odd, it's white. Thus, two squares have the same color if their parities match.

Approach

  1. Convert the column letter to a number (a=1, b=2, ..., h=8).
  2. Convert the row character to a number (1-8).
  3. For both coordinates, compute the sum of column and row indices and check their parity.
  4. Return true if both parities match, otherwise false.

Edge cases:

  • Both coordinates are the same.

Code

C++
class Solution {
public:
    bool squareIsSameColor(string c1, string c2) {
        auto get = [](const string& c) {
            return ((c[0] - 'a' + 1) + (c[1] - '0')) % 2;
        };
        return get(c1) == get(c2);
    }
};
Go
func squareIsSameColor(c1, c2 string) bool {
    get := func(c string) int {
        return (int(c[0]-'a'+1) + int(c[1]-'0')) % 2
    }
    return get(c1) == get(c2)
}
Java
class Solution {
    public boolean squareIsSameColor(String c1, String c2) {
        return ((c1.charAt(0) - 'a' + 1 + c1.charAt(1) - '0') % 2) ==
               ((c2.charAt(0) - 'a' + 1 + c2.charAt(1) - '0') % 2);
    }
}
Kotlin
class Solution {
    fun squareIsSameColor(c1: String, c2: String): Boolean {
        fun get(c: String) = (c[0] - 'a' + 1 + c[1] - '0') % 2
        return get(c1) == get(c2)
    }
}
Python
class Solution:
    def square_is_same_color(self, c1: str, c2: str) -> bool:
        def get(c: str) -> int:
            return (ord(c[0]) - ord('a') + 1 + int(c[1])) % 2
        return get(c1) == get(c2)
Rust
impl Solution {
    pub fn square_is_same_color(c1: String, c2: String) -> bool {
        fn get(c: &str) -> i32 {
            let b = c.as_bytes();
            ((b[0] - b'a' + 1) as i32 + (b[1] - b'0') as i32) % 2
        }
        get(&c1) == get(&c2)
    }
}

Complexity

  • ⏰ Time complexity: O(1), as all operations are constant time.
  • 🧺 Space complexity: O(1), as only a few variables are used.

Comments