diff --git a/prisma/seed-cn.ts b/prisma/seed-cn.ts
new file mode 100644
index 0000000..5d64961
--- /dev/null
+++ b/prisma/seed-cn.ts
@@ -0,0 +1,1105 @@
+import { PrismaClient, Prisma, EditorLanguage, LanguageServerProtocol } from "@/generated/client";
+
+const prisma = new PrismaClient();
+
+const editorLanguageConfigData: Prisma.EditorLanguageConfigCreateInput[] = [
+    {
+        language: EditorLanguage.c,
+        label: "C",
+        fileName: "main",
+        fileExtension: ".c",
+        languageServerConfig: {
+            create: {
+                protocol: LanguageServerProtocol.ws,
+                hostname: "localhost",
+                port: 4594,
+                path: "/clangd",
+            },
+        },
+        dockerConfig: {
+            create: {
+                image: "gcc",
+                tag: "latest",
+                workingDir: "/src",
+                compileOutputLimit: 1 * 1024 * 1024,
+                runOutputLimit: 1 * 1024 * 1024,
+            },
+        },
+    },
+    {
+        language: EditorLanguage.cpp,
+        label: "C++",
+        fileName: "main",
+        fileExtension: ".cpp",
+        languageServerConfig: {
+            create: {
+                protocol: LanguageServerProtocol.ws,
+                hostname: "localhost",
+                port: 4595,
+                path: "/clangd",
+            },
+        },
+        dockerConfig: {
+            create: {
+                image: "gcc",
+                tag: "latest",
+                workingDir: "/src",
+                compileOutputLimit: 1 * 1024 * 1024,
+                runOutputLimit: 1 * 1024 * 1024,
+            },
+        },
+    },
+];
+
+const userData: Prisma.UserCreateInput[] = [
+    {
+        name: "cfngc4594",
+        email: "cfngc4594@gmail.com",
+        password: "$2b$10$edWXpq2TOiiGQkPOXWKGlO4EKnp2YyV7OoS2qqk/W0E6GyiVQIC66",
+        role: "ADMIN",
+        problems: {
+            create: [
+                {
+                    displayId: 1000,
+                    title: "两数之和",
+                    description: `#### 1. 两数之和
+
+难度：简单
+
+---
+
+给定一个整数数组 \`nums\` 和一个整数目标值 \`target\`，请你在该数组中找出  **和为目标值**  _\`target\`_  的那  **两个**  整数，并返回它们的数组下标。
+
+你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
+
+你可以按任意顺序返回答案。
+
+ **示例 1：** 
+
+\`\`\`
+输入：nums = [2,7,11,15], target = 9
+输出：[0,1]
+解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
+\`\`\`
+
+ **示例 2：** 
+
+\`\`\`
+输入：nums = [3,2,4], target = 6
+输出：[1,2]
+\`\`\`
+
+ **示例 3：** 
+
+\`\`\`
+输入：nums = [3,3], target = 6
+输出：[0,1]
+\`\`\`
+
+ **提示：** 
+
+*   \`2 <= nums.length <= 10^4\`
+*   \`-10^9 <= nums[i] <= 10^9\`
+*   \`-10^9 <= target <= 10^9\`
+*    **只会存在一个有效答案** 
+
+ **进阶：** 你可以想出一个时间复杂度小于 \`O(n^2)\` 的算法吗？
+
+---
+
+
+
+\`\`\`C++
+\`\`\``,
+                    solution: `<VideoEmbed platform="youtube" id="tSI98g3PDyE" />
+
+## 方法一：暴力枚举
+
+### 思路及算法
+
+最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。
+
+当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。
+
+
+### 代码
+
+\`\`\`c showLineNumbers
+int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
+    struct hashTable {
+        int key;
+        int value;
+        UT_hash_handle hh;
+    } *hashTable = NULL, *item, *tmpItem;
+
+    for (int i = 0; i < numsSize; i++) {
+        HASH_FIND_INT(hashTable, &nums[i], item);
+        if (item) {
+            int* result = malloc(sizeof(int) * 2);
+            result[0] = item->value;
+            result[1] = i;
+            *returnSize = 2;
+            HASH_ITER(hh, hashTable, item, tmpItem) {
+                HASH_DEL(hashTable, item);
+                free(item);
+            }
+            return result;
+        }
+        item = malloc(sizeof(struct hashTable));
+        item->key = target - nums[i];
+        item->value = i;
+        HASH_ADD_INT(hashTable, key, item);
+    }
+
+    HASH_ITER(hh, hashTable, item, tmpItem) {
+        HASH_DEL(hashTable, item);
+        free(item);
+    }
+
+    *returnSize = 0;
+    // If no valid pair is found, return an empty array
+    return malloc(sizeof(int) * 0);
+}
+
+\`\`\`
+
+### 复杂度分析
+
+- **时间复杂度:** $O(n^2)$.
+
+  其中 $n$ 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
+
+- **空间复杂度:** $O(1)$.
+
+  所需的空间不取决于 input 数组的大小，因此仅使用恒定空间。
+
+---
+
+## 方法二：哈希表
+
+### 思路及算法
+
+注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。
+
+使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 $O(N)$ 降低到 $O(1)$。
+
+这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。
+
+### 代码
+
+\`\`\`c showLineNumbers
+int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
+    struct hashTable {
+        int key;
+        int value;
+        UT_hash_handle hh;
+    } *hashTable = NULL, *item, *tmpItem;
+
+    for (int i = 0; i < numsSize; i++) {
+        HASH_FIND_INT(hashTable, &nums[i], item);
+        if (item) {
+            int* result = malloc(sizeof(int) * 2);
+            result[0] = item->value;
+            result[1] = i;
+            *returnSize = 2;
+            HASH_ITER(hh, hashTable, item, tmpItem) {
+                HASH_DEL(hashTable, item);
+                free(item);
+            }
+            return result;
+        }
+        item = malloc(sizeof(struct hashTable));
+        item->key = target - nums[i];
+        item->value = i;
+        HASH_ADD_INT(hashTable, key, item);
+    }
+
+    HASH_ITER(hh, hashTable, item, tmpItem) {
+        HASH_DEL(hashTable, item);
+        free(item);
+    }
+
+    *returnSize = 0;
+    // If no valid pair is found, return an empty array
+    return malloc(sizeof(int) * 0);
+}
+\`\`\`
+
+### 复杂度分析
+
+- **时间复杂度:** $O(n)$.
+
+  其中 $N$ 是数组中的元素数量。对于每一个元素 x，我们可以 $O(1)$ 地寻找 target - x。
+  
+- **空间复杂度:** $O(n)$.
+
+  其中 $N$ 是数组中的元素数量。主要为哈希表的开销。
+`,
+                    difficulty: "EASY",
+                    published: true,
+                    templates: {
+                        create: [
+                            {
+                                language: "c",
+                                template: `
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int *parseIntArray(char *line, int *len) {
+  line[strcspn(line, "\\n")] = 0;
+  char *p = line;
+  while (*p && (*p == '[' || *p == ' ' || *p == ']'))
+    p++;
+
+  int capacity = 10;
+  int *arr = malloc(capacity * sizeof(int));
+  *len = 0;
+
+  char *token = strtok(p, ",");
+  while (token) {
+    if (*len >= capacity) {
+      capacity *= 2;
+      arr = realloc(arr, capacity * sizeof(int));
+    }
+    arr[(*len)++] = atoi(token);
+    token = strtok(NULL, ",");
+  }
+  return arr;
+}
+
+char *formatOutput(int *res, int resLen) {
+  if (resLen == 0)
+    return "[]";
+
+  char *buf = malloc(resLen * 12 + 3);
+  char *p = buf;
+  *p++ = '[';
+  for (int i = 0; i < resLen; i++) {
+    p += sprintf(p, "%d", res[i]);
+    if (i != resLen - 1)
+      *p++ = ',';
+  }
+  *p++ = ']';
+  *p = 0;
+  return buf;
+}
+
+int *twoSum(int *nums, int numsSize, int target, int *returnSize);
+
+int main() {
+  char line[1024];
+  while (fgets(line, sizeof(line), stdin)) {
+    int numsSize;
+    int *nums = parseIntArray(line, &numsSize);
+
+    if (!fgets(line, sizeof(line), stdin))
+      break;
+    int target = atoi(line);
+
+    int returnSize;
+    int *res = twoSum(nums, numsSize, target, &returnSize);
+
+    char *output = formatOutput(res, returnSize);
+    printf("%s\\n", output);
+
+    free(nums);
+    if (returnSize > 0)
+      free(res);
+    if (returnSize > 0)
+      free(output);
+  }
+  return 0;
+}
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
+    
+}`,
+                            },
+                            {
+                                language: "cpp",
+                                template: `
+#include <iostream>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <unordered_map>
+
+using namespace std;
+
+// 解析输入字符串为整数数组
+vector<int> parseIntArray(string line) {
+    vector<int> result;
+    line.erase(remove(line.begin(), line.end(), '['), line.end());
+    line.erase(remove(line.begin(), line.end(), ']'), line.end());
+    stringstream ss(line);
+    string token;
+    while (getline(ss, token, ',')) {
+        if (!token.empty()) {
+            result.push_back(stoi(token));
+        }
+    }
+    return result;
+}
+
+// 格式化输出结果为字符串
+string formatOutput(const vector<int>& res) {
+    if (res.empty()) return "[]";
+    stringstream ss;
+    ss << "[";
+    for (size_t i = 0; i < res.size(); ++i) {
+        ss << res[i];
+        if (i != res.size() - 1)
+            ss << ",";
+    }
+    ss << "]";
+    return ss.str();
+}
+
+// Solution 类声明
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target);
+};
+
+int main() {
+    string line;
+    while (getline(cin, line)) {
+        vector<int> nums = parseIntArray(line);
+
+        if (!getline(cin, line)) break;
+        int target = stoi(line);
+
+        Solution sol;
+        vector<int> res = sol.twoSum(nums, target);
+
+        cout << formatOutput(res) << endl;
+    }
+
+    return 0;
+}
+
+vector<int> Solution::twoSum(vector<int>& nums, int target) {
+
+    return {};
+}
+`,
+                            },
+                        ],
+                    },
+                    testcases: {
+                        create: [
+                            {
+                                data: {
+                                    create: [
+                                        { label: "nums", value: "[2,7,11,15]", index: 0 },
+                                        { label: "target", value: "9", index: 1 },
+                                    ],
+                                },
+                                expectedOutput: "[0,1]",
+                            },
+                            {
+                                data: {
+                                    create: [
+                                        { label: "nums", value: "[3,2,4]", index: 0 },
+                                        { label: "target", value: "6", index: 1 },
+                                    ],
+                                },
+                                expectedOutput: "[1,2]",
+                            },
+                            {
+                                data: {
+                                    create: [
+                                        { label: "nums", value: "[3,3]", index: 0 },
+                                        { label: "target", value: "6", index: 1 },
+                                    ],
+                                },
+                                expectedOutput: "[0,1]",
+                            },
+                        ],
+                    },
+                },
+                {
+                    displayId: 1001,
+                    title: "两数相加",
+                    description: `#### 2. 两数相加
+
+难度：中等
+
+---
+
+给你两个  **非空**  的链表，表示两个非负的整数。它们每位数字都是按照  **逆序**  的方式存储的，并且每个节点只能存储  **一位**  数字。
+
+请你将两个数相加，并以相同形式返回一个表示和的链表。
+
+你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+
+ **示例 1：** 
+
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/01/02/addtwonumber1.jpg)
+\`\`\`
+输入：l1 = [2,4,3], l2 = [5,6,4]
+输出：[7,0,8]
+解释：342 + 465 = 807.
+\`\`\`
+
+ **示例 2：** 
+
+\`\`\`
+输入：l1 = [0], l2 = [0]
+输出：[0]
+\`\`\`
+
+ **示例 3：** 
+
+\`\`\`
+输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+输出：[8,9,9,9,0,0,0,1]
+\`\`\`
+
+ **提示：** 
+
+*   每个链表中的节点数在范围 \`[1, 100]\` 内
+*   \`0 <= Node.val <= 9\`
+*   题目数据保证列表表示的数字不含前导零
+
+---
+
+
+
+\`\`\`C++
+\`\`\``,
+                    solution: `## 方法一：模拟
+
+### 思路与算法
+
+由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。
+
+我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为 n1+n2+carry；其中，答案链表处相应位置的数字为 (n1+n2+carry)mod10，而新的进位值为 ⌊ 
+10
+
+
+如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。
+
+此外，如果链表遍历结束后，有 carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。
+
+
+
+### 代码
+
+\`\`\`c showLineNumbers
+struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
+    struct ListNode* dummyHead = malloc(sizeof(struct ListNode));
+    dummyHead->val = 0;
+    dummyHead->next = NULL;
+    struct ListNode* curr = dummyHead;
+    int carry = 0;
+
+    while (l1 != NULL || l2 != NULL || carry != 0) {
+        int x = (l1 != NULL) ? l1->val : 0;
+        int y = (l2 != NULL) ? l2->val : 0;
+        int sum = carry + x + y;
+        carry = sum / 10;
+
+        curr->next = malloc(sizeof(struct ListNode));
+        curr->next->val = sum % 10;
+        curr->next->next = NULL;
+        curr = curr->next;
+
+        if (l1 != NULL) l1 = l1->next;
+        if (l2 != NULL) l2 = l2->next;
+    }
+
+    struct ListNode* result = dummyHead->next;
+    free(dummyHead);  // Free the memory allocated for dummyHead
+    return result;
+}
+\`\`\`
+
+### 复杂度分析
+
+- **时间复杂度:** $O(max(m,n))$
+
+  其中 $m$ 和 $n$ 分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要 $O(1)$ 的时间。
+  
+- **空间复杂度:** $O(1)$
+
+  注意返回值不计入空间复杂度。
+  
+`,
+                    difficulty: "MEDIUM",
+                    published: true,
+                    templates: {
+                        create: [
+                            {
+                                language: "c",
+                                template: `
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Definition for singly-linked list.
+struct ListNode {
+    int val;
+    struct ListNode *next;
+};
+
+// 创建链表
+struct ListNode* createList(char *line) {
+    struct ListNode dummy;
+    struct ListNode *tail = &dummy;
+    dummy.next = NULL;
+
+    line[strcspn(line, "\\n")] = 0;
+    char *p = line;
+    while (*p && (*p == '[' || *p == ' ' || *p == ']')) p++;
+
+    char *token = strtok(p, ",");
+    while (token) {
+        struct ListNode *node = malloc(sizeof(struct ListNode));
+        node->val = atoi(token);
+        node->next = NULL;
+        tail->next = node;
+        tail = node;
+        token = strtok(NULL, ",");
+    }
+
+    return dummy.next;
+}
+
+// 打印链表
+void printList(struct ListNode* head) {
+    printf("[");
+    while (head) {
+        printf("%d", head->val);
+        if (head->next) printf(",");
+        head = head->next;
+    }
+    printf("]\\n");
+}
+
+// 释放链表内存
+void freeList(struct ListNode* head) {
+    while (head) {
+        struct ListNode* temp = head;
+        head = head->next;
+        free(temp);
+    }
+}
+
+// 主函数
+int main() {
+    char line[1024];
+
+    while (fgets(line, sizeof(line), stdin)) {
+        struct ListNode* l1 = createList(line);
+
+        if (!fgets(line, sizeof(line), stdin)) break;
+        struct ListNode* l2 = createList(line);
+
+        struct ListNode* result = addTwoNumbers(l1, l2);
+        printList(result);
+
+        freeList(l1);
+        freeList(l2);
+        freeList(result);
+    }
+
+    return 0;
+}
+
+
+struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
+    
+    return NULL; // 在这里填充你的算法逻辑
+}
+
+`,
+                            },
+                            {
+                                language: "cpp",
+                                template: `
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+// Definition for singly-linked list.
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode() : val(0), next(nullptr) {}
+    ListNode(int x) : val(x), next(nullptr) {}
+    ListNode(int x, ListNode *next) : val(x), next(next) {}
+};
+
+// 声明 Solution 类
+class Solution {
+public:
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2);
+};
+
+// 输入字符串 -> 链表
+ListNode* createList(const string& line) {
+    ListNode dummy;
+    ListNode* tail = &dummy;
+    dummy.next = nullptr;
+
+    string nums = line;
+    nums.erase(remove(nums.begin(), nums.end(), '['), nums.end());
+    nums.erase(remove(nums.begin(), nums.end(), ']'), nums.end());
+
+    stringstream ss(nums);
+    string token;
+    while (getline(ss, token, ',')) {
+        if (!token.empty()) {
+            int val = stoi(token);
+            tail->next = new ListNode(val);
+            tail = tail->next;
+        }
+    }
+
+    return dummy.next;
+}
+
+// 打印链表
+void printList(ListNode* head) {
+    cout << "[";
+    while (head) {
+        cout << head->val;
+        if (head->next) cout << ",";
+        head = head->next;
+    }
+    cout << "]" << endl;
+}
+
+// 释放内存
+void freeList(ListNode* head) {
+    while (head) {
+        ListNode* tmp = head;
+        head = head->next;
+        delete tmp;
+    }
+}
+
+// 主函数
+int main() {
+    string line;
+    while (getline(cin, line)) {
+        ListNode* l1 = createList(line);
+        if (!getline(cin, line)) break;
+        ListNode* l2 = createList(line);
+
+        Solution sol;
+        ListNode* res = sol.addTwoNumbers(l1, l2);
+        printList(res);
+
+        freeList(l1);
+        freeList(l2);
+        freeList(res);
+    }
+    return 0;
+}
+
+
+ListNode* Solution::addTwoNumbers(ListNode* l1, ListNode* l2) {
+
+    return nullptr; // 在这里填充你的算法逻辑
+}
+`,
+                            },
+                        ],
+                    },
+                    testcases: {
+                        create: [
+                            {
+                                data: {
+                                    create: [
+                                        { label: "l1", value: "[2,4,3]", index: 0 },
+                                        { label: "l2", value: "[5,6,4]", index: 1 },
+                                    ],
+                                },
+                                expectedOutput: "[7,0,8]",
+                            },
+                            {
+                                data: {
+                                    create: [
+                                        { label: "l1", value: "[0]", index: 0 },
+                                        { label: "l2", value: "[0]", index: 1 },
+                                    ],
+                                },
+                                expectedOutput: "[0]",
+                            },
+                            {
+                                data: {
+                                    create: [
+                                        { label: "l1", value: "[9,9,9,9,9,9,9]", index: 0 },
+                                        { label: "l2", value: "[9,9,9,9]", index: 1 },
+                                    ],
+                                },
+                                expectedOutput: "[8,9,9,9,0,0,0,1]",
+                            },
+                        ],
+                    },
+                },
+            ],
+        },
+    },
+    {
+        name: "fly6516",
+        email: "fly6516@outlook.com",
+        password: "$2b$10$SD1T/dYvKTArGdTmf8ERxuBKIONxY01/wSboRNaNsHnKZzDhps/0u",
+        role: "ADMIN",
+        problems: {
+            create: [
+                {
+                    displayId: 1002,
+                    title: "寻找两个正序数组的中位数",
+                    description: `#### 4. 寻找两个正序数组的中位数
+
+难度：困难
+
+---
+
+给定两个大小分别为 \`m\` 和 \`n\` 的正序（从小到大）数组 \`nums1\` 和 \`nums2\`。请你找出并返回这两个正序数组的  **中位数**  。
+
+算法的时间复杂度应该为 \`O(log (m+n))\` 。
+
+ **示例 1：** 
+
+\`\`\`
+输入：nums1 = [1,3], nums2 = [2]
+输出：2.00000
+解释：合并数组 = [1,2,3] ，中位数 2
+\`\`\`
+
+ **示例 2：** 
+
+\`\`\`
+输入：nums1 = [1,2], nums2 = [3,4]
+输出：2.50000
+解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
+\`\`\`
+
+ **提示：** 
+
+*   \`nums1.length == m\`
+*   \`nums2.length == n\`
+*   \`0 <= m <= 1000\`
+*   \`0 <= n <= 1000\`
+*   \`1 <= m + n <= 2000\`
+*   \`-10^6 <= nums1[i], nums2[i] <= 10^6\`
+
+---
+
+
+
+\`\`\`C++
+\`\`\``,
+                    solution: `## 方法一：二分查找
+
+### Intuition
+
+给定两个有序数组，要求找到两个有序数组的中位数，最直观的思路有以下两种：
+
+- 使用归并的方式，合并两个有序数组，得到一个大的有序数组。大的有序数组的中间位置的元素，即为中位数。
+
+- 不需要合并两个有序数组，只要找到中位数的位置即可。由于两个数组的长度已知，因此中位数对应的两个数组的下标之和也是已知的。维护两个指针，初始时分别指向两个数组的下标 0 的位置，每次将指向较小值的指针后移一位（如果一个指针已经到达数组末尾，则只需要移动另一个数组的指针），直到到达中位数的位置。
+
+
+#假设两个有序数组的长度分别为 $m$ 和 $n$，上述两种思路的复杂度如何？
+
+第一种思路的时间复杂度是 $O(m+n)$，空间复杂度是 $O(m+n)$。第二种思路虽然可以将空间复杂度降到 $O(1)$，但是时间复杂度仍是 $O(m+n)$。
+
+如何把时间复杂度降低到 $O(log(m+n))$ 呢？如果对时间复杂度的要求有 $log$，通常都需要用到二分查找，这道题也可以通过二分查找实现。
+
+根据中位数的定义，当 $m+n$ 是奇数时，中位数是两个有序数组中的第 $(m+n)/2$ 个元素，当 $m+n$ 是偶数时，中位数是两个有序数组中的第 $(m+n)/2$ 个元素和第 $(m+n)/2+1$ 个元素的平均值。因此，这道题可以转化成寻找两个有序数组中的第 $k$ 小的数，其中 $k$ 为 $(m+n)/2$ 或 $(m+n)/2+1$。
+
+假设两个有序数组分别是 $A$ 和 $B$。要找到第 $k$ 个元素，我们可以比较 $A[k/2−1]$ 和 $B[k/2−1]$，其中 $/$ 表示整数除法。由于 $A[k/2−1]$ 和 $B[k/2−1]$ 的前面分别有 $A[0..k/2−2]$ 和 $B[0..k/2−2]$，即 $k/2−1$ 个元素，对于 $A[k/2−1]$ 和 $B[k/2−1]$ 中的较小值，最多只会有 $(k/2−1)+(k/2−1)≤k−2$ 个元素比它小，那么它就不能是第 $k$ 小的数了。
+
+
+ ![](https://assets.leetcode-cn.com/solution-static/4/4_fig1.png）
+ 
+ 因此我们可以归纳出三种情况：
+
+- 如果 $A[k/2−1]<B[k/2−1]$，则比 $A[k/2−1]$ 小的数最多只有 $A$ 的前 $k/2−1$ 个数和 $B$ 的前 $k/2−1$ 个数，即比 $A[k/2−1]$ 小的数最多只有 $k−2$ 个，因此 $A[k/2−1]$ 不可能是第 $k$ 个数，$A[0]$ 到 $A[k/2−1]$ 也都不可能是第 $k$ 个数，可以全部排除。
+
+- 如果 $A[k/2−1]>B[k/2−1]$，则可以排除 $B[0]$ 到 $B[k/2−1]$。
+
+- 如果 $A[k/2−1]=B[k/2−1]$，则可以归入第一种情况处理。
+
+可以看到，比较 $A[k/2−1] 和 $B[k/2−1]$ 之后，可以排除 $k/2$ 个不可能是第 $k$ 小的数，查找范围缩小了一半。同时，我们将在排除后的新数组上继续进行二分查找，并且根据我们排除数的个数，减少 $k$ 的值，这是因为我们排除的数都不大于第 $k$ 小的数。
+
+有以下三种情况需要特殊处理：
+
+- 如果 $A[k/2−1]$ 或者 $B[k/2−1]$ 越界，那么我们可以选取对应数组中的最后一个元素。在这种情况下，我们必须根据排除数的个数减少 $k$ 的值，而不能直接将 $k$ 减去 $k/2$。
+
+- 如果一个数组为空，说明该数组中的所有元素都被排除，我们可以直接返回另一个数组中第 $k$ 小的元素。
+
+- 如果 $k=1$，我们只要返回两个数组首元素的最小值即可。
+
+用一个例子说明上述算法。假设两个有序数组如下：
+\`\`\`math
+A: 1 3 4 9
+B: 1 2 3 4 5 6 7 8 9
+\`\`\`
+
+两个有序数组的长度分别是 4 和 9，长度之和是 13，中位数是两个有序数组中的第 7 个元素，因此需要找到第 k=7 个元素。
+
+比较两个有序数组中下标为 k/2−1=2 的数，即 A[2] 和 B[2]，如下面所示：
+\`\`\`math
+A: 1 3 4 9
+       ↑
+B: 1 2 3 4 5 6 7 8 9
+       ↑
+\`\`\`
+由于 A[2]>B[2]，因此排除 B[0] 到 B[2]，即数组 B 的下标偏移（offset）变为 3，同时更新 k 的值：k=k−k/2=4。
+
+下一步寻找，比较两个有序数组中下标为 k/2−1=1 的数，即 A[1] 和 B[4]，如下面所示，其中方括号部分表示已经被排除的数。
+\`\`\`math
+A: 1 3 4 9
+     ↑
+B: [1 2 3] 4 5 6 7 8 9
+             ↑
+\`\`\`
+由于 A[1]<B[4]，因此排除 A[0] 到 A[1]，即数组 A 的下标偏移变为 2，同时更新 k 的值：k=k−k/2=2。
+
+下一步寻找，比较两个有序数组中下标为 k/2−1=0 的数，即比较 A[2] 和 B[3]，如下面所示，其中方括号部分表示已经被排除的数。
+\`\`\`math
+A: [1 3] 4 9
+         ↑
+B: [1 2 3] 4 5 6 7 8 9
+           ↑
+\`\`\`
+由于 A[2]=B[3]，根据之前的规则，排除 A 中的元素，因此排除 A[2]，即数组 A 的下标偏移变为 3，同时更新 k 的值： k=k−k/2=1。
+
+由于 k 的值变成 1，因此比较两个有序数组中的未排除下标范围内的第一个数，其中较小的数即为第 k 个数，由于 A[3]>B[3]，因此第 k 个数是 B[3]=4。
+\`\`\`math
+A: [1 3 4] 9
+           ↑
+B: [1 2 3] 4 5 6 7 8 9
+           ↑
+\`\`\`
+### 代码
+
+\`\`\`c showLineNumbers
+int solve(int* A, int aStart, int aEnd, int* B, int bStart, int bEnd, int k) {
+    // If the segment of on array is empty, it means we have passed all
+    // its element, just return the corresponding element in the other array.
+    if (aEnd < aStart) {
+        return B[k - aStart];
+    }
+    if (bEnd < bStart) {
+        return A[k - bStart];
+    }
+
+    // Get the middle indexes and middle values of A and B.
+    int aIndex = (aStart + aEnd) / 2, bIndex = (bStart + bEnd) / 2;
+    int aValue = A[aIndex], bValue = B[bIndex];
+
+    // If k is in the right half of A + B, remove the smaller left half.
+    if (aIndex + bIndex < k) {
+        if (aValue > bValue) {
+            return solve(A, aStart, aEnd, B, bIndex + 1, bEnd, k);
+        } else {
+            return solve(A, aIndex + 1, aEnd, B, bStart, bEnd, k);
+        }
+    }
+    // Otherwise, remove the larger right half.
+    else {
+        if (aValue > bValue) {
+            return solve(A, aStart, aIndex - 1, B, bStart, bEnd, k);
+        } else {
+            return solve(A, aStart, aEnd, B, bStart, bIndex - 1, k);
+        }
+    }
+}
+
+double findMedianSortedArrays(int* A, int na, int* B, int nb) {
+    int n = na + nb;
+    if (n % 2 == 1) {
+        return solve(A, 0, na - 1, B, 0, nb - 1, n / 2);
+    } else {
+        return (solve(A, 0, na - 1, B, 0, nb - 1, n / 2) +
+                solve(A, 0, na - 1, B, 0, nb - 1, n / 2 - 1)) /
+               2.0;
+    }
+}
+\`\`\`
+
+### 复杂度分析
+
+Let $m$ be the size of array \`nums1\` and $n$ be the size of array \`nums2\`.
+
+- **时间复杂度:** $O(log(m+n))$
+
+  - 其中 m 和 n 分别是数组 nums 1​和 nums 2​的长度。初始时有 $k=(m+n)/2$ 或 $k=(m+n)/2+1$，每一轮循环可以将查找范围减少一半，因此时间复杂度是 $O(log(m+n))$。
+
+- **空间复杂度:** $O(1)$
+
+`,
+                    difficulty: "HARD",
+                    published: true,
+                    templates: {
+                        create: [
+                            {
+                                language: "c",
+                                template: `
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// 解析输入数组
+int *parseIntArray(char *line, int *len) {
+    line[strcspn(line, "\\n")] = 0; // 移除换行符
+    char *p = line;
+    while (*p && (*p == '[' || *p == ' ' || *p == ']')) p++; // 跳过空格和括号
+
+    int capacity = 10;
+    int *arr = malloc(capacity * sizeof(int)); // 初始分配空间
+    *len = 0;
+
+    char *token = strtok(p, ","); // 分割输入为逗号分隔的整数
+    while (token) {
+        if (*len >= capacity) { // 扩展数组大小
+            capacity *= 2;
+            arr = realloc(arr, capacity * sizeof(int));
+        }
+        arr[(*len)++] = atoi(token); // 存储整数
+        token = strtok(NULL, ",");
+    }
+    return arr;
+}
+
+double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size);
+
+int main() {
+    char line[1024];
+
+    while (fgets(line, sizeof(line), stdin)) { // 读取第一行
+        int len1;
+        int *nums1 = parseIntArray(line, &len1); // 解析数组1
+
+        if (!fgets(line, sizeof(line), stdin)) break; // 如果第二行不存在，退出
+        int len2;
+        int *nums2 = parseIntArray(line, &len2); // 解析数组2
+
+        double result = findMedianSortedArrays(nums1, len1, nums2, len2); // 计算中位数
+        printf("%.5f\\n", result); // 输出中位数，保留5位小数
+
+        free(nums1); // 释放内存
+        free(nums2); // 释放内存
+    }
+
+    return 0;
+}
+
+
+// 寻找中位数函数 
+double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
+    
+    return 0.0; // 在这里填充你的算法逻辑
+}
+`,
+                            },
+                            {
+                                language: "cpp",
+                                template: `
+#include <iostream>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <algorithm>
+using namespace std;
+
+class Solution {
+public:
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2);
+};
+
+// 解析输入为整数数组
+vector<int> parseIntArray(const string& line) {
+    string trimmed = line;
+    trimmed.erase(remove(trimmed.begin(), trimmed.end(), '['), trimmed.end());
+    trimmed.erase(remove(trimmed.begin(), trimmed.end(), ']'), trimmed.end());
+
+    vector<int> result;
+    stringstream ss(trimmed);
+    string token;
+    while (getline(ss, token, ',')) {
+        if (!token.empty()) {
+            result.push_back(stoi(token));
+        }
+    }
+    return result;
+}
+
+int main() {
+    string line;
+    while (getline(cin, line)) {
+        vector<int> nums1 = parseIntArray(line);
+        if (!getline(cin, line)) break;
+        vector<int> nums2 = parseIntArray(line);
+
+        Solution sol;
+        double result = sol.findMedianSortedArrays(nums1, nums2);
+        printf("%.5f\\n", result);
+    }
+    return 0;
+}
+
+
+
+double Solution::findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+
+    return 0.0; // 临时返回值，待填充
+}
+`,
+                            },
+                        ],
+                    },
+                    testcases: {
+                        create: [
+                            {
+                                data: {
+                                    create: [
+                                        { label: "nums1", value: "[1,3]", index: 0 },
+                                        { label: "nums2", value: "[2]", index: 1 },
+                                    ],
+                                },
+                                expectedOutput: "2.00000",
+                            },
+                            {
+                                data: {
+                                    create: [
+                                        { label: "nums1", value: "[1,2]", index: 0 },
+                                        { label: "nums2", value: "[3,4]", index: 1 },
+                                    ],
+                                },
+                                expectedOutput: "2.50000",
+                            },
+                        ],
+                    },
+                },
+            ],
+        },
+    },
+];
+
+export async function main() {
+    for (const e of editorLanguageConfigData) {
+        await prisma.editorLanguageConfig.create({ data: e });
+    }
+
+    for (const u of userData) {
+        await prisma.user.create({ data: u });
+    }
+}
+
+main();