feat: i18n update

Author: rennzhang

src/codeTemplates/backtrack.js

@@ -65,18 +65,30 @@ module.exports = () => ({
           text: `
           const visited = {}
           function backtrack(i) {
-              if (满足特定条件）{
+              // 如果满足条件
+              if (Meet certain conditions) {
                   // 返回结果 or 退出搜索空间
+                  // return result or exit search space
               }
           
-              visited[i] = true // 将当前状态标为已搜索
-              dosomething(i) // 对i做一些操作
-              for (根据i能到达的下个状态j) {
-                  if (!visited[j]) { // 如果状态j没有被搜索过
+              // 将当前状态标为已搜索
+              // mark the current state as searched
+              visited[i] = true
+              // 对i做一些操作
+              // do something with i
+              dosomething(i) 
+              
+              // for (根据i能到达的下个状态j) {
+              for (The next state j that can be reached based on i.) {
+                // 如果状态j没有被搜索过
+                // if state j has not been searched
+                  if (!visited[j]) { 
                       dfs(j)
                   }
               }
-              undo(i) // 恢复i
+              // 恢复i
+              // restore i
+              undo(i) 
           }
           backtrack(0)
           `,

src/codeTemplates/hand-writing.js

@@ -20,7 +20,9 @@ module.exports = () => ({
           language: "py",
           text: `
 # 1. 归并排序（推荐！其他排序方法都不推荐在竞赛中使用）
+# 1. Merge sort (recommended! None of the other ranking methods are recommended for use in contests)
 # 归并排序乞丐版
+# Merge sort beggar version
 class Solution:
     def sortArray(self, nums: List[int]) -> List[int]:
         def mergeSort(l, r):
@@ -49,6 +51,7 @@ class Solution:
         mergeSort(0, len(nums) - 1)
         return nums
 # 归并排序优化版
+# Merge sort optimization version
 class Solution:
     def sortArray(self, nums: List[int]) -> List[int]:
         temp = [0] * len(nums)
@@ -83,7 +86,9 @@ class Solution:
         return nums
 
 # 2. 快速排序
+# 2. Quick sort
 # 快速排序乞丐版
+# Quick sort beggar version
 class Solution:
     def sortArray(self, nums: List[int]) -> List[int]:
         temp = [0] * len(nums)
@@ -98,6 +103,7 @@ class Solution:
 
         return quickSort(nums)
 # 快速排序优化版
+# Quick sort optimization version
 class Solution:
     def sortArray(self, nums: List[int]) -> List[int]:
         temp = [0] * len(nums)
@@ -126,6 +132,7 @@ class Solution:
         return nums
 
 # 3. 插入排序
+# 3. Insertion sort
 class Solution:
     def sortArray(self, nums: List[int]) -> List[int]:
         n = len(nums)
@@ -139,6 +146,7 @@ class Solution:
         return nums
 
 # 4. 选择排序
+# 4. Selection sort
 class Solution:
     def sortArray(self, nums: List[int]) -> List[int]:
         n = len(nums)
@@ -151,6 +159,7 @@ class Solution:
         return nums
 
 # 5. 冒泡排序
+# 5. Bubble sort
 class Solution:
     def sortArray(self, nums: List[int]) -> List[int]:
         n = len(nums)
@@ -179,6 +188,7 @@ class Solution:
           language: "py",
           text: `
 # 1. 归并排序（推荐！其他排序方法都不推荐在竞赛中使用）
+# 1. Merge sort (recommended! None of the other ranking methods are recommended for use in contests)
 class Solution:
     def sortList(self, head: ListNode) -> ListNode:
         def mergeSort(head: ListNode) -> ListNode:
@@ -213,9 +223,11 @@ class Solution:
 
         return mergeSort(head)
 # 2. 快速排序
+# 2. Quick sort
 class Solution:
     def sortList(self, head):
         # ��坏情况也是 n ^ 2 ，因此面试或者竞赛不建议使用
+        # The worst case is also n ^ 2, so it is not recommended to use it in interviews or competitions
         def quickSort(head, end):
      
         if head != end:
@@ -226,12 +238,15 @@ class Solution:
         def partition(head, end):
             # p1是写指针，p2是读指针
             # 最终 p1 是大的链表的头， head 是小的链表的头
+            # p1 is the write pointer, p2 is the read pointer
+            # Finally, p1 is the head of the larger linked list, and head is the head of the smaller linked list
             pivot_val = head.val
             p1, p2 = head, head.next
 
             while p2 != end:
                 if p2.val < pivot_val:
                     # 相当于数组的 append 方法
+                    # Equivalent to the append method of an array
                     p1 = p1.next
                     p1.val, p2.val = p2.val, p1.val
                 p2 = p2.next
@@ -241,6 +256,7 @@ class Solution:
         quickSort(head, None)
         return head
 # 3. 插入排序
+# 3. Insertion sort
 class Solution:
     def sortList(self, head):
         if head == None or head.next == None:
@@ -252,21 +268,26 @@ class Solution:
         cur = head
         while cur:
             # 准备将 last 插入到合适位置
+            # Prepare to insert last into the appropriate position
             last = cur.next
             if last and last.val < cur.val:
                 # 从 dummy 到 cur 线性遍历找第一个满足条件的位置并插入
+                # Linearly traverse from dummy to cur to find the first position that meets the conditions and insert
                 while pre.next and pre.next.val < last.val:
                     pre = pre.next
                 tmp = pre.next
                 pre.next = last
-                cur.next = last.next  # 别忘了这个，否则成环
+                # 别忘了这个，否则成环
+                # Don't forget this, otherwise it will become a ring
+                cur.next = last.next  
                 last.next = tmp
                 pre = dummy
             else:
                 cur = last
 
         return dummy.next
 # 4. 选择排序
+# 4. Selection sort
 class Solution:
     def sortList(self, head):
         temp = head
@@ -282,6 +303,7 @@ class Solution:
             temp = temp.next
         return head
 # 5. 冒泡排序
+# 5. Bubble sort
 class Solution:
     def sortList(self, head):
         if not head:

src/codeTemplates/prime.js

@@ -2,7 +2,9 @@ const { t } = require("../locales");
 
 const pyCode = `
 MAXN = int(1e5)
-flag = [True] * (MAXN + 10) # if flag[i] is true, then i is prime
+# 如果 flag[i] 为 true，表示 i 是质数
+# if flag[i] is true, then i is prime
+flag = [True] * (MAXN + 10) 
 flag[0], flag[1] = False, False
 for i in range(2, int(MAXN ** 0.5) + 1):
     if flag[i]: