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/docs/chapter_divide_and_conquer/divide_and_conquer.md

@@ -1,4 +1,4 @@
-# Divide and conquer algorithms
+# Divide and Conquer Algorithms
 
 <u>Divide and conquer</u> is a very important and common algorithm strategy. Divide and conquer is typically implemented based on recursion, consisting of two steps: "divide" and "conquer".
 
@@ -12,7 +12,7 @@ As shown in the figure below, "merge sort" is one of the typical applications of
 
 ![Divide and conquer strategy of merge sort](divide_and_conquer.assets/divide_and_conquer_merge_sort.png)
 
-## How to determine divide and conquer problems
+## How to Determine Divide and Conquer Problems
 
 Whether a problem is suitable for solving with divide and conquer can usually be determined based on the following criteria.
 
@@ -26,13 +26,13 @@ Clearly, merge sort satisfies these three criteria.
 2. **Subproblems are independent**: Each subarray can be sorted independently (subproblems can be solved independently).
 3. **Solutions of subproblems can be merged**: Two sorted subarrays (solutions of subproblems) can be merged into one sorted array (solution of the original problem).
 
-## Improving efficiency through divide and conquer
+## Improving Efficiency Through Divide and Conquer
 
 **Divide and conquer can not only effectively solve algorithmic problems but often also improve algorithm efficiency**. In sorting algorithms, quick sort, merge sort, and heap sort are faster than selection, bubble, and insertion sort because they apply the divide and conquer strategy.
 
 This raises the question: **Why can divide and conquer improve algorithm efficiency, and what is the underlying logic**? In other words, why is dividing a large problem into multiple subproblems, solving the subproblems, and merging their solutions more efficient than directly solving the original problem? This question can be discussed from two aspects: operation count and parallel computation.
 
-### Operation count optimization
+### Operation Count Optimization
 
 Taking "bubble sort" as an example, processing an array of length $n$ requires $O(n^2)$ time. Suppose we divide the array into two subarrays from the midpoint as shown in the figure below, the division requires $O(n)$ time, sorting each subarray requires $O((n / 2)^2)$ time, and merging the two subarrays requires $O(n)$ time, resulting in an overall time complexity of:
 
@@ -58,7 +58,7 @@ Going further, **what if we continuously divide the subarrays from their midpoin
 
 Thinking further, **what if we set multiple division points** and evenly divide the original array into $k$ subarrays? This situation is very similar to "bucket sort", which is well-suited for sorting massive amounts of data, with a theoretical time complexity of $O(n + k)$.
 
-### Parallel computation optimization
+### Parallel Computation Optimization
 
 We know that the subproblems generated by divide and conquer are independent of each other, **so they can typically be solved in parallel**. This means divide and conquer can not only reduce the time complexity of algorithms, **but also benefits from parallel optimization by operating systems**.
 
@@ -68,7 +68,7 @@ For example, in the "bucket sort" shown in the figure below, we evenly distribut
 
 ![Parallel computation in bucket sort](divide_and_conquer.assets/divide_and_conquer_parallel_computing.png)
 
-## Common applications of divide and conquer
+## Common Applications of Divide and Conquer
 
 On one hand, divide and conquer can be used to solve many classic algorithmic problems.