fix:修复showLogs参数无法接收多个内容的问题并只保留leet-check和leet-create

Author: wh131462

Readme.md

@@ -11,8 +11,8 @@
 - [x] 4.函数:优化时间和资源统计函数
 - [ ] 5.优化创建时的体验，添加重复时候的确认覆盖或者添加额外符号
 - [ ] 6.特殊数据结构的处理(ListNode,Stack等)的处理
-- [ ] 7.创建某一特定编号的题目脚本
-- [ ] 8.题目中图片的预览功能
+- [ ] 7.创建某一特定编号的题目脚本,以及实现随机题目
+- [ ] 8.实现在编辑器中预览图片
 
 ## How to use for yourself ?
 
@@ -38,33 +38,46 @@ pnpm install
 ### 1. 获取今天的题目
 
 ```shell
-yarn create-today [your-specified-name:default is question's id]
+yarn leet-create
 ```
-
 会通过接口获取今日题目，并会在`src`目录下根据`你提供的指定名称(默认不填值为题目的id)`创建一个目录，并将今日题目和基础示例代码填充到`index.js`中。
 
-```shell
-//todo 填充代码创建结果和截图
-```
+![创建目录](./resources/leet-create-0.png)
+![填充文件](resources/leet-create-1.png)
 
 ### 2. 检验今天的题目
 
 ```shell
-yarn check-today
+yarn leet-check
 ```
 
 此指令会根据今天你的题目创建时填写的名称去执行对应的题目文件，输出结果。
 > NOTE:缓存的实现是在`commom/resouces/store.json`,如果只想让内容在本地存在,不上传到个人项目中的话,执行`git update-index --aussume-unchanged common/resources/store.json`来忽略本地的文件变更即可。
+> 
 
 ```shell
-// todo 填充代码创建结果和截图
-```
+yarn leet-check 
+
+[leet-check]检测题目:2744.find-maximum-number-of-string-pairs
+执行结果:
+┌─────────┬──────────┬──────────┬──────────┬────────────┬───────────┐
+│ (index) │ 测试结果 │ 预期结果 │ 执行结果 │  执行用时  │ 内存占用  │
+├─────────┼──────────┼──────────┼──────────┼────────────┼───────────┤
+│    0    │  '通过'  │   '2'    │   '2'    │ '0.2113ms' │ '1.68 KB' │
+│    1    │  '通过'  │   '1'    │   '1'    │ '0.0195ms' │ '1.73 KB' │
+│    2    │  '通过'  │   '0'    │   '0'    │ '0.0091ms' │ '1.80 KB' │
+└─────────┴──────────┴──────────┴──────────┴────────────┴───────────┘
+点击跳转到题目提交:https://leetcode.cn/problems/find-maximum-number-of-string-pairs/
 
+Done in 0.18s.
+
+```
+![检测题目](resources/leet-check.png)
 ### 3. 创建自己想要练习的题目
 
 ```shell
 # 可以使用你喜欢的任意包管理工具,例如 `pnpm`/`npm`
-yarn leet-create [题目编号或者名称]
+yarn leet-create -i [题目编号或者名称]
 
 e.g.
 yarn leet-create 1314
@@ -78,11 +91,13 @@ yarn leet-create 1314
   └── index.js # 模板js文件 可以替换题目
 ```
 
+//todo 待填充
+
 ### 4. 检验自己想要练习的结果
 
 ```shell
 # 可以使用你喜欢的任意包管理工具,例如 `pnpm`/`npm`
-yarn leet-check [题目编号或者名称]
+yarn leet-check -i [题目编号或者名称]
 
 e.g.
 yarn leet-check 1314
@@ -91,31 +106,37 @@ yarn leet-check 1314
 会出现其用时以及内存占用:
 
 ```shell
-yarn run v1.22.19
-$ node common/scripts/check.js 2696
-执行结果:
-5
-函数执行用时: 2.509ms
-内存占用：262144
-2
-函数执行用时: 0.063ms
-内存占用：0
-
-✨  Done in 0.13s.
+//todo 待填充
+```
+### 5. 获取随机题目
+
+```shell
+yarn leet-create -r
+```
+会获取一个当前src目录中未出现过的题目
+//todo 待填充
+
+### 6. 检验随机题目
+
+```shell
+# 可以使用你喜欢的任意包管理工具,例如 `pnpm`/`npm`
+yarn leet-check -r
+```
+会检验上次随机出的题目编号:
+
+```shell
+//todo 待填充
 ```
 
 ## Scripts API Document
 
-| script       | 参数         | 说明       |
-|--------------|------------|----------|
-| leet-create  | 题目编号或者题目名称 | 创建一个模板文件 |
-| leet-check   | 题目编号或者题目名称 | 执行某个项目   |
-| get-question | 无          | 获取今日题目对象 |
-| create-today | 无          | 创建今日题目   |
-| check-today  | 无          | 检查今日题目   |
+| script      | 参数               | 说明                                                  |
+|-------------|------------------|-----------------------------------------------------|
+| leet-create | [-i [题目编号]][-r]  | 创建一个题目,不带参数获取今日题目,`-i` 参数指定题号去获取，`-r` 随机题目          |
+| leet-check  | [-i [题目编号]][-r]       | 执行检测一个题目,不带参数检测今日题目,`-i` 参数指定题号去检测，`-r` 检测上一个随机出的题目 |
 
 > note:
-> 名词解释: 题目编号或者题目名称(题目创建的时候的唯一标识,可以是题目的LeetCode编号也可以是自己起得别名)
+> 名词解释: 题目编号是leet-code为其分配的唯一id,如`1314`对应题目`矩阵区域和`
 
 ## Contributor
 

common/resources/store.json

@@ -1 +1 @@
-{"today":"2182","today-question-info":{"id":"82","enName":"remove-duplicates-from-sorted-list-ii","title":"删除排序链表中的重复元素 II","detail":"<p>给定一个已排序的链表的头&nbsp;<code>head</code> ，&nbsp;<em>删除原始链表中所有重复数字的节点，只留下不同的数字</em>&nbsp;。返回 <em>已排序的链表</em>&nbsp;。</p>\n\n<p>&nbsp;</p>\n\n<p><strong>示例 1：</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg\" style=\"height: 142px; width: 500px;\" />\n<pre>\n<strong>输入：</strong>head = [1,2,3,3,4,4,5]\n<strong>输出：</strong>[1,2,5]\n</pre>\n\n<p><strong>示例 2：</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg\" style=\"height: 164px; width: 400px;\" />\n<pre>\n<strong>输入：</strong>head = [1,1,1,2,3]\n<strong>输出：</strong>[2,3]\n</pre>\n\n<p>&nbsp;</p>\n\n<p><strong>提示：</strong></p>\n\n<ul>\n\t<li>链表中节点数目在范围 <code>[0, 300]</code> 内</li>\n\t<li><code>-100 &lt;= Node.val &lt;= 100</code></li>\n\t<li>题目数据保证链表已经按升序 <strong>排列</strong></li>\n</ul>\n","date":"2024-01-15","jsCode":"/**\n * Definition for singly-linked list.\n * function ListNode(val, next) {\n *     this.val = (val===undefined ? 0 : val)\n *     this.next = (next===undefined ? null : next)\n * }\n */\n/**\n * @param {ListNode} head\n * @return {ListNode}\n */\nvar deleteDuplicates = function(head) {\n\n};"},"today-tag":"82"}
+{"today":"2182","today-question-info":{"id":"2744","enName":"find-maximum-number-of-string-pairs","title":"最大字符串配对数目","detail":"<p>给你一个下标从 <strong>0</strong>&nbsp;开始的数组&nbsp;<code>words</code>&nbsp;，数组中包含 <strong>互不相同</strong>&nbsp;的字符串。</p>\n\n<p>如果字符串&nbsp;<code>words[i]</code>&nbsp;与字符串 <code>words[j]</code>&nbsp;满足以下条件，我们称它们可以匹配：</p>\n\n<ul>\n\t<li>字符串&nbsp;<code>words[i]</code>&nbsp;等于&nbsp;<code>words[j]</code>&nbsp;的反转字符串。</li>\n\t<li><code>0 &lt;= i &lt; j &lt; words.length</code></li>\n</ul>\n\n<p>请你返回数组 <code>words</code>&nbsp;中的&nbsp;<strong>最大</strong>&nbsp;匹配数目。</p>\n\n<p>注意，每个字符串最多匹配一次。</p>\n\n<p>&nbsp;</p>\n\n<p><strong>示例 1：</strong></p>\n\n<pre>\n<b>输入：</b>words = [\"cd\",\"ac\",\"dc\",\"ca\",\"zz\"]\n<b>输出：</b>2\n<strong>解释：</strong>在此示例中，我们可以通过以下方式匹配 2 对字符串：\n- 我们将第 0 个字符串与第 2 个字符串匹配，因为 word[0] 的反转字符串是 \"dc\" 并且等于 words[2]。\n- 我们将第 1 个字符串与第 3 个字符串匹配，因为 word[1] 的反转字符串是 \"ca\" 并且等于 words[3]。\n可以证明最多匹配数目是 2 。\n</pre>\n\n<p><strong>示例 2：</strong></p>\n\n<pre>\n<b>输入：</b>words = [\"ab\",\"ba\",\"cc\"]\n<b>输出：</b>1\n<b>解释：</b>在此示例中，我们可以通过以下方式匹配 1 对字符串：\n- 我们将第 0 个字符串与第 1 个字符串匹配，因为 words[1] 的反转字符串 \"ab\" 与 words[0] 相等。\n可以证明最多匹配数目是 1 。\n</pre>\n\n<p><strong>示例 3：</strong></p>\n\n<pre>\n<b>输入：</b>words = [\"aa\",\"ab\"]\n<b>输出：</b>0\n<strong>解释：</strong>这个例子中，无法匹配任何字符串。\n</pre>\n\n<p>&nbsp;</p>\n\n<p><strong>提示：</strong></p>\n\n<ul>\n\t<li><code>1 &lt;= words.length &lt;= 50</code></li>\n\t<li><code>words[i].length == 2</code></li>\n\t<li><code>words</code>&nbsp;包含的字符串互不相同。</li>\n\t<li><code>words[i]</code>&nbsp;只包含小写英文字母。</li>\n</ul>\n","date":"2024-01-17","jsCode":"/**\n * @param {string[]} words\n * @return {number}\n */\nvar maximumNumberOfStringPairs = function(words) {\n\n};"},"today-tag":"82"}

common/scripts/checkToday.js

@@ -6,9 +6,10 @@
  * @returns {string}
  */
 function getTestCase(question){
-    const cases = question.detail.match(/<strong>输入：<\/strong>.+\n/g).map(str=>str.replaceAll("<strong>输入：","").replaceAll("</strong>","").replace("\n",""))
-    const expires = question.detail.match(/<strong>输出：<\/strong>.+\n/g).map(str=>str.replaceAll("<strong>输出：</strong>","").replace("\n",""))
-    const functionName = question.jsCode.match(/var.+=/g)[0].replace("var ","").replace(" =","");
+    console.log(question)
+    const cases = question.detail.match(/(<[a-zA-Z]+>输入：<\/[a-zA-Z]+>).+\n/g)?.map(str=>`[${str?.replace(/<[a-zA-Z]+>输入：/gm,"")?.replace(/<\/[a-zA-Z]+>/,"")?.replace("\n","")}]`)
+    const expires = question.detail.match(/(<[a-zA-Z]+>输出：<\/[a-zA-Z]+>).+\n/g)?.map(str=>str?.replace(/<[a-zA-Z]+>输出：<\/[a-zA-Z]+>/gm,"")?.replace("\n",""))
+    const functionName = question.jsCode?.match(/var.+=/g)?.[0]?.replace("var ","")?.replace(" =","");
     return `showLogs(
     ${functionName},
     [${cases}],

common/scripts/createToday.js

@@ -2,12 +2,19 @@ const v8 = require("v8");
 const { getFileSize } = require("./sizeUtil");
 const { isSameData } = require("./isSameData");
 
+/**
+ * 执行并输出时间和内存
+ * @param fnName
+ * @param param 传入数组 全部通过解构来做
+ * @param compare
+ * @returns {{预期结果: string, 执行结果: string, 内存占用: string, 测试结果: (string), 执行用时: string}}
+ */
 function withTimeLog(fnName, param, compare) {
     // 记录开始时间
     const startTime = performance.now();
     // 获取函数执行前的内存使用情况
     const startHeapStatsArray = v8.getHeapSpaceStatistics()
-    const callVal = fnName(param)
+    const callVal = fnName(...param)
     // 获取函数执行后的内存使用情况
     const endHeapStatsArray = v8.getHeapSpaceStatistics()
     // 记录结束时间

common/utils/getTestCase.js

@@ -6,11 +6,7 @@
   "type": "commonjs",
   "scripts": {
     "leet-check": "node common/scripts/check.js",
-    "leet-create": "node common/scripts/create.js",
-    "preget-question": "rimraf index.html",
-    "get-question": "node common/question/getQuestion.js",
-    "create-today": "node common/scripts/createToday.js",
-    "check-today": "node common/scripts/checkToday.js"
+    "leet-create": "node common/scripts/create.js"
   },
   "author": "EternalHeart",
   "license": "ISC",

common/utils/withTimeLog.js

@@ -0,0 +1,62 @@
+const { showLogs } = require("../../common/utils/withTimeLog");
+/**
+ * 2744.最大字符串配对数目 [2024-01-17]
+ * 给你一个下标从 0 开始的数组 words ，数组中包含 互不相同 的字符串。
+ * 如果字符串 words[i] 与字符串 words[j] 满足以下条件，我们称它们可以匹配：
+ * 	字符串 words[i] 等于 words[j] 的反转字符串。
+ * 	0 <= i < j < words.length
+ * 请你返回数组 words 中的 最大 匹配数目。
+ * 注意，每个字符串最多匹配一次。
+ * <img src="resources/leet-check.png" alt="图片" width="400" height="230"/>
+ * 示例 1：
+ * 输入：words = ["cd","ac","dc","ca","zz"]
+ * 输出：2
+ * 解释：在此示例中，我们可以通过以下方式匹配 2 对字符串：
+ * - 我们将第 0 个字符串与第 2 个字符串匹配，因为 word[0] 的反转字符串是 "dc" 并且等于 words[2]。
+ * - 我们将第 1 个字符串与第 3 个字符串匹配，因为 word[1] 的反转字符串是 "ca" 并且等于 words[3]。
+ * 可以证明最多匹配数目是 2 。
+ * 示例 2：
+ * 输入：words = ["ab","ba","cc"]
+ * 输出：1
+ * 解释：在此示例中，我们可以通过以下方式匹配 1 对字符串：
+ * - 我们将第 0 个字符串与第 1 个字符串匹配，因为 words[1] 的反转字符串 "ab" 与 words[0] 相等。
+ * 可以证明最多匹配数目是 1 。
+ * 示例 3：
+ * 输入：words = ["aa","ab"]
+ * 输出：0
+ * 解释：这个例子中，无法匹配任何字符串。
+ *  
+ * 提示：
+ * 	1 <= words.length <= 50
+ * 	words[i].length == 2
+ * 	words 包含的字符串互不相同。
+ * 	words[i] 只包含小写英文字母。
+ * 
+ */
+/**
+ * @param {string[]} words
+ * @return {number}
+ */
+var maximumNumberOfStringPairs = function(words) {
+    const n = words.length;
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        for (let j = i + 1; j < n; ++j) {
+            if (words[i][0] == words[j][1] && words[i][1] == words[j][0]) {
+                ++ans;
+            }
+        }
+    }
+    return ans;
+};
+
+/**
+ * Test case
+ */
+showLogs(
+    maximumNumberOfStringPairs,
+    [[words = ["cd","ac","dc","ca","zz"]],[words = ["ab","ba","cc"]],[words = ["aa","ab"]]],
+    [2,1,0]
+)
+console.log("点击跳转到题目提交:https://leetcode.cn/problems/find-maximum-number-of-string-pairs/")
+