Words Within Two Edits of Dictionary - Practice Coding Problems

Words Within Two Edits of Dictionary - Problem

You're given two string arrays: queries and dictionary. All words in both arrays consist of lowercase English letters and have the same length.

In one edit operation, you can take any word from queries and change exactly one letter to any other letter. Your task is to find all words from queries that can be transformed to match some word in the dictionary using at most two edits.

Goal: Return a list of all words from queries that match with some dictionary word after a maximum of two edits. Preserve the original order from queries.

Example: If queries = ["word", "note"] and dictionary = ["world", "note"], then "word" needs 1 edit to become "world", and "note" needs 0 edits (exact match).

Input & Output

example_1.py — Basic Example

$ Input: queries = ["word", "note", "ants", "wood"] dictionary = ["world", "leetcode", "note", "wood"]

› Output: ["word", "note", "wood"]

💡 Note: "word" differs from "world" by 1 character (d→l), "note" matches exactly (0 edits), and "wood" matches exactly. "ants" would need more than 2 edits to match any dictionary word.

example_2.py — All Match

$ Input: queries = ["yes"] dictionary = ["not"]

› Output: []

💡 Note: "yes" differs from "not" in all 3 positions (y≠n, e≠o, s≠t), requiring 3 edits which exceeds the limit of 2.

example_3.py — Edge Case

$ Input: queries = ["abc", "def"] dictionary = ["abc", "ghi", "aef"]

› Output: ["abc", "def"]

💡 Note: "abc" matches exactly with dictionary word "abc" (0 edits). "def" can become "aef" with 1 edit (d→a).

Visualization

Tap to expand

Understanding the Visualization

Take Query Word

Start with a word from the queries array

Compare Characters

Go through each position and count differences with dictionary words

Early Termination

Stop counting if differences exceed 2 (optimization)

Decision

Add to result if any dictionary word is within 2 edits

Key Takeaway

🎯 Key Insight: Since all words have the same length, we only need to count character differences at corresponding positions. No complex dynamic programming needed - just simple character comparison with early termination when differences exceed 2!

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

n queries × m dictionary words × k character comparisons, but with better constants

✓ Linear Growth

Space Complexity

O(m)

Space for dictionary hash set containing m words

✓ Linear Space

Constraints

1 ≤ queries.length, dictionary.length ≤ 1000
queries[i].length = dictionary[j].length for all valid i, j
1 ≤ queries[i].length ≤ 100
All queries[i] and dictionary[j] consist of lowercase English letters only

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses a straightforward comparison method with early termination optimization. For each query word, we compare it against every dictionary word by counting character differences. The key insight is that since all words have the same length, we only need to count position-wise character mismatches. The algorithm stops counting as soon as differences exceed 2, making it efficient in practice with O(n×m×k) time complexity where k is the word length.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Optimization	O(n × m × k)	O(m)	Use hash set for dictionary lookup with optimized difference counting
Brute Force (Nested Loops)	O(n × m × k)	O(1)	Compare each query word with every dictionary word by counting character differences

Hash Set Optimization — Algorithm Steps

Convert dictionary array to hash set for faster lookups
For each query word, iterate through dictionary set
Count character differences with early termination
If differences ≤ 2, add to result and break
Return the collected results

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert dictionary to set

Organize dictionary words for better access

Process each query

Check query against dictionary with optimization

Early termination

Stop counting when differences exceed 2

Collect results

Add matching words to result array

Code -

solution.c — C

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

int countDifferences(const char* word1, const char* word2) {
    int differences = 0;
    int len = strlen(word1);
    for (int i = 0; i < len; i++) {
        if (word1[i] != word2[i]) {
            differences++;
            if (differences > 2) return differences;
        }
    }
    return differences;
}

bool isWithinTwoEdits(const char* query, char** dictionary, int dictionarySize) {
    for (int i = 0; i < dictionarySize; i++) {
        if (countDifferences(query, dictionary[i]) <= 2) {
            return true;
        }
    }
    return false;
}

char** twoEditWords(char** queries, int queriesSize, char** dictionary, int dictionarySize, int* returnSize) {
    char** result = (char**)malloc(queriesSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        if (isWithinTwoEdits(queries[i], dictionary, dictionarySize)) {
            // Allocate memory for the string and copy
            int len = strlen(queries[i]);
            result[*returnSize] = (char*)malloc((len + 1) * sizeof(char));
            strcpy(result[*returnSize], queries[i]);
            (*returnSize)++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

n queries × m dictionary words × k character comparisons, but with better constants

✓ Linear Growth

Space Complexity

O(m)

Space for dictionary hash set containing m words

✓ Linear Space

Constraints

1 ≤ queries.length, dictionary.length ≤ 1000
queries[i].length = dictionary[j].length for all valid i, j
1 ≤ queries[i].length ≤ 100
All queries[i] and dictionary[j] consist of lowercase English letters only

26.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Set Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler