# Leetcode – String Matching in an Array Solution

The “String Matching in an Array” problem on Leetcode is a fascinating problem that poses an interesting challenge involving string manipulation and search algorithms. This comprehensive article aims to provide a thorough examination of the problem, along with different methodologies to solve it, while diving deep into the Python language’s features and nuances.

1. Understanding the Problem Statement
2. Initial Thoughts and Strategies
3. Brute-Force Solution
4. Trie-Based Solution
5. KMP Algorithm Solution
6. Time and Space Complexity Analysis
7. Testing the Solution
8. Conclusion

## 1. Understanding the Problem Statement

The problem asks us to find all the strings from a given list of strings that are substrings of other strings in that list.

### Constraints and Assumptions

• 1 <= words.length <= 100
• 1 <= words[i].length <= 30
• words[i] contains only lowercase English letters.
• It’s guaranteed that words[i] will be unique.

## 2. Initial Thoughts and Strategies

The first thing that comes to mind is to check each string against all other strings, but this would require nested loops, leading to a quadratic time complexity. However, given the problem’s constraints, this might be acceptable. Other more complex solutions include using a Trie or the Knuth-Morris-Pratt (KMP) algorithm.

## 3. Brute-Force Solution

In the simplest approach, we can use nested loops to compare each string against all other strings.

Python Code:

def stringMatching(words):
result = []
for i in range(len(words)):
for j in range(len(words)):
if i != j and words[i] in words[j]:
result.append(words[i])
break
return result

## 4. Trie-Based Solution

Tries can be used to store strings in such a way that common prefixes are represented by shared branches. While inserting a string, we can check whether it is a prefix of another string in the Trie, or vice versa.

Python Code:

class TrieNode:
def __init__(self):
self.children = {}
self.isEndOfWord = False

def insert(root, word, result):
node = root
isSub = True
for ch in word:
if ch not in node.children:
isSub = False
node.children[ch] = TrieNode()
node = node.children[ch]
node.isEndOfWord = True
if isSub:  # if this word is a prefix of another
result.append(word)
else:  # check if other words are prefixes of this word
node = root
for ch in word:
if node.isEndOfWord:
result.append(word[:len(word) - len(ch) + 1])
node = node.children[ch]

def stringMatching(words):
root = TrieNode()
result = []
for word in words:
insert(root, word, result)
return result

## 5. KMP Algorithm Solution

The Knuth-Morris-Pratt algorithm is a text-searching algorithm that can be adapted to solve this problem efficiently. However, given the constraints of the problem, implementing KMP may be overkill.

## 6. Time and Space Complexity Analysis

• Brute-Force Approach: O(n^2 * m), where n is the number of words and m is the average length of words. Space Complexity is O(1).
• Trie-Based Approach: Time Complexity is O(n * m), and Space Complexity is also O(n * m).

## 7. Testing the Solution

Key test cases include:

• A list of words where no word is a substring of another.
• A list of words where all words are substrings of one long word.
• A list of words with multiple valid answers.

## 8. Conclusion

The “String Matching in an Array” problem offers a classic case of trading off between time complexity and implementation complexity. For small input sizes, a simple brute-force approach might suffice, while Trie-based solutions could be more efficient for larger input sizes.