Words Within Two Edits of Dictionary

Words Within Two Edits of Dictionary - Problem

You are given two string arrays, queries and dictionary. All words in each array comprise of lowercase English letters and have the same length.

In one edit you can take a word from queries, and change any letter in it to any other letter. Find all words from queries that, after a maximum of two edits, equal some word from dictionary.

Return a list of all words from queries, that match with some word from dictionary after a maximum of two edits. Return the words in the same order they appear in queries.

Input & Output

Example 1 — Basic Case

$ Input: queries = ["word","note","ants","wood"], dictionary = ["wood","joke","moat"]

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

💡 Note: "word" → "wood" (1 edit: r→o), "note" → "joke" (1 edit: n→j), "wood" → "wood" (0 edits), "ants" needs 3 edits minimum

Example 2 — Two Edits Required

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

› Output: []

💡 Note: "yes" → "not" requires 3 edits (y→n, e→o, s→t), which exceeds the maximum of 2

Example 3 — Multiple Matches

$ Input: queries = ["leet","code"], dictionary = ["lead","cool"]

› Output: ["leet","code"]

💡 Note: "leet" → "lead" (2 edits: e→a, t→d), "code" → "cool" (2 edits: d→l, e→l)

Constraints

1 ≤ queries.length, dictionary.length ≤ 100
1 ≤ queries[i].length, dictionary[i].length ≤ 100
queries[i] and dictionary[i] consist of only lowercase English letters
All queries[i] and dictionary[i] have the same length

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18

The key insight is that we only need to count character differences between words. The most efficient approach is brute force with early termination - compare each query word with every dictionary word and stop counting when differences exceed 2. Time: O(n*m*k), Space: O(1).

Common Approaches

✓ Brute Force Comparison

⏱️ Time: O(n*m*k) Space: O(1)

For each word in queries, iterate through all words in dictionary and count character differences. If differences ≤ 2, add to result.

Early Termination Optimization

⏱️ Time: O(n*m*k) Space: O(1)

Improve brute force by stopping character comparison as soon as we find more than 2 differences. This saves unnecessary comparisons.

Hash Set for Dictionary Lookup

⏱️ Time: O(n*k²*26²) Space: O(m*k)

Convert dictionary to hash set for faster lookups, then for each query word generate all possible words within 2 edits and check if they exist in the set.

Brute Force Comparison — Algorithm Steps

Step 1: For each query word
Step 2: Check against all dictionary words
Step 3: Count character differences
Step 4: Add to result if differences ≤ 2

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Word

Take first query word 'word'

Compare All

Check against each dictionary word

Count Diffs

Count character differences ≤ 2

Code -

solution.c — C

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

char** solution(char** queries, int queriesSize, char** dictionary, int dictSize, int* returnSize) {
    char** result = (char**)malloc(queriesSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        int found = 0;
        for (int j = 0; j < dictSize; j++) {
            int diffCount = 0;
            for (int k = 0; k < strlen(queries[i]); k++) {
                if (queries[i][k] != dictionary[j][k]) {
                    diffCount++;
                    if (diffCount > 2) {
                        break;
                    }
                }
            }
            
            if (diffCount <= 2) {
                result[*returnSize] = (char*)malloc((strlen(queries[i]) + 1) * sizeof(char));
                strcpy(result[*returnSize], queries[i]);
                (*returnSize)++;
                found = 1;
                break;
            }
        }
    }
    
    return result;
}

void parseStringArray(const char* str, char*** arr, int* size) {
    *size = 0;
    char* temp = (char*)malloc(strlen(str) + 1);
    strcpy(temp, str);
    
    // Count strings
    char* p = temp;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    int count = 0;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == '"') {
            count++;
            p++;
            while (*p && *p != '"') {
                if (*p == '\\') p++; // Skip escaped chars
                p++;
            }
            if (*p == '"') p++;
        } else if (*p != ']' && *p != '\0') {
            p++;
        }
    }
    
    *arr = (char**)malloc(count * sizeof(char*));
    *size = 0;
    
    // Parse strings
    free(temp);
    temp = (char*)malloc(strlen(str) + 1);
    strcpy(temp, str);
    p = temp;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']' && *size < count) {
        while (*p == ' ' || *p == ',') p++;
        if (*p == '"') {
            p++; // Skip opening quote
            char* start = p;
            int len = 0;
            while (*p && *p != '"') {
                len++;
                p++;
            }
            (*arr)[*size] = (char*)malloc((len + 1) * sizeof(char));
            strncpy((*arr)[*size], start, len);
            (*arr)[*size][len] = '\0';
            (*size)++;
            if (*p == '"') p++;
        } else if (*p != ']' && *p != '\0') {
            p++;
        }
    }
    
    free(temp);
}

int main() {
    char line1[10000];
    char line2[10000];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    char** queries;
    char** dictionary;
    int queriesSize, dictSize;
    
    parseStringArray(line1, &queries, &queriesSize);
    parseStringArray(line2, &dictionary, &dictSize);
    
    int returnSize;
    char** result = solution(queries, queriesSize, dictionary, dictSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < queriesSize; i++) {
        free(queries[i]);
    }
    free(queries);
    
    for (int i = 0; i < dictSize; i++) {
        free(dictionary[i]);
    }
    free(dictionary);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m*k)

n queries × m dictionary words × k character comparisons

✓ Linear Growth

Space Complexity

O(1)

Only using variables, result list not counted as extra space

✓ Linear Space

12.0K Views

Medium Frequency

~15 min Avg. Time

450 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 Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler