# Solving Leetcode Interviews in Seconds with AI: Words Within Two Edits of Dictionary


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2452" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.  

	# Explanation
	*   **Iterate and Compare:** Iterate through each query word and compare it with every word in the dictionary.
*   **Edit Distance Calculation:** For each query-dictionary word pair, calculate the edit distance (number of differing characters).
*   **Filter and Collect:** If the edit distance is less than or equal to 2, add the query word to the result list.

*   **Time Complexity:** O(Q * D * N), where Q is the number of queries, D is the number of words in the dictionary, and N is the length of each word. **Space Complexity:** O(Q), where Q is the number of queries (for the result list).

```python
def solve():
    queries = ["word","note","ants","wood"]
    dictionary = ["wood","joke","moat"]
    expected = ["word","note","wood"]
    assert find_words(queries, dictionary) == expected

    queries = ["yes"]
    dictionary = ["not"]
    expected = []
    assert find_words(queries, dictionary) == expected

def find_words(queries, dictionary):
    result = []
    for query in queries:
        for word in dictionary:
            diff_count = 0
            for i in range(len(query)):
                if query[i] != word[i]:
                    diff_count += 1
            if diff_count <= 2:
                result.append(query)
                break  # Move to the next query word if a match is found
    return result

	
	# Code
	```python
	def find_words(queries, ditionary):    result = []
    for query in queries:
        for word in dictionary:
            diff_count = 0
            for i in range(len(query)):
                if query[i] != word[i]:
                    diff_count += 1
            if diff_count <= 2:
                result.append(query)
                break
    return result
	```
			
				# Summary
				```