Merge branch 'master' of https://github.com/leetcode-pp/leetcode-cheat

Author: robot

src/codeTemplates/backtrack.js

@@ -1,49 +1,62 @@
+const { t } = require("../locales");
 module.exports = () => ({
   logo: require("../imgs/backtrack.svg"),
-  title: "回溯",
+  // title: "回溯",
+  title: t("Locale.codeTemplate.backtrack.title"),
   list: [
     {
-      text: "标准回溯（伪代码）",
+      // text: "标准回溯（伪代码）",
+      text: t("Locale.codeTemplate.backtrack.item1"),
       problems: [
         {
           id: "combination-sum",
-          title: "39. 组合总和",
+          // title: "39. 组合总和",
+          title: t("Locale.problem.39"),
         },
         {
-          title: "40. 组合总和 II",
+          // title: "40. 组合总和 II",
+          title: t("Locale.problem.40"),
           id: "combination-sum-ii",
         },
         {
-          title: "46. 全排列",
+          // title: "46. 全排列",
+          title: t("Locale.problem.46"),
           id: "permutations",
         },
         {
-          title: "47. 全排列 II",
+          // title: "47. 全排列 II",
+          title: t("Locale.problem.47"),
           id: "permutations-ii",
         },
         {
           id: "N-Queens-II",
-          title: "52. N 皇后 II",
+          // title: "52. N 皇后 II",
+          title: t("Locale.problem.52"),
         },
         {
           id: "subsets",
-          title: "78. 子集",
+          // title: "78. 子集",
+          title: t("Locale.problem.78"),
         },
         {
           id: "subsets-ii",
-          title: "90. 子集 II",
+          // title: "90. 子集 II",
+          title: t("Locale.problem.90"),
         },
         {
           id: "path-sum-ii",
-          title: "113. 路径总和 II",
+          // title: "113. 路径总和 II",
+          title: t("Locale.problem.113"),
         },
         {
           id: "palindrome-partitioning",
-          title: "131. 分割回文串",
+          // title: "131. 分割回文串",
+          title: t("Locale.problem.131"),
         },
         {
           id: "maximum-score-words-formed-by-letters",
-          title: "1255. 得分最高的单词集合",
+          // title: "1255. 得分最高的单词集合",
+          title: t("Locale.problem.1255"),
         },
       ],
       codes: [
@@ -52,34 +65,49 @@ 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)
           `,
         },
       ],
     },
     {
-      text: "笛卡尔积优化",
+      // text: "笛卡尔积优化",
+      text: t("Locale.codeTemplate.backtrack.item2"),
       problems: [
         {
           id: "word-break-ii",
-          title: "140. 单词拆分 II",
+          // title: "140. 单词拆分 II",
+          title: t("Locale.problem.140"),
         },
         {
           id: "ambiguous-coordinates",
-          title: "816. 模糊坐标",
+          // title: "816. 模糊坐标",
+          title: t("Locale.problem.816"),
         },
       ],
       codes: [

src/codeTemplates/bfs.js

@@ -1,22 +1,27 @@
 import bfsLogo from "../imgs/bfs.svg";
+const { t } = require("../locales");
 
 export default () => ({
   title: "BFS",
   logo: bfsLogo,
   list: [
     {
-      text: "带层信息",
+      // text: "带层信息",
+      text: t("Locale.codeTemplate.BFS.item1"),
       problems: [
         {
-          title: "513.找树左下角的值",
+          // title: "513.找树左下角的值",
+          title: t("Locale.problem.513"),
           id: "find-bottom-left-tree-value",
         },
         {
-          title: "662. 二叉树最大宽度",
+          // title: "662. 二叉树最大宽度",
+          title: t("Locale.problem.662"),
           id: "maximum-width-of-binary-tree",
         },
         {
-          title: "863. 二叉树中所有距离为 K 的结点",
+          // title: "863. 二叉树中所有距离为 K 的结点",
+          title: t("Locale.problem.863"),
           id: "all-nodes-distance-k-in-binary-tree",
         },
       ],
@@ -27,15 +32,20 @@ export default () => ({
         class Solution:
           def bfs(k):
               # 使用双端队列，而不是数组。因为数组从头部删除元素的时间复杂度为 N，双端队列的底层实现其实是链表。
+              # Utilize a double-ended queue instead of an array, as the time complexity for removing elements from the head of an array is O(N), whereas a double-ended queue, implemented as a linked list, offers a more efficient alternative.
               queue = collections.deque([root])
               # 记录层数
+              # Record the level or depth.
               steps = 0
               # 需要返回的节点
+              # The nodes to return.
               ans = []
               # 队列不空，生命不止！
+              # While the queue is not empty, we continue.
               while queue:
                   size = len(queue)
                   # 遍历当前层的所有节点
+                  # Traverse all the nodes in the current level.
                   for _ in range(size):
                       node = queue.popleft()
                       if (steps == k) ans.append(node)
@@ -44,17 +54,20 @@ export default () => ({
                       if node.left:
                           queue.append(node.left)
                   # 遍历完当前层所有的节点后 steps + 1
+                  # After traversing all the nodes in the current level, steps + 1.
                   steps += 1
               return ans
               `,
         },
       ],
     },
     {
-      text: "不带层信息",
+      // text: "不带层信息",
+      text: t("Locale.codeTemplate.BFS.item2"),
       problems: [
         {
-          title: "116. 填充每个节点的下一个右侧节点指针",
+          // title: "116. 填充每个节点的下一个右侧节点指针",
+          title: t("Locale.problem.116"),
           id: "populating-next-right-pointers-in-each-node",
         },
       ],
@@ -65,12 +78,15 @@ export default () => ({
         class Solution:
           def bfs(k):
               # 使用双端队列，而不是数组。因为数组从头部删除元素的时间复杂度为 N，双端队列的底层实现其实是链表。
+              # Utilize a double-ended queue instead of an array, as the time complexity for removing elements from the head of an array is O(N), whereas a double-ended queue, implemented as a linked list, offers a more efficient alternative.
               queue = collections.deque([root])
               # 队列不空，生命不止！
+              # While the queue is not empty, we continue.
               while queue:
                   node = queue.popleft()
                   # 由于没有记录 steps，因此我们肯定是不需要根据层的信息去判断的。否则就用带层的模板了。
-                  if (node 是我们要找到的) return node
+                  # Since we don't record steps, we don't need to judge based on the level information. Otherwise, we would use the template with level information.
+                  if (node is what we are looking for) return node
                   if node.right:
                       queue.append(node.right)
                   if node.left: