Merge pull request #1397 from sounmind/main

Author: sounmind

encode-and-decode-strings/sounmind.js

@@ -0,0 +1,56 @@
+from typing import List
+
+
+class Solution:
+    # Special character used as delimiter between length and actual string
+    delimiter = "$"
+
+    def encode(self, strs: List[str]) -> str:
+        """
+        Encodes a list of strings into a single string.
+        Format: [length]$[string][length]$[string]...
+        """
+        encoded = []
+        # Encode each word using the format: length + delimiter + word
+        for word in strs:
+            # Convert word length to string, add delimiter, then add the word itself
+            encoded.append(f"{len(word)}{self.delimiter}{word}")
+
+        # Join all encoded elements into a single string and return
+        return "".join(encoded)
+
+    def decode(self, encoded: str) -> List[str]:
+        """
+        Decodes a single string back to the original list of strings.
+        """
+        decoded = []  # List to store the decoded strings
+        current_index = 0  # Pointer to track current position in the encoded string
+
+        # Process the encoded string until we reach the end
+        while current_index < len(encoded):
+            # Starting from current_index, find the position of delimiter
+            delimiter_index = current_index
+
+            # Move forward until we find the delimiter character
+            while encoded[delimiter_index] != self.delimiter:
+                delimiter_index += 1
+
+            # Extract and convert the length prefix to integer
+            word_length = int(encoded[current_index:delimiter_index])
+
+            # Calculate the start position of the word (after the delimiter)
+            word_start = delimiter_index + 1
+
+            # Calculate the end position of the word
+            word_end = word_start + word_length
+
+            # Extract the word using the calculated positions
+            word = encoded[word_start:word_end]
+
+            # Add the decoded word to our result list
+            decoded.append(word)
+
+            # Move the current index to the end of this word for the next iteration
+            current_index = word_end
+
+        return decoded

encode-and-decode-strings/sounmind.py

@@ -0,0 +1,28 @@
+from collections import defaultdict
+from typing import List
+
+
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        # Dictionary to store anagram groups using character frequency as key
+        anagram_groups = defaultdict(list)
+
+        for word in strs:
+            # Create a frequency array for 26 lowercase English letters
+            char_frequency = [0] * 26
+
+            # Count frequency of each character in the current word
+            for char in word:
+                # Convert character to 0-25 index (a=0, b=1, ..., z=25)
+                char_index = ord(char) - ord("a")
+                char_frequency[char_index] += 1
+
+            # Convert the frequency array to tuple (to make it hashable as dictionary key)
+            # Words with identical character frequencies are anagrams
+            freq_key = tuple(char_frequency)
+
+            # Add the current word to its corresponding anagram group
+            anagram_groups[freq_key].append(word)
+
+        # Return all the anagram groups as a list of lists
+        return list(anagram_groups.values())

group-anagrams/sounmind.js

@@ -0,0 +1,47 @@
+from typing import Optional
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def mergeTwoLists(
+        self, list1: Optional[ListNode], list2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+        """
+        Merge two sorted linked lists and return the head of the merged list.
+
+        Args:
+            list1: Head of the first sorted linked list
+            list2: Head of the second sorted linked list
+
+        Returns:
+            Head of the merged sorted linked list
+        """
+        # Handle edge cases
+        if not list1:
+            return list2
+        if not list2:
+            return list1
+
+        # Create a dummy head to simplify the merging process
+        dummy_head = ListNode()
+        current = dummy_head
+
+        # Merge nodes from both lists in sorted order
+        while list1 and list2:
+            if list1.val < list2.val:
+                current.next = list1
+                list1 = list1.next
+            else:
+                current.next = list2
+                list2 = list2.next
+            current = current.next
+
+        # Attach remaining nodes from either list
+        current.next = list1 if list1 else list2
+
+        return dummy_head.next