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

Author: L-SUI

LeetCode/1013. 将数组分成和相等的三个部分.js

@@ -0,0 +1,52 @@
+// 给你一个整数数组 arr，只有可以将其划分为三个和相等的 非空 部分时才返回 true，否则返回 false。
+
+// 形式上，如果可以找出索引 i + 1 < j 且满足 (arr[0] + arr[1] + ... + arr[i] == arr[i + 1] + arr[i + 2] + ... + arr[j - 1] == arr[j] + arr[j + 1] + ... + arr[arr.length - 1]) 就可以将数组三等分。
+
+//  
+
+// 示例 1：
+
+// 输入：arr = [0,2,1,-6,6,-7,9,1,2,0,1]
+// 输出：true
+// 解释：0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1
+// 示例 2：
+
+// 输入：arr = [0,2,1,-6,6,7,9,-1,2,0,1]
+// 输出：false
+// 示例 3：
+
+// 输入：arr = [3,3,6,5,-2,2,5,1,-9,4]
+// 输出：true
+// 解释：3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4
+//  
+
+// 提示：
+
+// 3 <= arr.length <= 5 * 104
+// -104 <= arr[i] <= 104
+
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/partition-array-into-three-parts-with-equal-sum
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+/**
+ * @param {number[]} arr
+ * @return {boolean}
+ */
+/**
+ * @param {number[]} arr
+ * @return {boolean}
+ */
+ var canThreePartsEqualSum = function(arr) {
+    let sum = arr.reduce((a,b) => a + b)
+    let num = 3
+    let temp = 0
+    for(let a of arr){
+        temp += a
+        if (temp === sum / 3) num--, temp = 0
+    }
+    return num <=  0
+};

LeetCode/1021. 删除最外层的括号.js

@@ -0,0 +1,61 @@
+// 有效括号字符串为空 ""、"(" + A + ")" 或 A + B ，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。
+
+// 例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。
+// 如果有效字符串 s 非空，且不存在将其拆分为 s = A + B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。
+
+// 给出一个非空有效字符串 s，考虑将其进行原语化分解，使得：s = P_1 + P_2 + ... + P_k，其中 P_i 是有效括号字符串原语。
+
+// 对 s 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 s 。
+
+//  
+
+// 示例 1：
+
+// 输入：s = "(()())(())"
+// 输出："()()()"
+// 解释：
+// 输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，
+// 删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。
+// 示例 2：
+
+// 输入：s = "(()())(())(()(()))"
+// 输出："()()()()(())"
+// 解释：
+// 输入字符串为 "(()())(())(()(()))"，原语化分解得到 "(()())" + "(())" + "(()(()))"，
+// 删除每个部分中的最外层括号后得到 "()()" + "()" + "()(())" = "()()()()(())"。
+// 示例 3：
+
+// 输入：s = "()()"
+// 输出：""
+// 解释：
+// 输入字符串为 "()()"，原语化分解得到 "()" + "()"，
+// 删除每个部分中的最外层括号后得到 "" + "" = ""。
+//  
+
+// 提示：
+
+// 1 <= s.length <= 105
+// s[i] 为 '(' 或 ')'
+// s 是一个有效括号字符串
+// 通过次数57,377提交次数73,236
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/remove-outermost-parentheses
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+ var removeOuterParentheses = function(S) {
+    let count = 0, ans = '';
+    for (let i = 0; i < S.length; i++) {
+        if(S[i] === '(' && count++ > 0) ans += '('
+        if(S[i] === ')' && count-- > 1) ans += ')';
+    }
+    return ans;
+};

LeetCode/1022. 从根到叶的二进制数之和.js

@@ -0,0 +1,68 @@
+// 给出一棵二叉树，其上每个结点的值都是 0 或 1 。每一条从根到叶的路径都代表一个从最高有效位开始的二进制数。例如，如果路径为 0 -> 1 -> 1 -> 0 -> 1，那么它表示二进制数 01101，也就是 13 。
+
+// 对树上的每一片叶子，我们都要找出从根到该叶子的路径所表示的数字。
+
+// 返回这些数字之和。题目数据保证答案是一个 32 位 整数。
+
+//  
+
+// 示例 1：
+
+
+// 输入：root = [1,0,1,0,1,0,1]
+// 输出：22
+// 解释：(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
+// 示例 2：
+
+// 输入：root = [0]
+// 输出：0
+// 示例 3：
+
+// 输入：root = [1]
+// 输出：1
+// 示例 4：
+
+// 输入：root = [1,1]
+// 输出：3
+//  
+
+// 提示：
+
+// 树中的结点数介于 1 和 1000 之间。
+// Node.val 为 0 或 1 。
+
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/sum-of-root-to-leaf-binary-numbers
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+ var sumRootToLeaf = function (root) {
+    const arr = []
+    const loop = (node, v) => {
+        if (!node.left && !node.right) {
+            arr.push(parseInt(v + node.val, 2))
+            return
+        }
+
+        node.left  && loop(node.left,  v + node.val)
+        node.right && loop(node.right, v + node.val)
+    }
+
+    loop(root, '')
+    return arr.reduce((sum, cur) => sum + cur, 0)
+}

LeetCode/1037. 有效的回旋镖.js

@@ -0,0 +1,40 @@
+// 回旋镖定义为一组三个点，这些点各不相同且不在一条直线上。
+
+// 给出平面上三个点组成的列表，判断这些点是否可以构成回旋镖。
+
+//  
+
+// 示例 1：
+
+// 输入：[[1,1],[2,3],[3,2]]
+// 输出：true
+// 示例 2：
+
+// 输入：[[1,1],[2,2],[3,3]]
+// 输出：false
+//  
+
+// 提示：
+
+// points.length == 3
+// points[i].length == 2
+// 0 <= points[i][j] <= 100
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/valid-boomerang
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+/**
+ * @param {number[][]} points
+ * @return {boolean}
+ */
+ var isBoomerang = function(points) {
+    const dx = points[1][0] - points[0][0];
+    const dy = points[1][1] - points[0][1];
+    const ex = points[2][0] - points[0][0];
+    const ey = points[2][1] - points[0][1];
+    return dx * ey != dy * ex;
+};

LeetCode/1071. 字符串的最大公因子.js

@@ -0,0 +1,36 @@
+// 对于字符串 S 和 T，只有在 S = T + ... + T（T 自身连接 1 次或多次）时，我们才认定 “T 能除尽 S”。
+
+// 返回最长字符串 X，要求满足 X 能除尽 str1 且 X 能除尽 str2。
+
+//  
+
+// 示例 1：
+
+// 输入：str1 = "ABCABC", str2 = "ABC"
+// 输出："ABC"
+// 示例 2：
+
+// 输入：str1 = "ABABAB", str2 = "ABAB"
+// 输出："AB"
+// 示例 3：
+
+// 输入：str1 = "LEET", str2 = "CODE"
+// 输出：""
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/greatest-common-divisor-of-strings
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+/**
+ * @param {string} str1
+ * @param {string} str2
+ * @return {string}
+ */
+ var gcdOfStrings = function(str1, str2) {
+    if (str1 + str2 !== str2 + str1) return ''
+    const gcd = (a, b) => (0 === b ? a : gcd(b, a % b))
+    return str1.substring(0, gcd(str1.length, str2.length))
+  };
+  

LeetCode/1078. Bigram 分词.js

@@ -0,0 +1,53 @@
+// 给出第一个词 first 和第二个词 second，考虑在某些文本 text 中可能以 "first second third" 形式出现的情况，其中 second 紧随 first 出现，third 紧随 second 出现。
+
+// 对于每种这样的情况，将第三个词 "third" 添加到答案中，并返回答案。
+
+//  
+
+// 示例 1：
+
+// 输入：text = "alice is a good girl she is a good student", first = "a", second = "good"
+// 输出：["girl","student"]
+// 示例 2：
+
+// 输入：text = "we will we will rock you", first = "we", second = "will"
+// 输出：["we","rock"]
+//  
+
+// 提示：
+
+// 1 <= text.length <= 1000
+// text 由一些用空格分隔的单词组成，每个单词都由小写英文字母组成
+// 1 <= first.length, second.length <= 10
+// first 和 second 由小写英文字母组成
+
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/occurrences-after-bigram
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+/**
+ * @param {string} text
+ * @param {string} first
+ * @param {string} second
+ * @return {string[]}
+ */
+/**
+ * @param {string} text
+ * @param {string} first
+ * @param {string} second
+ * @return {string[]}
+ */
+ var findOcurrences = function (text, first, second) {
+    let ans = [];
+    let arr = text.split(' ');
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i] === first && arr[i + 1] && arr[i + 1] === second && arr[i + 2]) {
+            ans.push(arr[i + 2])
+        }
+    }
+    return ans
+};

LeetCode/1108. IP 地址无效化.js

@@ -0,0 +1,32 @@
+// 给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
+
+// 所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."。
+
+//  
+
+// 示例 1：
+
+// 输入：address = "1.1.1.1"
+// 输出："1[.]1[.]1[.]1"
+// 示例 2：
+
+// 输入：address = "255.100.50.0"
+// 输出："255[.]100[.]50[.]0"
+//  
+
+// 提示：
+
+// 给出的 address 是一个有效的 IPv4 地址
+
+// 来源：力扣（LeetCode）
+// 链接：https://leetcode-cn.com/problems/defanging-an-ip-address
+// 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+/**
+ * @param {string} address
+ * @return {string}
+ */
+ var defangIPaddr = function(address) {
+    return address.split('.').join('[.]')
+};