Merge branch 'master' of https://github.com/L-SUI/note

Author: 刘晓东

.circleci/config.yml

@@ -0,0 +1,64 @@
+#https://github.com/revolunet/create-react-app-circleci/blob/master/.circleci/config.yml
+# 给当前node_modules 一个快照，如果 package.json 没变，node_modules 就不用重新下载
+defaults: &defaults
+  docker:
+    - image: circleci/node:12.18.2
+
+version: 2
+jobs:
+  publish:
+    <<: *defaults
+    steps:
+      - checkout
+      - run: git pull
+      - restore_cache:
+          keys:
+            - v2-dependencies-{{ checksum "package.json" }}
+      - run: npm install
+      - save_cache:
+          paths:
+            - node_modules
+          key: v2-dependencies-{{ checksum "package.json" }}
+      - run: npm install -D vuepress --registry.npmjs.org
+      # ksgcLbaW4SVNXtGtudlBOZ2EfMJz80TMlqpNi934
+      - run: npx vuepress build docs
+      - run: rm -rf ./L-SUI.github.io
+      - run: git clone https://github.com/L-SUI/L-SUI.github.io.git
+      - run: cp -af ./docs/.vuepress/dist/  ./L-SUI.github.io/
+      - run: cd L-SUI.github.io && git add .
+      - run: git config  user.email "[email protected]"
+      - run: git config  user.name "LiuXiaoDong"
+      - run: git commit -m 'circleci自动提交'
+      - run: git push 
+      - run: cd ../ && rm -rf ./L-SUI.github.io
+      # - persist_to_workspace:
+      #     root: .
+      #     paths:
+      #       - node_modules
+
+
+workflows:
+  version: 2
+  build_accept_deploy:
+    jobs:
+      - publish
+      # - prepare
+      # - publish:
+      #     requires:
+      #       - prepare
+#      - prepare
+#      - build:
+#          requires:
+#            - test
+#      - test:
+#          requires:
+#            - prepare
+#          requires:
+#            - build
+#          filters:
+#            # 所有 branches 都忽略，只部署 vx.x.x 的 tags
+##            tags:
+##              only: /^v[0-9]+(\.[0-9]+)*/
+#            branches:
+#              all
+#              ignore: /.*/

LeetCode/1160. 拼写单词.js

@@ -0,0 +1,73 @@
+// 给你一份『词汇表』（字符串数组） words 和一张『字母表』（字符串） chars。
+
+// 假如你可以用 chars 中的『字母』（字符）拼写出 words 中的某个『单词』（字符串），那么我们就认为你掌握了这个单词。
+
+// 注意：每次拼写（指拼写词汇表中的一个单词）时，chars 中的每个字母都只能用一次。
+
+// 返回词汇表 words 中你掌握的所有单词的 长度之和。
+
+//  
+
+// 示例 1：
+
+// 输入：words = ["cat","bt","hat","tree"], chars = "atach"
+// 输出：6
+// 解释： 
+// 可以形成字符串 "cat" 和 "hat"，所以答案是 3 + 3 = 6。
+// 示例 2：
+
+// 输入：words = ["hello","world","leetcode"], chars = "welldonehoneyr"
+// 输出：10
+// 解释：
+// 可以形成字符串 "hello" 和 "world"，所以答案是 5 + 5 = 10。
+//  
+
+// 提示：
+
+// 1 <= words.length <= 1000
+// 1 <= words[i].length, chars.length <= 100
+// 所有字符串中都仅包含小写英文字母
+
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/find-words-that-can-be-formed-by-characters
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+/**
+ * @param {string[]} words
+ * @param {string} chars
+ * @return {number}
+ */
+/**
+ * @param {string[]} words
+ * @param {string} chars
+ * @return {number}
+ */
+ var countCharacters = function(words, chars) {
+    let size = 0;
+    let charMap = new Map();
+
+    for(let char of chars) {
+       charMap.set(char, (charMap.has(char) ? charMap.get(char) + 1 : 1));
+    }
+    for(let word of words) {
+        let wordMap = new Map();
+        for(let char of word) {
+            wordMap.set(char, (wordMap.has(char) ? wordMap.get(char) + 1 : 1));
+        }
+        let enough = true;
+        for(let char of word) {
+           if(wordMap.get(char) > charMap.get(char) || charMap.get(char) === undefined) {
+               enough = false;
+               break;
+           }
+        }
+        if(enough) {
+            size += word.length;
+        }
+    }
+    return  size;
+};

LeetCode/1381. 设计一个支持增量操作的栈.js

@@ -0,0 +1,88 @@
+// 请你设计一个支持下述操作的栈。
+
+// 实现自定义栈类 CustomStack ：
+
+// CustomStack(int maxSize)：用 maxSize 初始化对象，maxSize 是栈中最多能容纳的元素数量，栈在增长到 maxSize 之后则不支持 push 操作。
+// void push(int x)：如果栈还未增长到 maxSize ，就将 x 添加到栈顶。
+// int pop()：弹出栈顶元素，并返回栈顶的值，或栈为空时返回 -1 。
+// void inc(int k, int val)：栈底的 k 个元素的值都增加 val 。如果栈中元素总数小于 k ，则栈中的所有元素都增加 val 。
+//  
+
+// 示例：
+
+// 输入：
+// ["CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"]
+// [[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]
+// 输出：
+// [null,null,null,2,null,null,null,null,null,103,202,201,-1]
+// 解释：
+// CustomStack customStack = new CustomStack(3); // 栈是空的 []
+// customStack.push(1);                          // 栈变为 [1]
+// customStack.push(2);                          // 栈变为 [1, 2]
+// customStack.pop();                            // 返回 2 --> 返回栈顶值 2，栈变为 [1]
+// customStack.push(2);                          // 栈变为 [1, 2]
+// customStack.push(3);                          // 栈变为 [1, 2, 3]
+// customStack.push(4);                          // 栈仍然是 [1, 2, 3]，不能添加其他元素使栈大小变为 4
+// customStack.increment(5, 100);                // 栈变为 [101, 102, 103]
+// customStack.increment(2, 100);                // 栈变为 [201, 202, 103]
+// customStack.pop();                            // 返回 103 --> 返回栈顶值 103，栈变为 [201, 202]
+// customStack.pop();                            // 返回 202 --> 返回栈顶值 202，栈变为 [201]
+// customStack.pop();                            // 返回 201 --> 返回栈顶值 201，栈变为 []
+// customStack.pop();                            // 返回 -1 --> 栈为空，返回 -1
+//  
+
+// 提示：
+
+// 1 <= maxSize <= 1000
+// 1 <= x <= 1000
+// 1 <= k <= 1000
+// 0 <= val <= 100
+// 每种方法 increment，push 以及 pop 分别最多调用 1000 次
+
+
+
+
+/**
+ * @param {number} maxSize
+ */
+ var CustomStack = function(maxSize) {
+    this.queue = [];
+    this.maxSize = maxSize
+};
+
+/** 
+ * @param {number} x
+ * @return {void}
+ */
+CustomStack.prototype.push = function(x) {
+    if(this.queue.length<this.maxSize) this.queue.push(x)
+};
+
+/**
+ * @return {number}
+ */
+CustomStack.prototype.pop = function() {
+    if(this.queue.length==0) return -1;
+    return this.queue.pop()
+};
+
+/** 
+ * @param {number} k 
+ * @param {number} val
+ * @return {void}
+ */
+CustomStack.prototype.increment = function(k, val) {
+    let i=0;
+    while(i<k&&i<this.queue.length){
+        this.queue[i] += val
+        i++
+    }
+};
+
+/**
+ * Your CustomStack object will be instantiated and called as such:
+ * var obj = new CustomStack(maxSize)
+ * obj.push(x)
+ * var param_2 = obj.pop()
+ * obj.increment(k,val)
+ */

LeetCode/23. 合并K个升序链表.js

@@ -0,0 +1,99 @@
+// 给你一个链表数组，每个链表都已经按升序排列。
+
+// 请你将所有链表合并到一个升序链表中，返回合并后的链表。
+
+//  
+
+// 示例 1：
+
+// 输入：lists = [[1,4,5],[1,3,4],[2,6]]
+// 输出：[1,1,2,3,4,4,5,6]
+// 解释：链表数组如下：
+// [
+//   1->4->5,
+//   1->3->4,
+//   2->6
+// ]
+// 将它们合并到一个有序链表中得到。
+// 1->1->2->3->4->4->5->6
+// 示例 2：
+
+// 输入：lists = []
+// 输出：[]
+// 示例 3：
+
+// 输入：lists = [[]]
+// 输出：[]
+//  
+
+// 提示：
+
+// k == lists.length
+// 0 <= k <= 10^4
+// 0 <= lists[i].length <= 500
+// -10^4 <= lists[i][j] <= 10^4
+// lists[i] 按 升序 排列
+// lists[i].length 的总和不超过 10^4
+
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/merge-k-sorted-lists
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+/**
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+ var mergeKLists = function (lists) {
+    // 当是空数组的情况下
+    if (!lists.length) {
+      return null;
+    }
+    // 合并两个排序链表
+    const merge = (head1, head2) => {
+      let dummy = new ListNode(0);
+      let cur = dummy;
+      // 新链表，新的值小就先接谁
+      while (head1 && head2) {
+        if (head1.val < head2.val) {
+          cur.next = head1;
+          head1 = head1.next;
+        } else {
+          cur.next = head2;
+          head2 = head2.next;
+        }
+        cur = cur.next;
+      }
+      // 如果后面还有剩余的就把剩余的接上
+      cur.next = head1 == null ? head2 : head1;
+      return dummy.next;
+    };
+    const mergeLists = (lists, start, end) => {
+      if (start + 1 == end) {
+        return lists[start];
+      }
+      // 输入的k个排序链表，可以分成两部分，前k/2个链表和后k/2个链表
+      // 如果将这前k/2个链表和后k/2个链表分别合并成两个排序的链表，再将两个排序的链表合并，那么所有链表都合并了
+      let mid = (start + end) >> 1;
+      let head1 = mergeLists(lists, start, mid);
+      let head2 = mergeLists(lists, mid, end);
+      return merge(head1, head2);
+    };
+    return mergeLists(lists, 0, lists.length);
+  };
+  
+