Update pascal_triangle.py

Author: lighting9999

matrix/pascal_triangle.py

@@ -1,16 +1,19 @@
 """
-This implementation demonstrates how to generate the elements of a Pascal's triangle.
-The element havingva row index of r and column index of c can be derivedvas follows:
-triangle[r][c] = triangle[r-1][c-1]+triangle[r-1][c]
+This implementation demonstrates how to generate the elements of Pascal's Triangle.
+An element with row index r and column index c can be derived as:
+triangle[r][c] = triangle[r-1][c-1] + triangle[r-1][c]
 
-A Pascal's triangle is a triangular array containing binomial coefficients.
+Pascal's Triangle is a triangular array containing binomial coefficients.
 https://en.wikipedia.org/wiki/Pascal%27s_triangle
 """
 
+from typing import List, Callable
+from timeit import timeit
+
 
 def print_pascal_triangle(num_rows: int) -> None:
     """
-    Print Pascal's triangle for different number of rows
+    Print Pascal's triangle for the specified number of rows
     >>> print_pascal_triangle(5)
         1
        1 1
@@ -20,7 +23,7 @@ def print_pascal_triangle(num_rows: int) -> None:
     """
     triangle = generate_pascal_triangle(num_rows)
     for row_idx in range(num_rows):
-        # Print left spaces
+        # Print leading spaces
         for _ in range(num_rows - row_idx - 1):
             print(end=" ")
         # Print row values
@@ -32,9 +35,9 @@ def print_pascal_triangle(num_rows: int) -> None:
         print()
 
 
-def generate_pascal_triangle(num_rows: int) -> list[list[int]]:
+def generate_pascal_triangle(num_rows: int) -> List[List[int]]:
     """
-    Create Pascal's triangle for different number of rows
+    Generate Pascal's triangle for the specified number of rows
     >>> generate_pascal_triangle(0)
     []
     >>> generate_pascal_triangle(1)
@@ -50,49 +53,46 @@ def generate_pascal_triangle(num_rows: int) -> list[list[int]]:
     >>> generate_pascal_triangle(-5)
     Traceback (most recent call last):
         ...
-    ValueError: The input value of 'num_rows' should be greater than or equal to 0
+    ValueError: Input value 'num_rows' must be >= 0
     >>> generate_pascal_triangle(7.89)
     Traceback (most recent call last):
         ...
-    TypeError: The input value of 'num_rows' should be 'int'
+    TypeError: Input value 'num_rows' must be an integer
     """
 
     if not isinstance(num_rows, int):
-        raise TypeError("The input value of 'num_rows' should be 'int'")
+        raise TypeError("Input value 'num_rows' must be an integer")
 
     if num_rows == 0:
         return []
-    elif num_rows < 0:
-        raise ValueError(
-            "The input value of 'num_rows' should be greater than or equal to 0"
-        )
+    if num_rows < 0:
+        raise ValueError("Input value 'num_rows' must be >= 0")
 
-    triangle: list[list[int]] = []
+    triangle: List[List[int]] = []
     for current_row_idx in range(num_rows):
         current_row = populate_current_row(triangle, current_row_idx)
         triangle.append(current_row)
     return triangle
 
 
-def populate_current_row(triangle: list[list[int]], current_row_idx: int) -> list[int]:
+def populate_current_row(triangle: List[List[int]], current_row_idx: int) -> List[int]:
     """
     >>> triangle = [[1]]
     >>> populate_current_row(triangle, 1)
     [1, 1]
     """
     current_row = [-1] * (current_row_idx + 1)
-    # first and last elements of current row are equal to 1
+    # First and last elements of current row are always 1
     current_row[0], current_row[-1] = 1, 1
     for current_col_idx in range(1, current_row_idx):
         calculate_current_element(
             triangle, current_row, current_row_idx, current_col_idx
         )
     return current_row
 
-
 def calculate_current_element(
-    triangle: list[list[int]],
-    current_row: list[int],
+    triangle: List[List[int]],
+    current_row: List[int],
     current_row_idx: int,
     current_col_idx: int,
 ) -> None:
@@ -103,22 +103,19 @@ def calculate_current_element(
     >>> current_row
     [1, 2, 1]
     """
-    above_to_left_elt = triangle[current_row_idx - 1][current_col_idx - 1]
-    above_to_right_elt = triangle[current_row_idx - 1][current_col_idx]
-    current_row[current_col_idx] = above_to_left_elt + above_to_right_elt
+    above_left = triangle[current_row_idx - 1][current_col_idx - 1]
+    above_right = triangle[current_row_idx - 1][current_col_idx]
+    current_row[current_col_idx] = above_left + above_right
 
 
-def generate_pascal_triangle_optimized(num_rows: int) -> list[list[int]]:
+def generate_pascal_triangle_optimized(num_rows: int) -> List[List[int]]:
     """
-    This function returns a matrix representing the corresponding pascal's triangle
-    according to the given input of number of rows of Pascal's triangle to be generated.
-    It reduces the operations done to generate a row by half
-    by eliminating redundant calculations.
-
-    :param num_rows: Integer specifying the number of rows in the Pascal's triangle
-    :return: 2-D List (matrix) representing the Pascal's triangle
-
-    Return the Pascal's triangle of given rows
+    Returns a matrix representing Pascal's triangle.
+    Reduces operations by half by eliminating redundant calculations.
+    
+    :param num_rows: Number of rows in the Pascal's triangle
+    :return: 2D list representing the Pascal's triangle
+    
     >>> generate_pascal_triangle_optimized(3)
     [[1], [1, 1], [1, 2, 1]]
     >>> generate_pascal_triangle_optimized(1)
@@ -128,29 +125,27 @@ def generate_pascal_triangle_optimized(num_rows: int) -> list[list[int]]:
     >>> generate_pascal_triangle_optimized(-5)
     Traceback (most recent call last):
         ...
-    ValueError: The input value of 'num_rows' should be greater than or equal to 0
+    ValueError: Input value 'num_rows' must be >= 0
     >>> generate_pascal_triangle_optimized(7.89)
     Traceback (most recent call last):
         ...
-    TypeError: The input value of 'num_rows' should be 'int'
+    TypeError: Input value 'num_rows' must be an integer
     """
 
     if not isinstance(num_rows, int):
-        raise TypeError("The input value of 'num_rows' should be 'int'")
+        raise TypeError("Input value 'num_rows' must be an integer")
 
     if num_rows == 0:
         return []
-    elif num_rows < 0:
-        raise ValueError(
-            "The input value of 'num_rows' should be greater than or equal to 0"
-        )
+    if num_rows < 0:
+        raise ValueError("Input value 'num_rows' must be >= 0")
 
-    result: list[list[int]] = [[1]]
+    result: List[List[int]] = [[1]]
 
     for row_index in range(1, num_rows):
         temp_row = [0] + result[-1] + [0]
         row_length = row_index + 1
-        # Calculate the number of distinct elements in a row
+        # Calculate number of distinct elements in row
         distinct_elements = sum(divmod(row_length, 2))
         row_first_half = [
             temp_row[i - 1] + temp_row[i] for i in range(1, distinct_elements + 1)
@@ -162,18 +157,13 @@ def generate_pascal_triangle_optimized(num_rows: int) -> list[list[int]]:
 
     return result
 
-
 def benchmark() -> None:
     """
-    Benchmark multiple functions, with three different length int values.
+    Benchmark functions with different input sizes
     """
-    from collections.abc import Callable
-    from timeit import timeit
-
     def benchmark_a_function(func: Callable, value: int) -> None:
         call = f"{func.__name__}({value})"
         timing = timeit(f"__main__.{call}", setup="import __main__")
-        # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
         print(f"{call:38} -- {timing:.4f} seconds")
 
     for value in range(15):  # (1, 7, 14):