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
2026-08-23 08:47:12 +00:00 · 2025-12-31 07:44:52 +08:00
parent 45e1295241
commit 2778a6f9c7
1284 changed files with 71557 additions and 3275 deletions
@@ -0,0 +1,33 @@
+/**
+ * File: ListNode.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+public class ListNode: Hashable {
+    public var val: Int // Node value
+    public var next: ListNode? // Successor node reference
+
+    public init(x: Int) {
+        val = x
+    }
+
+    public static func == (lhs: ListNode, rhs: ListNode) -> Bool {
+        lhs.val == rhs.val && lhs.next.map { ObjectIdentifier($0) } == rhs.next.map { ObjectIdentifier($0) }
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(val)
+        hasher.combine(next.map { ObjectIdentifier($0) })
+    }
+
+    public static func arrToLinkedList(arr: [Int]) -> ListNode? {
+        let dum = ListNode(x: 0)
+        var head: ListNode? = dum
+        for val in arr {
+            head?.next = ListNode(x: val)
+            head = head?.next
+        }
+        return dum.next
+    }
+}
@@ -0,0 +1,20 @@
+/**
+ * File: Pair.swift
+ * Created Time: 2023-06-28
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Key-value pair */
+public class Pair: Equatable {
+    public var key: Int
+    public var val: String
+
+    public init(key: Int, val: String) {
+        self.key = key
+        self.val = val
+    }
+
+    public static func == (lhs: Pair, rhs: Pair) -> Bool {
+        lhs.key == rhs.key && lhs.val == rhs.val
+    }
+}
@@ -0,0 +1,93 @@
+/**
+ * File: PrintUtil.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+public enum PrintUtil {
+    private class Trunk {
+        var prev: Trunk?
+        var str: String
+
+        init(prev: Trunk?, str: String) {
+            self.prev = prev
+            self.str = str
+        }
+    }
+
+    public static func printLinkedList(head: ListNode) {
+        var head: ListNode? = head
+        var list: [String] = []
+        while head != nil {
+            list.append("\(head!.val)")
+            head = head?.next
+        }
+        print(list.joined(separator: " -> "))
+    }
+
+    public static func printTree(root: TreeNode?) {
+        printTree(root: root, prev: nil, isRight: false)
+    }
+
+    private static func printTree(root: TreeNode?, prev: Trunk?, isRight: Bool) {
+        if root == nil {
+            return
+        }
+
+        var prevStr = "    "
+        let trunk = Trunk(prev: prev, str: prevStr)
+
+        printTree(root: root?.right, prev: trunk, isRight: true)
+
+        if prev == nil {
+            trunk.str = "———"
+        } else if isRight {
+            trunk.str = "/———"
+            prevStr = "   |"
+        } else {
+            trunk.str = "\\———"
+            prev?.str = prevStr
+        }
+
+        showTrunks(p: trunk)
+        print(" \(root!.val)")
+
+        if prev != nil {
+            prev?.str = prevStr
+        }
+        trunk.str = "   |"
+
+        printTree(root: root?.left, prev: trunk, isRight: false)
+    }
+
+    private static func showTrunks(p: Trunk?) {
+        if p == nil {
+            return
+        }
+
+        showTrunks(p: p?.prev)
+        print(p!.str, terminator: "")
+    }
+
+    public static func printHashMap<K, V>(map: [K: V]) {
+        for (key, value) in map {
+            print("\(key) -> \(value)")
+        }
+    }
+
+    public static func printHeap(queue: [Int]) {
+        print("Heap array representation:", terminator: "")
+        print(queue)
+        print("Heap tree representation:")
+        let root = TreeNode.listToTree(arr: queue)
+        printTree(root: root)
+    }
+
+    public static func printMatrix<T>(matrix: [[T]]) {
+        print("[")
+        for row in matrix {
+            print("  \(row),")
+        }
+        print("]")
+    }
+}
@@ -0,0 +1,71 @@
+/**
+ * File: TreeNode.swift
+ * Created Time: 2023-01-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Binary tree node class */
+public class TreeNode {
+    public var val: Int // Node value
+    public var height: Int // Node height
+    public var left: TreeNode? // Reference to left child node
+    public var right: TreeNode? // Reference to right child node
+
+    /* Constructor */
+    public init(x: Int) {
+        val = x
+        height = 0
+    }
+
+    // For the serialization encoding rules, please refer to:
+    // https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
+    // Array representation of binary tree:
+    // [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]
+    // Linked list representation of binary tree:
+    //             /——— 15
+    //         /——— 7
+    //     /——— 3
+    //    |    \——— 6
+    //    |        \——— 12
+    // ——— 1
+    //     \——— 2
+    //        |    /——— 9
+    //         \——— 4
+    //             \——— 8
+
+    /* Deserialize a list into a binary tree: recursion */
+    private static func listToTreeDFS(arr: [Int?], i: Int) -> TreeNode? {
+        if i < 0 || i >= arr.count || arr[i] == nil {
+            return nil
+        }
+        let root = TreeNode(x: arr[i]!)
+        root.left = listToTreeDFS(arr: arr, i: 2 * i + 1)
+        root.right = listToTreeDFS(arr: arr, i: 2 * i + 2)
+        return root
+    }
+
+    /* Deserialize a list into a binary tree */
+    public static func listToTree(arr: [Int?]) -> TreeNode? {
+        listToTreeDFS(arr: arr, i: 0)
+    }
+
+    /* Serialize a binary tree into a list: recursion */
+    private static func treeToListDFS(root: TreeNode?, i: Int, res: inout [Int?]) {
+        if root == nil {
+            return
+        }
+        while i >= res.count {
+            res.append(nil)
+        }
+        res[i] = root?.val
+        treeToListDFS(root: root?.left, i: 2 * i + 1, res: &res)
+        treeToListDFS(root: root?.right, i: 2 * i + 2, res: &res)
+    }
+
+    /* Serialize a binary tree into a list */
+    public static func treeToList(root: TreeNode?) -> [Int?] {
+        var res: [Int?] = []
+        treeToListDFS(root: root, i: 0, res: &res)
+        return res
+    }
+}
@@ -0,0 +1,32 @@
+/**
+ * File: Vertex.swift
+ * Created Time: 2023-02-19
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Vertex class */
+public class Vertex: Hashable {
+    public var val: Int
+
+    public init(val: Int) {
+        self.val = val
+    }
+
+    public static func == (lhs: Vertex, rhs: Vertex) -> Bool {
+        lhs.val == rhs.val
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(val)
+    }
+
+    /* Input value list vals, return vertex list vets */
+    public static func valsToVets(vals: [Int]) -> [Vertex] {
+        vals.map { Vertex(val: $0) }
+    }
+
+    /* Input vertex list vets, return value list vals */
+    public static func vetsToVals(vets: [Vertex]) -> [Int] {
+        vets.map { $0.val }
+    }
+}