Merge branch 'neetcode-gh:main' into main

Author: CarlosGuzman01

articles/add-bold-tag-in-string.md

@@ -0,0 +1,161 @@
+## 1. Mark Bold Characters
+
+::tabs-start
+
+```python
+class Solution:
+    def addBoldTag(self, s: str, words: List[str]) -> str:
+        n = len(s)
+        bold = [False] * n
+        
+        for word in words:
+            start = s.find(word)
+            while start != -1:
+                for i in range(start, start + len(word)):
+                    bold[i] = True
+                    
+                start = s.find(word, start + 1)
+
+        open_tag = "<b>"
+        close_tag = "</b>"
+        ans = []
+        
+        for i in range(n):
+            if bold[i] and (i == 0 or not bold[i - 1]):
+                ans.append(open_tag)
+                
+            ans.append(s[i])
+            
+            if bold[i] and (i == n - 1 or not bold[i + 1]):
+                ans.append(close_tag)
+        
+        return "".join(ans)
+```
+
+```java
+class Solution {
+    public String addBoldTag(String s, String[] words) {
+        int n = s.length();
+        boolean[] bold = new boolean[n];
+        
+        for (String word: words) {
+            int start = s.indexOf(word);
+            while (start != -1) {
+                for (int i = start; i < start + word.length(); i++) {
+                    bold[i] = true;
+                }
+                
+                start = s.indexOf(word, start + 1);
+            }
+        }
+        
+        String openTag = "<b>";
+        String closeTag = "</b>";
+        StringBuilder ans = new StringBuilder();
+        
+        for (int i = 0; i < n; i++) {
+            if (bold[i] && (i == 0 || !bold[i - 1])) {
+                ans.append(openTag);
+            }
+            
+            ans.append(s.charAt(i));
+            
+            if (bold[i] && (i == n - 1 || !bold[i + 1])) {
+                ans.append(closeTag);
+            }
+        }
+        
+        return ans.toString();
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string addBoldTag(string s, vector<string>& words) {
+        int n = s.size();
+        vector<bool> bold(n);
+        
+        for (string word: words) {
+            int start = s.find(word);
+            while (start != -1) {
+                for (int i = start; i < start + word.size(); i++) {
+                    bold[i] = true;
+                }
+                
+                start = s.find(word, start + 1);
+            }
+        }
+        
+        string openTag = "<b>";
+        string closeTag = "</b>";
+        string ans = "";
+        
+        for (int i = 0; i < n; i++) {
+            if (bold[i] && (i == 0 || !bold[i - 1])) {
+                ans += openTag;
+            }
+            
+            ans += s[i];
+            
+            if (bold[i] && (i == n - 1 || !bold[i + 1])) {
+                ans += closeTag;
+            }
+        }
+        
+        return ans;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @param {string[]} words
+     * @return {string}
+     */
+    addBoldTag(s, words) {
+        const n = s.length;
+        const bold = new Array(n).fill(false);
+        
+        for (const word of words) {
+            let start = s.indexOf(word);
+            while (start !== -1) {
+                for (let i = start; i < start + word.length; i++) {
+                    bold[i] = true;
+                }
+                start = s.indexOf(word, start + 1);
+            }
+        }
+        
+        const openTag = "<b>";
+        const closeTag = "</b>";
+        const ans = [];
+        
+        for (let i = 0; i < n; i++) {
+            if (bold[i] && (i === 0 || !bold[i - 1])) {
+                ans.push(openTag);
+            }
+            ans.push(s[i]);
+            if (bold[i] && (i === n - 1 || !bold[i + 1])) {
+                ans.push(closeTag);
+            }
+        }
+        
+        return ans.join("");
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+The time complexity may differ between languages. It is dependent on how the built-in method is implemented.
+For this analysis, we will assume that we are using Java.
+
+- Time complexity: $O(m \cdot (n^2 \cdot k - n \cdot k^2))$
+- Space complexity: $O(n)$
+
+>  Where $n$ is `s.length`, $m$ is `words.length`, and $k$ is the average length of the words.

articles/anagram-groups.md

@@ -1,5 +1,20 @@
 ## 1. Sorting
 
+### Intuition
+
+Anagrams become identical when their characters are sorted.  
+For example, `"eat"`, `"tea"`, and `"ate"` all become `"aet"` after sorting.  
+By using the sorted version of each string as a key, we can group all anagrams together.  
+Strings that share the same sorted form must be anagrams, so placing them in the same group is both natural and efficient.
+
+### Algorithm
+
+1. Create a hash map where each key is the sorted version of a string, and the value is a list of strings belonging to that anagram group.
+2. Iterate through each string in the input list:
+   - Sort the characters of the string to form a key.
+   - Append the original string to the list corresponding to this key.
+3. After processing all strings, return all values from the hash map, which represent the grouped anagrams.
+
 ::tabs-start
 
 ```python
@@ -153,6 +168,23 @@ class Solution {
 
 ## 2. Hash Table
 
+### Intuition
+
+Instead of sorting each string, we can represent every string by the frequency of its characters.  
+Since the problem uses lowercase English letters, a fixed-size array of length `26` can capture how many times each character appears.  
+Two strings are anagrams if and only if their frequency arrays are identical.  
+By using this frequency array (converted to a tuple so it can be a dictionary key), we can group all strings that share the same character counts.
+
+### Algorithm
+
+1. Create a hash map where each key is a `26`-length tuple representing character frequencies, and each value is a list of strings belonging to that anagram group.
+2. For each string in the input:
+   - Initialize a frequency array of size `26` with all zeros.
+   - For each character in the string, increment the count at the corresponding index.
+   - Convert the frequency array to a tuple and use it as the key.
+   - Append the string to the list associated with this key.
+3. After processing all strings, return all the lists stored in the hash map.
+
 ::tabs-start
 
 ```python