Generating parantheses code using iterative approach

Author: nightmare10123

backtracking/generate_parentheses_iterative.py

@@ -1,44 +1,47 @@
 """
-    Generate all valid combinations of parentheses (Iterative Approach).
+    >>> generate_parentheses_iterative(1)
+    ['()']
+
+    >>> generate_parentheses_iterative(0)
+    ['']
+
+Generate all valid combinations of parentheses (Iterative Approach).
 
-    The algorithm works as follows:
-    1. Initialize an empty list to store the combinations.
-    2. Initialize a stack to keep track of partial combinations.
-    3. Start with empty string and push it onstack along with the counts of '(' and ')'.
+The algorithm works as follows:
+1. Initialize an empty list to store the combinations.
+2. Initialize a stack to keep track of partial combinations.
+3. Start with empty string and push it onstack along with the counts of '(' and ')'.
 
-    4. While the stack is not empty:
-        a. Pop a partial combination and its open and close counts from the stack.
-        b. If the combination length is equal to 2*n, add it to the result.
-        c. If open count is < n, push new combination with added '(' onto the stack.
-        d. If close count < open count, push new combination with added ')' on stack.
-    5. Return the result containing all valid combinations.
+4. While the stack is not empty:
+    a. Pop a partial combination and its open and close counts from the stack.
+    b. If the combination length is equal to 2*n, add it to the result.
+    c. If open count is < n, push new combination with added '(' onto the stack.
+    d. If close count < open count, push new combination with added ')' on stack.
+5. Return the result containing all valid combinations.
 
-    Args:
-        n (int): The desired length of the parentheses combinations
+Args:
+    n (int): The desired length of the parentheses combinations
 
-    Returns:
-        list: A list of strings representing valid combinations of parentheses
+Returns:
+    list: A list of strings representing valid combinations of parentheses
 
-    Time Complexity:
-        O(2^(2n))
+Time Complexity:
+    O(2^(2n))
 
-    Space Complexity:
-        O(2^(2n))
+Space Complexity:
+    O(2^(2n))
 """
 
 
-def generate_parentheses(n: int) -> list:
+def generate_parentheses_iterative(length: int = 0) -> list:
     """
-    >>> generate_parentheses(3)
+    >>> generate_parentheses_iterative(3)
     ['()()()', '()(())', '(())()', '(()())', '((()))']
 
-    >>> generate_parentheses(2)
+    >>> generate_parentheses_iterative(2)
     ['()()', '(())']
 
-    >>> generate_parentheses(1)
-    ['()']
-
-    >>> generate_parentheses(0)
+    >>> generate_parentheses_iterative()
     ['']
 
     """
@@ -51,23 +54,19 @@ def generate_parentheses(n: int) -> list:
     while stack:
         current_combination, open_count, close_count = stack.pop()
 
-        if len(current_combination) == 2 * n:
+        if len(current_combination) == 2 * length:
             result.append(current_combination)
         else:
-            if open_count < n:
+            if open_count < length:
                 stack.append((current_combination + "(", open_count + 1, close_count))
             if close_count < open_count:
                 stack.append((current_combination + ")", open_count, close_count + 1))
 
     return result
 
 
-def main() -> None:
-    print(generate_parentheses(4))
-
-
 if __name__ == "__main__":
     import doctest
 
     doctest.testmod()
-    main()
+    print(generate_parentheses_iterative(3))