feat(algorithms, stack): decode string)

Author: BrianLusina

algorithms/stack/decode_string/README.md

@@ -32,3 +32,53 @@ Output: "abcabccdcdcdef"
 - Stack
 - Recursion
 
+## Solution
+
+The essence of this approach lies in recognizing that the problem is naturally suited for a stack-based solution. When
+decoding a string, we need to handle nested and sequential patterns, and a stack allows us to manage these layers
+effectively. By pushing and popping elements on the stack as we encounter brackets, we can keep track of the substrings
+and their repeat counts. This method ensures we decode the string from the innermost nested structure outward,
+maintaining the correct order and repetition. To achieve this, we process each character in the string in the following
+way:
+
+- **Digits**: Represent how many times a substring is repeated.
+- **Open bracket ([)**: Marks the start of a new substring and saves the current state by pushing the current substring
+  and repeat count onto stacks and then resetting them for a new segment.
+- **Close bracket (])**: Ends the current substring, repeats it as specified, and appends it to the previous substring.
+- **Letters**: Build the current substring being processed.
+
+This solution handles nested and consecutive encoding strings by utilizing the stack to track previously processed
+substrings and their associated repeat counts. The final decoded string is constructed by combining all parts accumulated
+in the stacks.
+
+Here’s the step-by-step implementation of the solution:
+
+- Initialize two empty stacks: count_stack for storing repeat counts and string_stack for storing intermediate strings.
+- Initialize current as an empty string. This will hold the currently decoded string segment.
+- Initialize k as 0: This will store multi-digit numbers representing repeat counts.
+- Iterate through each character char in the input string s:
+  - If char is a digit:
+    - Update k to accumulate the digit into a multi-digit number by performing k = 10 * k + int(char).
+  - If char is a '[':
+    - Push k onto count_stack to save the current repeat count. 
+    - Push current onto string_stack to save the current string segment. 
+    - Reset k to 0 for the next repeat count. 
+    - Reset current to an empty string to start decoding the new segment.
+  - If char is a’]’:
+    - Pop the last string segment from string_stack and store it in decoded_string. 
+    - Pop the last repeat count from count_stack and store it in num. 
+    - Update current by appending current * num to decoded_string, repeating the decoded segment, and combining it with
+      the previous string.
+  - If char is a regular character:
+    - Append char to current, adding it to the currently decoded string segment.
+- After processing all characters, current will contain the fully decoded string.
+
+### Time Complexity
+
+The time complexity of this solution is O(n∗m∗k), where n is the length of the input string, m is the length of current,
+and k is the maximum multiplier encountered during the decoding.
+
+### Space Complexity
+
+The space complexity of this solution is O(c+d), where c is the number of alphabets and d is the number of digits in the
+input string.

algorithms/stack/decode_string/__init__.py

@@ -2,18 +2,61 @@ def decode_string(s: str) -> str:
     stack, result, num = [], "", 0
 
     for char in s:
+        # If the character is a digit, update num to accumulate the multi-digit number
         if char.isdigit():
             num = num * 10 + int(char)
         elif char == "[":
+            # When encountering '[', push num and result onto the stack
             stack.append(result)
             stack.append(num)
+            # Reset num and result for the new segment inside the brackets
             result = ""
             num = 0
         elif char == "]":
-            p_num = stack.pop()
-            p_str = stack.pop()
-            result = p_str + p_num * result
+            # When encountering ']', pop the last string and count from the stack
+            popped_num = stack.pop()
+            popped_str = stack.pop()
+            # Repeat the result string popped_num times and append it to the popped string
+            result = popped_str + popped_num * result
         else:
+            # For regular characters, append them to the result string
             result += char
 
+    # Return the fully decoded string after processing all characters
     return result
+
+
+def decode_string_2(s: str) -> str:
+    # Initialize two stacks: one for numbers (repeat counts) and one for strings
+    count_stack = []
+    string_stack = []
+
+    # Initialize an empty string to hold the current decoded segment
+    current = ""
+    # Initialize k to accumulate multi-digit numbers for repeat counts
+    k = 0
+
+    # Loop through each character in the input string s
+    for char in s:
+        if char.isdigit():
+            # If the character is a digit, update k to accumulate the multi-digit number
+            k = 10 * k + int(char)
+        elif char == "[":
+            # When encountering '[', push k onto the count stack and current onto the string stack
+            count_stack.append(k)
+            string_stack.append(current)
+            # Reset k and current for the new segment inside the brackets
+            k = 0
+            current = ""
+        elif char == "]":
+            # When encountering ']', pop the last string and count from the stacks
+            popped_string = string_stack.pop()
+            num = count_stack.pop()
+            # Repeat the current string num times and append it to the popped string
+            current = popped_string + current * num
+        else:
+            # For regular characters, append them to the current string
+            current += char
+
+    # Return the fully decoded string after processing all characters
+    return current

algorithms/stack/decode_string/test_decode_string.py

@@ -1,28 +1,25 @@
 import unittest
+from parameterized import parameterized
+from algorithms.stack.decode_string import decode_string, decode_string_2
 
-from . import decode_string
+DECODE_STRING_TEST_CASES = [
+    ("3[a]2[bc]", "aaabcbc"),
+    ("3[a2[c]]", "accaccacc"),
+    ("2[abc]3[cd]ef", "abcabccdcdcdef"),
+    ("1[abc]2[def]3[ghi]", "abcdefdefghighighi"),
+    ("1[a2[b3[c4[d]]]]", "abcddddcddddcddddbcddddcddddcdddd"),
+]
 
 
 class DecodeStringTestCases(unittest.TestCase):
-    def test_one(self):
-        """should return aaabcbc from 3[a]2[bc]"""
-        encoded_string = "3[a]2[bc]"
-        expected = "aaabcbc"
+    @parameterized.expand(DECODE_STRING_TEST_CASES)
+    def test_decode_string(self, encoded_string: str, expected: str):
         actual = decode_string(encoded_string)
         self.assertEqual(expected, actual)
 
-    def test_two(self):
-        """should return aaabcbc from 3[a2[c]]"""
-        encoded_string = "3[a2[c]]"
-        expected = "accaccacc"
-        actual = decode_string(encoded_string)
-        self.assertEqual(expected, actual)
-
-    def test_three(self):
-        """should return abcabccdcdcdef from 2[abc]3[cd]ef"""
-        encoded_string = "2[abc]3[cd]ef"
-        expected = "abcabccdcdcdef"
-        actual = decode_string(encoded_string)
+    @parameterized.expand(DECODE_STRING_TEST_CASES)
+    def test_decode_string_2(self, encoded_string: str, expected: str):
+        actual = decode_string_2(encoded_string)
         self.assertEqual(expected, actual)
 
 

algorithms/stack/reverse_string/__init__.py

@@ -36,14 +36,14 @@ def reverse_string(text: str) -> str:
 def reverse_string_char_array(s: List[str]) -> None:
     """
     Reverses a character array in place using two-pointer technique.
-    
+
     Reference: https://leetcode.com/problems/reverse-string/
-    
+
     Complexity:
     Where n is the length of the input list
     Time: O(n), each character is visited at most once
     Space: O(1), only two pointers used, no extra data structures
-    
+
     Args:
         s (List[str]): character array to reverse in place
     Returns: