2452-WordsWithinTwoEditsOfDictionary.go

package main

// 2452. Words Within Two Edits of Dictionary
// 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.

// Example 1:
// Input: queries = ["word","note","ants","wood"], dictionary = ["wood","joke","moat"]
// Output: ["word","note","wood"]
// Explanation:
// - Changing the 'r' in "word" to 'o' allows it to equal the dictionary word "wood".
// - Changing the 'n' to 'j' and the 't' to 'k' in "note" changes it to "joke".
// - It would take more than 2 edits for "ants" to equal a dictionary word.
// - "wood" can remain unchanged (0 edits) and match the corresponding dictionary word.
// Thus, we return ["word","note","wood"].

// Example 2:
// Input: queries = ["yes"], dictionary = ["not"]
// Output: []
// Explanation:
// Applying any two edits to "yes" cannot make it equal to "not". Thus, we return an empty array.

// Constraints:
//     1 <= queries.length, dictionary.length <= 100
//     n == queries[i].length == dictionary[j].length
//     1 <= n <= 100
//     All queries[i] and dictionary[j] are composed of lowercase English letters.

import "fmt"

func twoEditWords(queries []string, dictionary []string) []string {
    helper := func(word string) bool {
        for _, d := range dictionary {
            if len(word) != len(d) { continue }
            i, count := 0, 0
            for i < len(word) {
                if word[i] != d[i] { count++ }
                if count > 2 { break }
                i++
            }
            if count <= 2 { return true }
        }
        return false
    }
    res := []string{}
    for _, q := range queries {
        if helper(q) {
            res = append(res, q)
        }
    }
    return res
}

func main() {
    // Example 1:
    // Input: queries = ["word","note","ants","wood"], dictionary = ["wood","joke","moat"]
    // Output: ["word","note","wood"]
    // Explanation:
    // - Changing the 'r' in "word" to 'o' allows it to equal the dictionary word "wood".
    // - Changing the 'n' to 'j' and the 't' to 'k' in "note" changes it to "joke".
    // - It would take more than 2 edits for "ants" to equal a dictionary word.
    // - "wood" can remain unchanged (0 edits) and match the corresponding dictionary word.
    // Thus, we return ["word","note","wood"].
    fmt.Println(twoEditWords([]string{"word","note","ants","wood"}, []string{"wood","joke","moat"})) // ["word","note","wood"]
    // Example 2:
    // Input: queries = ["yes"], dictionary = ["not"]
    // Output: []
    // Explanation:
    // Applying any two edits to "yes" cannot make it equal to "not". Thus, we return an empty array.
    fmt.Println(twoEditWords([]string{"yes"}, []string{"not"})) // []

    fmt.Println(twoEditWords([]string{"bluefrog"}, []string{"leetcode"})) // []
    fmt.Println(twoEditWords([]string{"bluefrog"}, []string{"frewu"})) // []
    fmt.Println(twoEditWords([]string{"frewu"}, []string{"leetcode"})) // []
}