Codestin Search App

Valid Word Square - Problem

Array Matrix Easy

Imagine you have a collection of words arranged in a grid, like a crossword puzzle. Your task is to determine if this grid forms a valid word square - a special arrangement where each row reads exactly the same as its corresponding column.

Given an array of strings words, return true if it forms a valid word square. A sequence of strings forms a valid word square if the k-th row and k-th column read the same string, where 0 ≤ k < max(numRows, numColumns).

Example: If words = ["abcd", "bnrt", "crmy", "dtye"], then:
• Row 0: "abcd" vs Column 0: "abcd" ✓
• Row 1: "bnrt" vs Column 1: "bnrt" ✓
• Row 2: "crmy" vs Column 2: "crmy" ✓
• Row 3: "dtye" vs Column 3: "dtye" ✓

This is a valid word square because each row matches its corresponding column perfectly!

Input & Output

example_1.py — Valid Word Square

$ Input: ["abcd", "bnrt", "crmy", "dtye"]

› Output: true

💡 Note: This forms a perfect word square: Row 0 'abcd' matches Column 0 'abcd', Row 1 'bnrt' matches Column 1 'bnrt', and so on. Each row-column pair is identical.

example_2.py — Invalid Word Square

$ Input: ["abcd", "bnrt", "crm", "dt"]

› Output: false

💡 Note: Row 2 is 'crm' but Column 2 is 'crmd' (taking 3rd character from each row). The lengths don't match, making this invalid.

example_3.py — Single Character Square

$ Input: ["ball", "area", "lead", "lady"]

› Output: false

💡 Note: Row 0 'ball' vs Column 0 'ball' ✓, but Row 1 'area' vs Column 1 'aree' ✗. The second column spells 'aree' not 'area'.

Constraints

1 ≤ words.length ≤ 500
1 ≤ words[i].length ≤ 500
words[i] consists of only lowercase English letters
Matrix dimensions may be uneven - number of rows may differ from maximum column length

Visualization

Tap to expand

Understanding the Visualization

Check Matrix Bounds

Ensure we can access both words[i][j] and words[j][i] safely

Compare Mirror Positions

For each valid (i,j), verify words[i][j] equals words[j][i]

Handle Edge Cases

Account for missing characters when row lengths vary

Return Validation Result

True if all mirror positions match, false otherwise

Key Takeaway

🎯 Key Insight: A word square is valid when it's symmetric across the main diagonal - each character at position (i,j) must equal the character at position (j,i).

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 25 f Meta 18

The key insight is to validate that each row matches its corresponding column. The optimal approach compares characters at positions (i,j) and (j,i) directly without building intermediate strings, achieving O(n²) time with O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Compare Every Row-Column Pair)	O(n²)	O(n)	Compare each row with its corresponding column character by character

Brute Force (Compare Every Row-Column Pair) — Algorithm Steps

Determine the maximum dimension (max of rows and columns)
For each position k from 0 to max dimension:
Build the k-th column string by collecting words[i][k] for all valid i
Get the k-th row string (or empty if k >= number of rows)
Compare the row and column strings - if any don't match, return false
If all comparisons pass, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Matrix Dimensions

Find the maximum between number of rows and maximum word length

Build Column Strings

For each column index, collect characters from all rows at that position

Compare Row vs Column

Check if each row string equals its corresponding column string

Return Result

Return false if any pair doesn't match, true if all pairs match

Code -

solution.c — C

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

bool validWordSquare(char** words, int wordsSize) {
    if (wordsSize == 0 || strlen(words[0]) == 0) {
        return true;
    }
    
    int maxLen = 0;
    for (int i = 0; i < wordsSize; i++) {
        int len = strlen(words[i]);
        if (len > maxLen) {
            maxLen = len;
        }
    }
    
    int maxDim = wordsSize > maxLen ? wordsSize : maxLen;
    
    for (int k = 0; k < maxDim; k++) {
        // Get k-th row
        char* row = k < wordsSize ? words[k] : "";
        
        // Build k-th column
        char col[1000] = {0};
        int colLen = 0;
        for (int i = 0; i < wordsSize; i++) {
            if (k < strlen(words[i])) {
                col[colLen++] = words[i][k];
            }
        }
        col[colLen] = '\0';
        
        if (strcmp(row, col) != 0) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char* words[] = {"ball", "area", "read", "lady"};
    int size = 4;
    printf("%s\n", validWordSquare(words, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We iterate through up to n rows/columns, and for each we may check up to n characters

⚠ Quadratic Growth

Space Complexity

O(n)

We create temporary strings for each column, each potentially of length n

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Compare Every Row-Column Pair) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler