Check if Word Can Be Placed In Crossword - Practice Coding Problems

Check if Word Can Be Placed In Crossword - Problem

Imagine you're a crossword puzzle enthusiast working on a partially completed puzzle. You have a word that you want to place, but you need to check if it fits according to crossword rules!

You're given an m x n crossword board where:

Lowercase letters represent already placed letters from solved words
Spaces (' ') represent empty cells where new letters can be placed
Hash symbols ('#') represent blocked cells (like the black squares in real crosswords)

A word can be placed horizontally (left-to-right or right-to-left) or vertically (top-to-bottom or bottom-to-top) if:

🚫 It doesn't occupy any blocked cells ('#')
✅ Each letter goes in an empty cell (' ') or matches an existing letter
🔒 No empty cells or letters are directly adjacent to the word's boundaries

Goal: Return true if the word can be placed anywhere on the board following these rules, false otherwise.

Input & Output

example_1.py — Valid Horizontal Placement

$ Input: board = [["#", " ", "#"], [" ", " ", "#"], ["#", "c", " "]], word = "abc"

› Output: true

💡 Note: The word 'abc' can be placed vertically starting at position (0,1) going downward. The 'a' goes in empty space (0,1), 'b' goes in empty space (1,1), and 'c' matches the existing 'c' at (2,1). The placement is properly isolated with blocked cells adjacent to the boundaries.

example_2.py — No Valid Placement

$ Input: board = [[" ", "#", "a"], ["#", " ", "#"], ["#", " ", "#"]], word = "abc"

› Output: false

💡 Note: No valid placement exists for 'abc'. Horizontal placements are blocked by insufficient space or conflicting characters. Vertical placements fail due to isolation requirements - existing 'a' at (0,2) would be adjacent to any vertical word placement.

example_3.py — Reverse Direction Placement

$ Input: board = [["#", " ", " "], ["#", " ", " "], ["#", " ", "c"]], word = "ca"

› Output: true

💡 Note: The word 'ca' can be placed vertically in reverse direction (bottom-to-top) starting at (2,2). The 'c' matches existing 'c' at (2,2) and 'a' goes in empty space (1,2). This placement satisfies isolation since column is bounded by blocked cells.

Visualization

Tap to expand

Understanding the Visualization

Survey the Scene

Examine the crossword board layout, noting blocked cells (#), empty spaces ( ), and existing letters

Try Every Starting Point

For each cell position, consider it as a potential starting point for word placement

Check All Directions

Attempt placement in horizontal (left-to-right and right-to-left) and vertical (top-to-bottom and bottom-to-top) directions

Validate Placement Rules

Ensure word fits in bounds, doesn't hit blocked cells, matches existing letters, and maintains proper isolation

Report Findings

Return true if any valid placement is found, false if all positions fail validation

Key Takeaway

🎯 Key Insight: The systematic enumeration approach is optimal because we must check placement constraints for every possible position and direction. There's no way to eliminate positions without actually validating the crossword rules.

Time & Space Complexity

Time Complexity

⏱️

O(m × n × w)

For each of the m×n cells, we potentially check word placement in 4 directions, each taking O(w) time where w is word length

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables and direction vectors

✓ Linear Space

Constraints

m == board.length
n == board[i].length
1 ≤ m × n ≤ 2 × 10⁵
1 ≤ word.length ≤ max(m, n)
board[i][j] is either ' ', '#', or a lowercase English letter
word consists of lowercase English letters only

Asked in

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

The optimal approach systematically checks every cell as a potential starting position and attempts word placement in all four directions. For each placement attempt, we validate three key constraints: boundary fitting (word stays within grid), character compatibility (each letter goes in empty space or matches existing letter), and isolation (no adjacent letters/spaces at word boundaries). Time complexity is O(m × n × w) where w is word length.

Common Approaches

Approach	Time	Space	Notes
✓ Systematic Position and Direction Check	O(m × n × w)	O(1)	Check every cell as starting position in all 4 possible directions

Systematic Position and Direction Check — Algorithm Steps

Iterate through each cell (i, j) in the matrix as potential starting position
For each starting position, try all 4 directions of placement
For each direction, check if word fits within matrix boundaries
Validate that no character conflicts with blocked cells ('#')
Ensure each character either matches existing letter or goes in empty space
Verify isolation: check that cells before and after word placement are blocked or out of bounds
Return true immediately if any valid placement is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Starting Positions

Try each cell as a potential starting position

Check Four Directions

For each position, attempt placement in horizontal L-R, R-L, vertical T-B, B-T

Validate Boundaries

Ensure word fits within matrix bounds

Check Isolation

Verify no adjacent letters/spaces at word boundaries

Validate Characters

Confirm each letter fits (empty space or matching letter)

Code -

solution.c — C

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

bool canPlaceHorizontal(char** board, int m, int n, char* word, int wordLen, int row, int col, int direction) {
    int startCol = (direction == 1) ? col : col - wordLen + 1;
    int endCol = (direction == 1) ? col + wordLen - 1 : col;
    
    if (startCol < 0 || endCol >= n) return false;
    
    // Check isolation
    if (startCol > 0 && board[row][startCol - 1] != '#') return false;
    if (endCol < n - 1 && board[row][endCol + 1] != '#') return false;
    
    // Check character compatibility
    for (int i = 0; i < wordLen; i++) {
        int boardCol = startCol + i;
        char wordChar = (direction == 1) ? word[i] : word[wordLen - 1 - i];
        char cell = board[row][boardCol];
        
        if (cell == '#') return false;
        if (cell != ' ' && cell != wordChar) return false;
    }
    
    return true;
}

bool canPlaceVertical(char** board, int m, int n, char* word, int wordLen, int row, int col, int direction) {
    int startRow = (direction == 1) ? row : row - wordLen + 1;
    int endRow = (direction == 1) ? row + wordLen - 1 : row;
    
    if (startRow < 0 || endRow >= m) return false;
    
    // Check isolation
    if (startRow > 0 && board[startRow - 1][col] != '#') return false;
    if (endRow < m - 1 && board[endRow + 1][col] != '#') return false;
    
    // Check character compatibility
    for (int i = 0; i < wordLen; i++) {
        int boardRow = startRow + i;
        char wordChar = (direction == 1) ? word[i] : word[wordLen - 1 - i];
        char cell = board[boardRow][col];
        
        if (cell == '#') return false;
        if (cell != ' ' && cell != wordChar) return false;
    }
    
    return true;
}

bool placeWordInCrossword(char** board, int boardSize, int* boardColSize, char* word) {
    if (!board || boardSize == 0 || !boardColSize || !word) return false;
    
    int m = boardSize, n = boardColSize[0];
    int wordLen = strlen(word);
    
    // Try every position and direction
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (canPlaceHorizontal(board, m, n, word, wordLen, i, j, 1) ||
                canPlaceHorizontal(board, m, n, word, wordLen, i, j, -1) ||
                canPlaceVertical(board, m, n, word, wordLen, i, j, 1) ||
                canPlaceVertical(board, m, n, word, wordLen, i, j, -1)) {
                return true;
            }
        }
    }
    
    return false;
}

int main() {
    char* board[] = {"# #", "  #", "#c "};
    int boardColSize[] = {3, 3, 3};
    char word[] = "abc";
    
    bool result = placeWordInCrossword(board, 3, boardColSize, word);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × w)

For each of the m×n cells, we potentially check word placement in 4 directions, each taking O(w) time where w is word length

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables and direction vectors

✓ Linear Space

Constraints

m == board.length
n == board[i].length
1 ≤ m × n ≤ 2 × 10⁵
1 ≤ word.length ≤ max(m, n)
board[i][j] is either ' ', '#', or a lowercase English letter
word consists of lowercase English letters only

29.0K Views

Medium Frequency

~25 min Avg. Time

854 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

Systematic Position and Direction Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler