[alphaorderly] WEEK 05 Solutions

Author: alphaorderly

best-time-to-buy-and-sell-stock/alphaorderly.py

@@ -0,0 +1,21 @@
+"""
+Time Complexity: O(n)
+Space Complexity: O(1)
+
+- Single Pass approach
+- Use a variable to store the least price
+- Use a variable to store the maximum profit
+- Update the maximum profit whenever the current price is greater than the least price
+"""
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        N = len(prices)
+
+        least = prices[0]
+        ans = 0
+
+        for i in range(1, N):
+            ans = max(ans, prices[i] - least)
+            least = min(least, prices[i])
+
+        return ans

encode-and-decode-strings/alphaorderly.py

@@ -0,0 +1,58 @@
+"""
+Time Complexity: O(n)
+Space Complexity: O(n)
+
+### Wrong Approach ( NEVER USE IT )
+- Uses eval() on potentially untrusted input, which is a major security risk.
+- If s or strs can be controlled or modified externally, arbitrary code execution is possible.
+- This is for illustration only; never use eval for decoding in production code.
+
+- Encodes by converting the list of strings to its string representation using str().
+- Decodes by evaluating that string with eval(), reconstructing the original list.
+"""
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        return str(strs)
+
+    def decode(self, s: str) -> List[str]:
+        return eval(s)
+
+"""
+Time Complexity: O(n)
+Space Complexity: O(n)
+
+- Encodes the list of strings by prefixing each string with its length and a separator ("_"), then concatenating.
+- Decodes by parsing each length, extracting the separated string accordingly.
+- Does not use eval, so this approach is safe.
+"""
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        strs = [str(len(s)) + "_" + s for s in strs]
+        return "".join(strs)
+
+    def decode(self, s: str) -> List[str]:
+        ans = []
+        N = len(s)
+        index = 0
+        size = 0
+
+        word_part = False
+
+        while index < N:
+            ch = s[index]
+            if not word_part:
+                if ch == "_":
+                    if size == 0:
+                        ans.append("")
+                    else:
+                        word_part = True
+                else:
+                    size = (size * 10) + int(ch)
+                index += 1
+            else:
+                ans.append(s[index : index + size])
+                index += size
+                size = 0
+                word_part = False
+
+        return ans

group-anagrams/alphaorderly.py

@@ -0,0 +1,44 @@
+"""
+Time Complexity: O(n * k log k)
+Space Complexity: O(n * k)
+
+- Iterate through each word in the input list
+- Use a dictionary to group anagrams by their sorted tuple of characters as the key
+- For each word, sort its characters and use the resulting tuple as the dictionary key
+- Append the word to the appropriate list in the dictionary
+- Return a list of the grouped anagrams
+"""
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        d = defaultdict(list)
+
+        for word in strs:
+            d[tuple(sorted(word))].append(word)
+
+        return list(d.values())
+
+"""
+Time Complexity: O(n * k)
+Space Complexity: O(n * k)
+
+- Iterate through each word in the input list
+- Use a dictionary to group anagrams; key is a tuple representing character counts
+- For each word, build a character frequency tuple (instead of sorting)
+- This tuple serves as a unique identifier for anagrams
+- Append the word to the appropriate list in the dictionary
+- Return a list of the grouped anagrams
+"""
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        d = defaultdict(list)
+
+        def hash(s: str) -> Tuple[int, ...]:
+            count = [0] * 26
+            for ch in s:
+                count[ord(ch) - ord('a')] += 1
+            return tuple(count)
+
+        for word in strs:
+            d[hash(word)].append(word)
+
+        return list(d.values())

implement-trie-prefix-tree/alphaorderly.py

@@ -0,0 +1,38 @@
+"""
+Time Complexity: O(L), where L is the length of the input string (word or prefix) per operation.
+Space Complexity: O(N), where N is the total number of characters inserted into the trie (all words inserted).
+
+- Each Trie node uses a dictionary to store children nodes for each character.
+- The `end` flag indicates whether the current node represents the end of a complete word.
+- The `insert` method adds a word to the trie by sequentially creating/following nodes for each character.
+- The `search` method checks for the presence of a full word in the trie by traversing nodes for each character and checking the `end` flag at the last character.
+- The `startsWith` method checks if there exists any word in the trie with the given prefix by traversing nodes for each character in the prefix.
+"""
+class Trie:
+
+    def __init__(self):
+        self.children = dict()
+        self.end = False
+
+    def insert(self, word: str) -> None:
+        node = self
+
+        for ch in word:
+            if ch not in node.children:
+                node.children[ch] = Trie()
+            node = node.children[ch]
+
+        node.end = True
+
+    def search(self, word: str, isPrefix: bool = False) -> bool:
+        node = self
+
+        for ch in word:
+            if ch not in node.children:
+                return False
+            node = node.children[ch]
+
+        return True if isPrefix else node.end
+
+    def startsWith(self, prefix: str) -> bool:
+        return self.search(word=prefix, isPrefix=True)

word-break/alphaorderly.py

@@ -0,0 +1,71 @@
+"""
+Time Complexity: O(n * k * m)
+    - n = len(s)
+    - k = number of words in wordDict
+    - m = average word length in wordDict
+
+    At each index in s, we may check every word in wordDict and for each, compare up to m characters.
+
+Space Complexity: O(n)
+    - n = len(s), due to recursion stack and memoization table (one entry per possible starting index).
+
+- Uses top-down dynamic programming with memoization (via lru_cache).
+- The helper function dp(index) returns True if s[index:] can be fully segmented into words from wordDict.
+- Base case: If index == len(s), then the entire string is successfully segmented.
+- For each call, iterate through all words in the dictionary and check if s[index:] begins with that word.
+- If a match is found, recursively check for the remainder of the string starting after the matched word.
+- Return True as soon as any valid segmentation is found.
+- Return False if no segmentation is possible for this index.
+"""
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        @lru_cache()
+        def dp(index: int) -> bool:
+            if index == len(s):
+                return True
+
+            for word in wordDict:
+                if len(s) - index < len(word):
+                    continue
+
+                if s[index:].startswith(word) and dp(index + len(word)):
+                    return True
+
+            return False
+
+        return dp(0)
+
+"""
+Time Complexity: O(n * k * m)
+    - n = len(s)
+    - k = number of words in wordDict
+    - m = average word length in wordDict
+
+    For every index in s, we consider each word in wordDict and, for each, match up to m characters.
+
+Space Complexity: O(n)
+    - n = len(s), required for the dp array.
+
+- Uses bottom-up dynamic programming.
+- The dp array indicates whether a prefix of s up to index can be segmented into words from wordDict.
+- Base case: dp[0] = 1, since the empty string can always be segmented.
+- For each index, iterate through all words, and for each, check if s[index - W : index] equals the word, assuming index >= W and dp[index - W] is True.
+- If a match is found, update dp[index] to reflect that segmentation.
+- Finally, return True if dp[-1] is set, indicating the entire string can be segmented; otherwise, return False.
+"""
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        S = len(s)
+
+        dp = [0] * (S + 1)
+        dp[0] = 1
+
+        for index in range(S + 1):
+            for word in wordDict:
+                W = len(word)
+                if index < W or dp[index - W] == 0:
+                    continue
+                if s[index - W :].startswith(word):
+                    dp[index] = dp[index - W]
+
+        return bool(dp[-1])