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/c/utils/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_executable(utils
+        common_test.c
+        common.h print_util.h
+        list_node.h tree_node.h
+        uthash.h)

en/codes/c/utils/common.h

@@ -0,0 +1,36 @@
+/**
+ * File: common.h
+ * Created Time: 2022-12-20
+ * Author: MolDuM (moldum@163.com)、Reanon (793584285@qq.com)
+ */
+
+#ifndef COMMON_H
+#define COMMON_H
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <math.h>
+
+#include "list_node.h"
+#include "print_util.h"
+#include "tree_node.h"
+#include "vertex.h"
+
+// hash table lib
+#include "uthash.h"
+
+#include "vector.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // COMMON_H

en/codes/c/utils/common_test.c

@@ -0,0 +1,35 @@
+/**
+ * File: include_test.c
+ * Created Time: 2023-01-10
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "common.h"
+
+void testListNode() {
+    int nums[] = {2, 3, 5, 6, 7};
+    int size = sizeof(nums) / sizeof(int);
+    ListNode *head = arrToLinkedList(nums, size);
+    printLinkedList(head);
+}
+
+void testTreeNode() {
+    int nums[] = {1, 2, 3, INT_MAX, 5, 6, INT_MAX};
+    int size = sizeof(nums) / sizeof(int);
+    TreeNode *root = arrayToTree(nums, size);
+
+    // print tree
+    printTree(root);
+
+    // tree to arr
+    int *arr = treeToArray(root, &size);
+    printArray(arr, size);
+}
+
+int main(int argc, char *argv[]) {
+    printf("==testListNode==\n");
+    testListNode();
+    printf("==testTreeNode==\n");
+    testTreeNode();
+    return 0;
+}

en/codes/c/utils/list_node.h

@@ -0,0 +1,59 @@
+/**
+ * File: list_node.h
+ * Created Time: 2023-01-09
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#ifndef LIST_NODE_H
+#define LIST_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Linked list node structure */
+typedef struct ListNode {
+    int val;               // Node value
+    struct ListNode *next; // Reference to next node
+} ListNode;
+
+/* Constructor, initialize a new node */
+ListNode *newListNode(int val) {
+    ListNode *node;
+    node = (ListNode *)malloc(sizeof(ListNode));
+    node->val = val;
+    node->next = NULL;
+    return node;
+}
+
+/* Deserialize array to linked list */
+ListNode *arrToLinkedList(const int *arr, size_t size) {
+    if (size <= 0) {
+        return NULL;
+    }
+
+    ListNode *dummy = newListNode(0);
+    ListNode *node = dummy;
+    for (int i = 0; i < size; i++) {
+        node->next = newListNode(arr[i]);
+        node = node->next;
+    }
+    return dummy->next;
+}
+
+/* Free memory allocated to linked list */
+void freeMemoryLinkedList(ListNode *cur) {
+    // Free memory
+    ListNode *pre;
+    while (cur != NULL) {
+        pre = cur;
+        cur = cur->next;
+        free(pre);
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // LIST_NODE_H

en/codes/c/utils/print_util.h

@@ -0,0 +1,131 @@
+/**
+ * File: print_util.h
+ * Created Time: 2022-12-21
+ * Author: MolDum (moldum@163.com), Reanon (793584285@qq.com)
+ */
+
+#ifndef PRINT_UTIL_H
+#define PRINT_UTIL_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "list_node.h"
+#include "tree_node.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Print array */
+void printArray(int arr[], int size) {
+    if (arr == NULL || size == 0) {
+        printf("[]");
+        return;
+    }
+    printf("[");
+    for (int i = 0; i < size - 1; i++) {
+        printf("%d, ", arr[i]);
+    }
+    printf("%d]\n", arr[size - 1]);
+}
+
+/* Print array */
+void printArrayFloat(float arr[], int size) {
+    if (arr == NULL || size == 0) {
+        printf("[]");
+        return;
+    }
+    printf("[");
+    for (int i = 0; i < size - 1; i++) {
+        printf("%.2f, ", arr[i]);
+    }
+    printf("%.2f]\n", arr[size - 1]);
+}
+
+/* Print linked list */
+void printLinkedList(ListNode *node) {
+    if (node == NULL) {
+        return;
+    }
+    while (node->next != NULL) {
+        printf("%d -> ", node->val);
+        node = node->next;
+    }
+    printf("%d\n", node->val);
+}
+
+typedef struct Trunk {
+    struct Trunk *prev;
+    char *str;
+} Trunk;
+
+Trunk *newTrunk(Trunk *prev, char *str) {
+    Trunk *trunk = (Trunk *)malloc(sizeof(Trunk));
+    trunk->prev = prev;
+    trunk->str = (char *)malloc(sizeof(char) * 10);
+    strcpy(trunk->str, str);
+    return trunk;
+}
+
+void showTrunks(Trunk *trunk) {
+    if (trunk == NULL) {
+        return;
+    }
+    showTrunks(trunk->prev);
+    printf("%s", trunk->str);
+}
+
+/**
+ * Print binary tree
+ * This tree printer is borrowed from TECHIE DELIGHT
+ * https://www.techiedelight.com/c-program-print-binary-tree/
+ */
+void printTreeHelper(TreeNode *node, Trunk *prev, bool isRight) {
+    if (node == NULL) {
+        return;
+    }
+    char *prev_str = "    ";
+    Trunk *trunk = newTrunk(prev, prev_str);
+    printTreeHelper(node->right, trunk, true);
+    if (prev == NULL) {
+        trunk->str = "———";
+    } else if (isRight) {
+        trunk->str = "/———";
+        prev_str = "   |";
+    } else {
+        trunk->str = "\\———";
+        prev->str = prev_str;
+    }
+    showTrunks(trunk);
+    printf("%d\n", node->val);
+
+    if (prev != NULL) {
+        prev->str = prev_str;
+    }
+    trunk->str = "   |";
+
+    printTreeHelper(node->left, trunk, false);
+}
+
+/* Print binary tree */
+void printTree(TreeNode *root) {
+    printTreeHelper(root, NULL, false);
+}
+
+/* Print heap */
+void printHeap(int arr[], int size) {
+    TreeNode *root;
+    printf("Heap array representation:");
+    printArray(arr, size);
+    printf("Heap tree representation:\n");
+    root = arrayToTree(arr, size);
+    printTree(root);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PRINT_UTIL_H

en/codes/c/utils/tree_node.h

@@ -0,0 +1,107 @@
+/**
+ * File: tree_node.h
+ * Created Time: 2023-01-09
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#ifndef TREE_NODE_H
+#define TREE_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <limits.h>
+
+#define MAX_NODE_SIZE 5000
+
+/* Binary tree node structure */
+typedef struct TreeNode {
+    int val;                // Node value
+    int height;             // Node height
+    struct TreeNode *left;  // Left child pointer
+    struct TreeNode *right; // Right child pointer
+} TreeNode;
+
+/* Constructor */
+TreeNode *newTreeNode(int val) {
+    TreeNode *node;
+
+    node = (TreeNode *)malloc(sizeof(TreeNode));
+    node->val = val;
+    node->height = 0;
+    node->left = NULL;
+    node->right = NULL;
+    return node;
+}
+
+// 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, None, 6, 7, 8, 9, None, None, 12, None, None, 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 */
+TreeNode *arrayToTreeDFS(int *arr, int size, int i) {
+    if (i < 0 || i >= size || arr[i] == INT_MAX) {
+        return NULL;
+    }
+    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));
+    root->val = arr[i];
+    root->left = arrayToTreeDFS(arr, size, 2 * i + 1);
+    root->right = arrayToTreeDFS(arr, size, 2 * i + 2);
+    return root;
+}
+
+/* Deserialize a list into a binary tree */
+TreeNode *arrayToTree(int *arr, int size) {
+    return arrayToTreeDFS(arr, size, 0);
+}
+
+/* Serialize a binary tree into a list: recursion */
+void treeToArrayDFS(TreeNode *root, int i, int *res, int *size) {
+    if (root == NULL) {
+        return;
+    }
+    while (i >= *size) {
+        res = realloc(res, (*size + 1) * sizeof(int));
+        res[*size] = INT_MAX;
+        (*size)++;
+    }
+    res[i] = root->val;
+    treeToArrayDFS(root->left, 2 * i + 1, res, size);
+    treeToArrayDFS(root->right, 2 * i + 2, res, size);
+}
+
+/* Serialize a binary tree into a list */
+int *treeToArray(TreeNode *root, int *size) {
+    *size = 0;
+    int *res = NULL;
+    treeToArrayDFS(root, 0, res, size);
+    return res;
+}
+
+/* Free binary tree memory */
+void freeMemoryTree(TreeNode *root) {
+    if (root == NULL)
+        return;
+    freeMemoryTree(root->left);
+    freeMemoryTree(root->right);
+    free(root);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TREE_NODE_H

en/codes/c/utils/vector.h

@@ -0,0 +1,259 @@
+/**
+ * File: vector.h
+ * Created Time: 2023-07-13
+ * Author: Zuoxun (845242523@qq.com)、Gonglja (glj0@outlook.com)
+ */
+
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Define vector type */
+typedef struct vector {
+    int size;     // Current vector size
+    int capacity; // Current vector capacity
+    int depth;    // Current vector depth
+    void **data;  // Pointer array to data
+} vector;
+
+/* Construct vector */
+vector *newVector() {
+    vector *v = malloc(sizeof(vector));
+    v->size = 0;
+    v->capacity = 4;
+    v->depth = 1;
+    v->data = malloc(v->capacity * sizeof(void *));
+    return v;
+}
+
+/* Construct vector with specified size and default value */
+vector *_newVector(int size, void *elem, int elemSize) {
+    vector *v = malloc(sizeof(vector));
+    v->size = size;
+    v->capacity = size;
+    v->depth = 1;
+    v->data = malloc(v->capacity * sizeof(void *));
+    for (int i = 0; i < size; i++) {
+        void *tmp = malloc(sizeof(char) * elemSize);
+        memcpy(tmp, elem, elemSize);
+        v->data[i] = tmp;
+    }
+    return v;
+}
+
+/* Destruct vector */
+void delVector(vector *v) {
+    if (v) {
+        if (v->depth == 0) {
+            return;
+        } else if (v->depth == 1) {
+            for (int i = 0; i < v->size; i++) {
+                free(v->data[i]);
+            }
+            free(v);
+        } else {
+            for (int i = 0; i < v->size; i++) {
+                delVector(v->data[i]);
+            }
+            v->depth--;
+        }
+    }
+}
+
+/* Add element (by copy) to vector tail */
+void vectorPushback(vector *v, void *elem, int elemSize) {
+    if (v->size == v->capacity) {
+        v->capacity *= 2;
+        v->data = realloc(v->data, v->capacity * sizeof(void *));
+    }
+    void *tmp = malloc(sizeof(char) * elemSize);
+    memcpy(tmp, elem, elemSize);
+    v->data[v->size++] = tmp;
+}
+
+/* Pop element from vector tail */
+void vectorPopback(vector *v) {
+    if (v->size != 0) {
+        free(v->data[v->size - 1]);
+        v->size--;
+    }
+}
+
+/* Clear vector */
+void vectorClear(vector *v) {
+    delVector(v);
+    v->size = 0;
+    v->capacity = 4;
+    v->depth = 1;
+    v->data = malloc(v->capacity * sizeof(void *));
+}
+
+/* Get vector size */
+int vectorSize(vector *v) {
+    return v->size;
+}
+
+/* Get vector tail element */
+void *vectorBack(vector *v) {
+    int n = v->size;
+    return n > 0 ? v->data[n - 1] : NULL;
+}
+
+/* Get vector head element */
+void *vectorFront(vector *v) {
+    return v->size > 0 ? v->data[0] : NULL;
+}
+
+/* Get vector element at index pos */
+void *vectorAt(vector *v, int pos) {
+    if (pos < 0 || pos >= v->size) {
+        printf("vectorAt: out of range\n");
+        return NULL;
+    }
+    return v->data[pos];
+}
+
+/* Set vector element at index pos */
+void vectorSet(vector *v, int pos, void *elem, int elemSize) {
+    if (pos < 0 || pos >= v->size) {
+        printf("vectorSet: out of range\n");
+        return;
+    }
+    free(v->data[pos]);
+    void *tmp = malloc(sizeof(char) * elemSize);
+    memcpy(tmp, elem, elemSize);
+    v->data[pos] = tmp;
+}
+
+/* Expand vector capacity */
+void vectorExpand(vector *v) {
+    v->capacity *= 2;
+    v->data = realloc(v->data, v->capacity * sizeof(void *));
+}
+
+/* Shrink vector capacity */
+void vectorShrink(vector *v) {
+    v->capacity /= 2;
+    v->data = realloc(v->data, v->capacity * sizeof(void *));
+}
+
+/* Insert element at vector index pos */
+void vectorInsert(vector *v, int pos, void *elem, int elemSize) {
+    if (v->size == v->capacity) {
+        vectorExpand(v);
+    }
+    for (int j = v->size; j > pos; j--) {
+        v->data[j] = v->data[j - 1];
+    }
+    void *tmp = malloc(sizeof(char) * elemSize);
+    memcpy(tmp, elem, elemSize);
+    v->data[pos] = tmp;
+    v->size++;
+}
+
+/* Delete element at vector index pos */
+void vectorErase(vector *v, int pos) {
+    if (v->size != 0) {
+        free(v->data[pos]);
+        for (int j = pos; j < v->size - 1; j++) {
+            v->data[j] = v->data[j + 1];
+        }
+        v->size--;
+    }
+}
+
+/* Swap vector elements */
+void vectorSwap(vector *v, int i, int j) {
+    void *tmp = v->data[i];
+    v->data[i] = v->data[j];
+    v->data[j] = tmp;
+}
+
+/* Is vector empty */
+bool vectorEmpty(vector *v) {
+    return v->size == 0;
+}
+
+/* Is vector full */
+bool vectorFull(vector *v) {
+    return v->size == v->capacity;
+}
+
+/* Are vectors equal */
+bool vectorEqual(vector *v1, vector *v2) {
+    if (v1->size != v2->size) {
+        printf("size not equal\n");
+        return false;
+    }
+    for (int i = 0; i < v1->size; i++) {
+        void *a = v1->data[i];
+        void *b = v2->data[i];
+        if (memcmp(a, b, sizeof(a)) != 0) {
+            printf("data %d not equal\n", i);
+            return false;
+        }
+    }
+    return true;
+}
+
+/* Sort vector internally */
+void vectorSort(vector *v, int (*cmp)(const void *, const void *)) {
+    qsort(v->data, v->size, sizeof(void *), cmp);
+}
+
+/* Print function, need to pass a function to print variables */
+/* Currently only supports printing vector with depth 1 */
+void printVector(vector *v, void (*printFunc)(vector *v, void *p)) {
+    if (v) {
+        if (v->depth == 0) {
+            return;
+        } else if (v->depth == 1) {
+            if(v->size == 0) {
+                printf("\n");
+                return;
+            }
+            for (int i = 0; i < v->size; i++) {
+                if (i == 0) {
+                    printf("[");
+                } else if (i == v->size - 1) {
+                    printFunc(v, v->data[i]);
+                    printf("]\r\n");
+                    break;
+                }
+                printFunc(v, v->data[i]);
+                printf(",");
+            }
+        } else {
+            for (int i = 0; i < v->size; i++) {
+                printVector(v->data[i], printFunc);
+            }
+            v->depth--;
+        }
+    }
+}
+
+/* Currently only supports printing vector with depth 2 */
+void printVectorMatrix(vector *vv, void (*printFunc)(vector *v, void *p)) {
+    printf("[\n");
+    for (int i = 0; i < vv->size; i++) {
+        vector *v = (vector *)vv->data[i];
+        printf("  [");
+        for (int j = 0; j < v->size; j++) {
+            printFunc(v, v->data[j]);
+            if (j != v->size - 1)
+                printf(",");
+        }
+        printf("],");
+        printf("\n");
+    }
+    printf("]\n");
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // VECTOR_H

en/codes/c/utils/vertex.h

@@ -0,0 +1,49 @@
+/**
+ * File: vertex.h
+ * Created Time: 2023-10-28
+ * Author: krahets (krahets@163.com)
+ */
+
+#ifndef VERTEX_H
+#define VERTEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Vertex structure */
+typedef struct {
+    int val;
+} Vertex;
+
+/* Constructor, initialize a new node */
+Vertex *newVertex(int val) {
+    Vertex *vet;
+    vet = (Vertex *)malloc(sizeof(Vertex));
+    vet->val = val;
+    return vet;
+}
+
+/* Convert value array to vertex array */
+Vertex **valsToVets(int *vals, int size) {
+    Vertex **vertices = (Vertex **)malloc(size * sizeof(Vertex *));
+    for (int i = 0; i < size; ++i) {
+        vertices[i] = newVertex(vals[i]);
+    }
+    return vertices;
+}
+
+/* Convert vertex array to value array */
+int *vetsToVals(Vertex **vertices, int size) {
+    int *vals = (int *)malloc(size * sizeof(int));
+    for (int i = 0; i < size; ++i) {
+        vals[i] = vertices[i]->val;
+    }
+    return vals;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // VERTEX_H