Minimum Moves to Capture The Queen - Practice Coding Problems

Minimum Moves to Capture The Queen - Problem

Math Enumeration Medium

There is a 1-indexed 8 x 8 chessboard containing 3 pieces. You are given 6 integers a, b, c, d, e, and f where:

(a, b) denotes the position of the white rook.
(c, d) denotes the position of the white bishop.
(e, f) denotes the position of the black queen.

Given that you can only move the white pieces, return the minimum number of moves required to capture the black queen.

Note that:

Rooks can move any number of squares either vertically or horizontally, but cannot jump over other pieces.
Bishops can move any number of squares diagonally, but cannot jump over other pieces.
A rook or a bishop can capture the queen if it is located in a square that they can move to.
The queen does not move.

Input & Output

Example 1 — Rook Direct Attack

$ Input: a=1, b=1, c=3, d=3, e=1, f=8

› Output: 1

💡 Note: Rook at (1,1) and Queen at (1,8) are on the same row. Bishop at (3,3) doesn't block the path, so rook can capture queen in 1 move.

Example 2 — Bishop Blocked

$ Input: a=2, b=2, c=1, d=4, e=4, f=1

› Output: 2

💡 Note: Bishop at (1,4) can attack diagonally to (4,1), but rook at (2,2) is not on the same diagonal. Neither piece can capture in 1 move, so answer is 2.

Example 3 — Bishop Direct Attack

$ Input: a=5, b=5, c=2, d=2, e=4, f=4

› Output: 1

💡 Note: Bishop at (2,2) and Queen at (4,4) are on the same diagonal. Rook at (5,5) doesn't block this diagonal path, so bishop captures in 1 move.

Constraints

1 ≤ a, b, c, d, e, f ≤ 8
No two pieces occupy the same square
All coordinates represent valid chessboard positions

Visualization

Tap to expand

Understanding the Visualization

Input

Rook at (a,b), Bishop at (c,d), Queen at (e,f)

Analysis

Check if rook or bishop can attack queen directly

Output

Return 1 if direct attack possible, otherwise 2

Key Takeaway

🎯 Key Insight: Either a piece can capture immediately (1 move) or it always takes exactly 2 moves

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that we only need to check if either the rook or bishop can capture the queen in 1 move. If neither can attack directly (due to blocking or wrong positioning), the answer is always 2 moves. Best approach uses mathematical conditions to check attack patterns. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Analysis	O(1)	O(1)	Use mathematical conditions to check piece attack patterns and blocking
Case Analysis	O(1)	O(1)	Check all possible scenarios: 1-move captures and 2-move captures

Mathematical Analysis — Algorithm Steps

Use coordinate equality for rook attacks (same row: a==e, same column: b==f)
Use absolute difference equality for bishop diagonal attacks
Apply dot product logic to check if blocking piece is between attacker and target

Visualization

Tap to expand

Step-by-Step Walkthrough

Rook Logic

Same row (a==e) OR same column (b==f) AND not blocked

Bishop Logic

Same diagonal |c-e|==|d-f| AND not blocked by rook

Blocking Check

Use coordinate geometry to detect if one piece blocks another's path

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min_val(int a, int b) {
    return a < b ? a : b;
}

int max_val(int a, int b) {
    return a > b ? a : b;
}

int isBetween(int p1, int p2, int p3, int p4, int q1, int q2) {
    if (p1 == p3) { // Same row
        return q1 == p1 && min_val(p2, p4) < q2 && q2 < max_val(p2, p4);
    } else if (p2 == p4) { // Same column
        return q2 == p2 && min_val(p1, p3) < q1 && q1 < max_val(p1, p3);
    } else if (abs_val(p1-p3) == abs_val(p2-p4)) { // Same diagonal
        int dx1 = q1-p1, dy1 = q2-p2;
        int dx2 = p3-p1, dy2 = p4-p2;
        return dx1*dy2 == dy1*dx2 && 0 < dx1*dx2 + dy1*dy2 && dx1*dx2 + dy1*dy2 < dx2*dx2 + dy2*dy2;
    }
    return 0;
}

int solution(int a, int b, int c, int d, int e, int f) {
    // Check rook attack
    int rookAttacks = (a == e || b == f) && !isBetween(a, b, e, f, c, d);
    
    // Check bishop attack
    int bishopAttacks = (abs_val(c-e) == abs_val(d-f)) && !isBetween(c, d, e, f, a, b);
    
    return (rookAttacks || bishopAttacks) ? 1 : 2;
}

int main() {
    int a, b, c, d, e, f;
    scanf("%d", &a);
    scanf("%d", &b);
    scanf("%d", &c);
    scanf("%d", &d);
    scanf("%d", &e);
    scanf("%d", &f);
    
    int result = solution(a, b, c, d, e, f);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations are constant-time arithmetic and comparisons

✓ Linear Growth

Space Complexity

O(1)

Only using variables for calculations, no additional data structures

✓ Linear Space

18.5K Views

Medium Frequency

~15 min Avg. Time

420 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Mathematical Analysis — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler