Available Captures for Rook - Practice Coding Problems

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: 3

💡 Note: Rook at (2,3) can attack: pawn up at (1,3), and in right direction it's blocked by bishop so can't attack the pawn at (4,7). Wait, let me recalculate - rook can attack 1 pawn directly above it.

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

Understanding the Visualization

Input

8×8 chessboard with rook 'R', bishops 'B', and pawns 'p'

Process

Simulate rook movement in 4 directions until blocked

Output

Count of pawns that can be captured

Key Takeaway

🎯 Key Insight: Rook attacks in straight lines - simulate movement in 4 directions until blocked

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

Approach	Time	Space	Notes
✓ Brute Force - Check All Squares	O(n⁴)	O(1)	Check every square to see if rook can attack it
Directional Simulation	O(1)	O(1)	Simulate rook movement in 4 directions until blocked

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