Translate all code to English (#1836)

* Review the EN heading format.

* Fix pythontutor headings.

* Fix pythontutor headings.

* bug fixes

* Fix headings in **/summary.md

* Revisit the CN-to-EN translation for Python code using Claude-4.5

* Revisit the CN-to-EN translation for Java code using Claude-4.5

* Revisit the CN-to-EN translation for Cpp code using Claude-4.5.

* Fix the dictionary.

* Fix cpp code translation for the multipart strings.

* Translate Go code to English.

* Update workflows to test EN code.

* Add EN translation for C.

* Add EN translation for CSharp.

* Add EN translation for Swift.

* Trigger the CI check.

* Revert.

* Update en/hash_map.md

* Add the EN version of Dart code.

* Add the EN version of Kotlin code.

* Add missing code files.

* Add the EN version of JavaScript code.

* Add the EN version of TypeScript code.

* Fix the workflows.

* Add the EN version of Ruby code.

* Add the EN version of Rust code.

* Update the CI check for the English version  code.

* Update Python CI check.

* Fix cmakelists for en/C code.

* Fix Ruby comments

en/codes/python/chapter_dynamic_programming/min_path_sum.py

@@ -8,37 +8,37 @@ from math import inf
 
 
 def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -> int:
-    """Minimum path sum: Brute force search"""
+    """Minimum path sum: Brute-force search"""
     # If it's the top-left cell, terminate the search
     if i == 0 and j == 0:
         return grid[0][0]
-    # If the row or column index is out of bounds, return a +∞ cost
+    # If row or column index is out of bounds, return +∞ cost
     if i < 0 or j < 0:
         return inf
-    # Calculate the minimum path cost from the top-left to (i-1, j) and (i, j-1)
+    # Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)
     up = min_path_sum_dfs(grid, i - 1, j)
     left = min_path_sum_dfs(grid, i, j - 1)
-    # Return the minimum path cost from the top-left to (i, j)
+    # Return the minimum path cost from top-left to (i, j)
     return min(left, up) + grid[i][j]
 
 
 def min_path_sum_dfs_mem(
     grid: list[list[int]], mem: list[list[int]], i: int, j: int
 ) -> int:
-    """Minimum path sum: Memoized search"""
+    """Minimum path sum: Memoization search"""
     # If it's the top-left cell, terminate the search
     if i == 0 and j == 0:
         return grid[0][0]
-    # If the row or column index is out of bounds, return a +∞ cost
+    # If row or column index is out of bounds, return +∞ cost
     if i < 0 or j < 0:
         return inf
-    # If there is a record, return it
+    # If there's a record, return it directly
     if mem[i][j] != -1:
         return mem[i][j]
-    # The minimum path cost from the left and top cells
+    # Minimum path cost for left and upper cells
     up = min_path_sum_dfs_mem(grid, mem, i - 1, j)
     left = min_path_sum_dfs_mem(grid, mem, i, j - 1)
-    # Record and return the minimum path cost from the top-left to (i, j)
+    # Record and return the minimum path cost from top-left to (i, j)
     mem[i][j] = min(left, up) + grid[i][j]
     return mem[i][j]
 
@@ -55,7 +55,7 @@ def min_path_sum_dp(grid: list[list[int]]) -> int:
     # State transition: first column
     for i in range(1, n):
         dp[i][0] = dp[i - 1][0] + grid[i][0]
-    # State transition: the rest of the rows and columns
+    # State transition: rest of the rows and columns
     for i in range(1, n):
         for j in range(1, m):
             dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]
@@ -71,11 +71,11 @@ def min_path_sum_dp_comp(grid: list[list[int]]) -> int:
     dp[0] = grid[0][0]
     for j in range(1, m):
         dp[j] = dp[j - 1] + grid[0][j]
-    # State transition: the rest of the rows
+    # State transition: rest of the rows
     for i in range(1, n):
         # State transition: first column
         dp[0] = dp[0] + grid[i][0]
-        # State transition: the rest of the columns
+        # State transition: rest of the columns
         for j in range(1, m):
             dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]
     return dp[m - 1]
@@ -86,19 +86,19 @@ if __name__ == "__main__":
     grid = [[1, 3, 1, 5], [2, 2, 4, 2], [5, 3, 2, 1], [4, 3, 5, 2]]
     n, m = len(grid), len(grid[0])
 
-    # Brute force search
+    # Brute-force search
     res = min_path_sum_dfs(grid, n - 1, m - 1)
-    print(f"The minimum path sum from the top-left to the bottom-right corner is {res}")
+    print(f"The minimum path sum from top-left to bottom-right is {res}")
 
-    # Memoized search
+    # Memoization search
     mem = [[-1] * m for _ in range(n)]
     res = min_path_sum_dfs_mem(grid, mem, n - 1, m - 1)
-    print(f"The minimum path sum from the top-left to the bottom-right corner is {res}")
+    print(f"The minimum path sum from top-left to bottom-right is {res}")
 
     # Dynamic programming
     res = min_path_sum_dp(grid)
-    print(f"The minimum path sum from the top-left to the bottom-right corner is {res}")
+    print(f"The minimum path sum from top-left to bottom-right is {res}")
 
     # Space-optimized dynamic programming
     res = min_path_sum_dp_comp(grid)
-    print(f"The minimum path sum from the top-left to the bottom-right corner is {res}")
+    print(f"The minimum path sum from top-left to bottom-right is {res}")