Queens That Can Attack the King - Practice Coding Problems

Queens That Can Attack the King - Problem

Imagine a chess battle where multiple black queens are strategically positioned on an 8×8 chessboard, all eyeing a single white king. Your mission? Identify which queens pose an immediate threat!

You're given:

queens - A 2D array where queens[i] = [x, y] represents the position of the i-th black queen
king - An array [x, y] representing the white king's position

A queen can attack the king if they share the same row, column, or diagonal with no pieces blocking the path. Return the coordinates of all queens that can directly attack the king.

Example: If the king is at [0,1] and queens are at [[0,0], [1,1], [2,2]], then queens at [0,0] (same row) and [1,1] (diagonal) can attack, but [2,2] cannot because [1,1] blocks the diagonal path.

Input & Output

example_1.py — Basic Attack Scenario

$ Input: queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]

› Output: [[0,1],[1,0],[3,3]]

💡 Note: The queen at [0,1] can attack horizontally, [1,0] can attack vertically, and [3,3] can attack diagonally. Other queens are either not aligned or blocked by closer queens.

example_2.py — Blocking Scenario

$ Input: queens = [[0,0],[1,1],[2,2],[3,4],[3,5],[4,4],[5,6]], king = [3,3]

› Output: [[2,2],[3,4],[4,4]]

💡 Note: Queen [2,2] attacks diagonally, [3,4] horizontally, [4,4] diagonally. The queen at [0,0] is blocked by [1,1] and [2,2].

example_3.py — Edge Case - Corner King

$ Input: queens = [[5,6],[7,7],[2,1],[0,7],[1,6],[5,1],[1,7],[0,6],[7,6]], king = [0,0]

› Output: [[2,1],[0,7],[7,7]]

💡 Note: From corner [0,0], king can be attacked by [2,1] diagonally, [0,7] vertically, and [7,7] diagonally. Other queens are not in direct lines of attack.

Visualization

Tap to expand

Understanding the Visualization

Position Setup

Place king and queens on 8x8 chessboard

Direction Vectors

Define 8 attack directions from king position

Beam Scanning

Scan each direction until hitting queen or boundary

Attack Detection

First queen in each direction can attack the king

Key Takeaway

🎯 Key Insight: Only the closest queen in each of the 8 directions can attack - scanning from the king naturally finds these attackers while ignoring blocked queens.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n queens, we check all other n queens to see if they block the path

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for iteration and result storage

✓ Linear Space

Constraints

1 ≤ queens.length ≤ 63
queens[i].length == 2
0 ≤ queens[i][j] < 8
king.length == 2
0 ≤ king[0], king[1] < 8
All given positions are unique
The king and queens are placed on a standard 8×8 chessboard

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses directional scanning from the king's position. Build a hash set of queen positions, then scan in all 8 directions (4 cardinal + 4 diagonal) from the king. The first queen encountered in each direction is an attacker, as any queen behind it would be blocked. This achieves O(n) time complexity with elegant geometric insight.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Queens)	O(n²)	O(1)	Check each queen individually to see if it can attack the king
Two-Pass Direction Scanning	O(n)	O(n)	First pass builds queen position map, second pass scans from king in all 8 directions

Brute Force (Check All Queens) — Algorithm Steps

For each queen, check if it's aligned with the king (same row, column, or diagonal)
If aligned, check if any other queen lies between this queen and the king
If no blocking queen exists, add this queen to the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Queen

Pick the first queen to analyze

Check Alignment

Verify if queen and king are on same row, column, or diagonal

Check Path

Examine each square between queen and king for blocking pieces

Repeat

Continue for all queens in the list

Code -

solution.c — C

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

bool canAttack(int* queen, int* king, int** queens, int queensSize) {
    int qx = queen[0], qy = queen[1];
    int kx = king[0], ky = king[1];
    
    // Check if on same row, column, or diagonal
    if (qx != kx && qy != ky && abs(qx - kx) != abs(qy - ky)) {
        return false;
    }
    
    // Determine direction
    int dx = qx == kx ? 0 : (kx > qx ? 1 : -1);
    int dy = qy == ky ? 0 : (ky > qy ? 1 : -1);
    
    // Check for blocking queens
    int x = qx + dx, y = qy + dy;
    while (x != kx || y != ky) {
        for (int i = 0; i < queensSize; i++) {
            if (queens[i][0] == x && queens[i][1] == y) {
                return false;
            }
        }
        x += dx;
        y += dy;
    }
    
    return true;
}

int** queensAttacktheKing(int** queens, int queensSize, int* queensColSize, int* king, int kingSize, int* returnSize, int** returnColumnSizes) {
    int** result = (int**)malloc(queensSize * sizeof(int*));
    *returnColumnSizes = (int*)malloc(queensSize * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < queensSize; i++) {
        if (canAttack(queens[i], king, queens, queensSize)) {
            result[*returnSize] = (int*)malloc(2 * sizeof(int));
            result[*returnSize][0] = queens[i][0];
            result[*returnSize][1] = queens[i][1];
            (*returnColumnSizes)[*returnSize] = 2;
            (*returnSize)++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n queens, we check all other n queens to see if they block the path

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for iteration and result storage

✓ Linear Space

Constraints

1 ≤ queens.length ≤ 63
queens[i].length == 2
0 ≤ queens[i][j] < 8
king.length == 2
0 ≤ king[0], king[1] < 8
All given positions are unique
The king and queens are placed on a standard 8×8 chessboard

23.8K Views

Medium Frequency

~18 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Queens) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler