Available Captures for Rook

Available Captures for Rook - Problem

You are given an 8 x 8 matrix representing a chessboard. There is exactly one white rook represented by 'R', some number of white bishops 'B', and some number of black pawns 'p'. Empty squares are represented by '.'.

A rook can move any number of squares horizontally or vertically (up, down, left, right) until it reaches another piece or the edge of the board. A rook is attacking a pawn if it can move to the pawn's square in one move.

Note: A rook cannot move through other pieces, such as bishops or pawns. This means a rook cannot attack a pawn if there is another piece blocking the path.

Return the number of pawns the white rook is attacking.

Input & Output

Example 1 — Basic Attack Pattern

$ Input: board = [["..",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","R",".",".","B","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","p"],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]

› Output: 1

💡 Note: Rook at (2,3) can attack the pawn directly above at (1,3). The pawn at (4,7) is not in the same row or column as the rook, so it cannot be attacked.

Example 2 — No Attackable Pawns

$ Input: board = [["..",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","R",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]

› Output: 0

💡 Note: Rook at (2,3) with no pawns on board - cannot attack any pawns.

Example 3 — Blocked by Bishop

$ Input: board = [["..",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","R","B",".","p","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]

› Output: 0

💡 Note: Rook at (2,3) cannot attack pawn at (2,6) because bishop at (2,4) blocks the path.

Constraints

board.length == 8
board[i].length == 8
board[i][j] is either 'R', '.', 'B', or 'p'
There is exactly one cell with board[i][j] == 'R'

Visualization

Tap to expand

Asked in

A Amazon 15 G Google 12

The key insight is to simulate rook movement in 4 directions (up, down, left, right) from its position until hitting a piece or board edge. Best approach is directional simulation with Time: O(1), Space: O(1) since we check at most 32 squares total.

Common Approaches

✓ Brute Force - Check All Squares

⏱️ Time: O(n⁴) Space: O(1)

Iterate through every square on the board. For each pawn found, check if the rook can attack it by verifying they're on the same row or column and no pieces block the path.

Directional Simulation

⏱️ Time: O(1) Space: O(1)

Find the rook position first, then simulate its movement in all four directions (up, down, left, right) until hitting a piece or board edge. Count pawns encountered before hitting blocking pieces.

Brute Force - Check All Squares — Algorithm Steps

Find rook position
For each pawn, check if on same row/column
Verify no blocking pieces between rook and pawn

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Rook

Locate the rook position on the board

Check Pawns

For each pawn, check if on same row/column

Verify Path

Check if any pieces block the attack path

Code -

solution.c — C

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

int solution(char board[8][8]) {
    // Find rook position
    int rookRow = -1, rookCol = -1;
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            if (board[i][j] == 'R') {
                rookRow = i;
                rookCol = j;
                break;
            }
        }
        if (rookRow != -1) break;
    }
    
    int count = 0;
    // Check all squares for pawns
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            if (board[i][j] == 'p') {
                // Check if rook can attack this pawn
                if (i == rookRow) { // Same row
                    int blocked = 0;
                    int start = (j < rookCol) ? j : rookCol;
                    int end = (j > rookCol) ? j : rookCol;
                    for (int k = start + 1; k < end; k++) {
                        if (board[i][k] != '.') {
                            blocked = 1;
                            break;
                        }
                    }
                    if (!blocked) count++;
                } else if (j == rookCol) { // Same column
                    int blocked = 0;
                    int start = (i < rookRow) ? i : rookRow;
                    int end = (i > rookRow) ? i : rookRow;
                    for (int k = start + 1; k < end; k++) {
                        if (board[k][j] != '.') {
                            blocked = 1;
                            break;
                        }
                    }
                    if (!blocked) count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char board[8][8];
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array manually
    int row = 0, col = 0;
    int inQuote = 0;
    
    for (int i = 0; line[i]; i++) {
        if (line[i] == '"') {
            inQuote = !inQuote;
        } else if (inQuote && line[i] != ',' && line[i] != ' ') {
            board[row][col++] = line[i];
            if (col == 8) {
                col = 0;
                row++;
            }
        }
    }
    
    printf("%d\n", solution(board));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

For each of 64 squares, potentially check all squares between rook and target

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra variables

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force - Check All Squares — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler