Group anagram

backtracking/generate_parentheses.py

@@ -0,0 +1,77 @@
+"""
+author: Aayush Soni
+Given n pairs of parentheses, write a function to generate all
+combinations of well-formed parentheses.
+Input: n = 2
+Output: ["(())","()()"]
+Leetcode link: https://leetcode.com/problems/generate-parentheses/description/
+"""
+
+
+def backtrack(
+    partial: str, open_count: int, close_count: int, n: int, result: list[str]
+) -> None:
+    """
+    Generate valid combinations of balanced parentheses using recursion.
+
+    :param partial: A string representing the current combination.
+    :param open_count: An integer representing the count of open parentheses.
+    :param close_count: An integer representing the count of close parentheses.
+    :param n: An integer representing the total number of pairs.
+    :param result: A list to store valid combinations.
+    :return: None
+
+    This function uses recursion to explore all possible combinations,
+    ensuring that at each step, the parentheses remain balanced.
+
+    Example:
+    >>> result = []
+    >>> backtrack("", 0, 0, 2, result)
+    >>> result
+    ['(())', '()()']
+    """
+    if len(partial) == 2 * n:
+        # When the combination is complete, add it to the result.
+        result.append(partial)
+        return
+
+    if open_count < n:
+        # If we can add an open parenthesis, do so, and recurse.
+        backtrack(partial + "(", open_count + 1, close_count, n, result)
+
+    if close_count < open_count:
+        # If we can add a close parenthesis (it won't make the combination invalid),
+        # do so, and recurse.
+        backtrack(partial + ")", open_count, close_count + 1, n, result)
+
+
+def generate_parenthesis(n: int) -> list[str]:
+    """
+    Generate valid combinations of balanced parentheses for a given n.
+
+    :param n: An integer representing the number of pairs of parentheses.
+    :return: A list of strings with valid combinations.
+
+    This function uses a recursive approach to generate the combinations.
+
+    Time Complexity: O(2^(2n)) - In the worst case, we have 2^(2n) combinations.
+    Space Complexity: O(n) - where 'n' is the number of pairs.
+
+    Example 1:
+    >>> generate_parenthesis(3)
+    ['((()))', '(()())', '(())()', '()(())', '()()()']
+
+    Example 2:
+    >>> generate_parenthesis(1)
+    ['()']
+    """
+
+    result = []
+    backtrack("", 0, 0, n, result)
+    return result
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

matrix/matrix_prefix_sum.py

@@ -0,0 +1,86 @@
+"""
+Python Program to find prefix sum of a 2D array
+"""
+
+
+def calculate_prefix_sum(matrix: list[list[int]]) -> list[list[int]]:
+    """
+    Calculate the prefix sum of a 2D matrix.
+    Prefix Sum Formula:
+    prefix_sum[i][j] = prefix_sum[i - 1][j] + prefix_sum[i][j - 1]
+    - prefix_sum[i - 1][j - 1] + matrix[i][j]
+
+    :param matrix: A 2D matrix.
+    :return: A matrix containing the prefix sums.
+
+    >>> calculate_prefix_sum([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
+    [[1, 2, 3], [2, 4, 6], [3, 6, 9]]
+
+    >>> calculate_prefix_sum([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    [[1, 3, 6], [5, 12, 21], [12, 27, 45]]
+    """
+    rows = len(matrix)
+    cols = len(matrix[0])
+
+    # Initialize the prefix sum matrix with zeros, with the
+    # same dimensions as the original matrix.
+    prefix_sum = [[0 for _ in range(cols)] for _ in range(rows)]
+
+    # Calculate the prefix sum for the top-left cell.
+    prefix_sum[0][0] = matrix[0][0]
+
+    # Calculate cumulative sums for the first row.
+    for i in range(1, cols):
+        prefix_sum[0][i] = prefix_sum[0][i - 1] + matrix[0][i]
+
+    # Calculate cumulative sums for the first column.
+    for i in range(1, rows):
+        prefix_sum[i][0] = prefix_sum[i - 1][0] + matrix[i][0]
+
+    # Update the values in the cells using the general formula.
+    for i in range(1, rows):
+        for j in range(1, cols):
+            # The value in each cell is the sum of:
+            # - The cell above it
+            # - The cell to the left of it
+            # - Subtracting the overlapping cell
+            # - Adding the value from the original matrix
+            prefix_sum[i][j] = (
+                prefix_sum[i - 1][j]
+                + prefix_sum[i][j - 1]
+                - prefix_sum[i - 1][j - 1]
+                + matrix[i][j]
+            )
+
+    return prefix_sum
+
+
+def display_matrix(matrix: list[list[int]]) -> None:
+    """
+    Display a 2D matrix.
+
+    :param matrix: A 2D matrix.
+
+    Display a 2D matrix by printing each row's elements separated by spaces.
+
+    >>> display_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    1 2 3
+    4 5 6
+    7 8 9
+
+    >>> display_matrix([[10, 20, 30], [40, 50, 60]])
+    10 20 30
+    40 50 60
+    """
+    for row in matrix:
+        # Join the elements of each row with spaces and print the result.
+        print(" ".join(map(str, row)))
+
+
+if __name__ == "__main__":
+    matrix = [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
+    # Calculate the prefix sum of the 2D matrix
+    prefix_sum_matrix = calculate_prefix_sum(matrix)
+
+    # Display the prefix sum matrix
+    display_matrix(prefix_sum_matrix)

strings/group_anagram.py

@@ -0,0 +1,55 @@
+"""
+author: Aayush Soni
+Given an array of strings strs, group the anagrams together.
+You can return the answer in any order.
+
+An Anagram is a word or phrase formed by rearranging the letters of
+a different word or phrase, typically using all the original letters exactly once.
+
+Leetcode link: https://leetcode.com/problems/group-anagrams/description/
+"""
+
+
+def group_anagrams(words: list[str]) -> dict[str, list[str]]:
+    """
+    Group anagrams in a list of words.
+
+    This function takes a list of words and groups them
+    based on whether they are anagrams of each other.
+
+    Examples:
+    >>> group_anagrams(["cat", "dog", "tac", "god", "act"])
+    {'act': ['cat', 'tac', 'act'], 'dgo': ['dog', 'god']}
+
+    >>> group_anagrams(["listen", "silent", "hello", "world"])
+    {'eilnst': ['listen', 'silent'], 'ehllo': ['hello'], 'dlorw': ['world']}
+    """
+
+    grouped_words: dict[str, list[str]] = {}
+
+    # Put all anagram words together in a dictionary
+    # where the key is the sorted word
+    for word in words:
+        sorted_word = "".join(sorted(word))
+        if sorted_word not in grouped_words:
+            grouped_words[sorted_word] = [word]
+        else:
+            grouped_words[sorted_word].append(word)
+
+    return grouped_words
+
+
+if __name__ == "__main__":
+    words = ["cat", "dog", "tac", "god", "act"]
+    groups = group_anagrams(words)
+
+    # Sort the groups for consistent output
+    sorted_groups = sorted(groups)
+
+    for key in sorted_groups:
+        group = groups[key]
+        print(" ".join(group))
+
+    import doctest
+
+    doctest.testmod()