From 908e4e6f1968cdb66534c68890a9bba6af3a9d7c Mon Sep 17 00:00:00 2001 From: fly6516 Date: Wed, 16 Apr 2025 00:22:15 +0800 Subject: [PATCH] feat: add seed-cn.ts --- prisma/seed-cn.ts | 1105 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1105 insertions(+) create mode 100644 prisma/seed-cn.ts 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: ` + +## 方法一：暴力枚举 + +### 思路及算法 + +最容易想到的方法是枚举数组中的每一个数 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 +#include +#include + +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 +#include +#include +#include +#include +#include + +using namespace std; + +// 解析输入字符串为整数数组 +vector parseIntArray(string line) { + vector 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& 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 twoSum(vector& nums, int target); +}; + +int main() { + string line; + while (getline(cin, line)) { + vector nums = parseIntArray(line); + + if (!getline(cin, line)) break; + int target = stoi(line); + + Solution sol; + vector res = sol.twoSum(nums, target); + + cout << formatOutput(res) << endl; + } + + return 0; +} + +vector Solution::twoSum(vector& 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 +#include +#include + +// 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 +#include +#include +#include +#include +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]$，则可以排除 $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[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 +#include +#include + +// 解析输入数组 +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 +#include +#include +#include +#include +using namespace std; + +class Solution { +public: + double findMedianSortedArrays(vector& nums1, vector& nums2); +}; + +// 解析输入为整数数组 +vector 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 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 nums1 = parseIntArray(line); + if (!getline(cin, line)) break; + vector nums2 = parseIntArray(line); + + Solution sol; + double result = sol.findMedianSortedArrays(nums1, nums2); + printf("%.5f\\n", result); + } + return 0; +} + + + +double Solution::findMedianSortedArrays(vector& nums1, vector& 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();