add 025 030 031 032 033 034 036 038 067 101

Author: zongyanqi

025-Reverse-Nodes-in-k-Group.js

@@ -0,0 +1,128 @@
+/**
+ * https://leetcode.com/problems/reverse-nodes-in-k-group/description/
+ * Difficulty:Hard
+ *
+ * Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.
+ * k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.
+ * You may not alter the values in the nodes, only nodes itself may be changed.
+ * Only constant memory is allowed.
+ * For example,
+ * Given this linked list: 1->2->3->4->5
+ * For k = 2, you should return: 2->1->4->3->5
+ * For k = 3, you should return: 3->2->1->4->5
+ *
+ */
+
+// Definition for singly-linked list.
+function ListNode(val) {
+    this.val = val;
+    this.next = null;
+}
+
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+var reverseKGroup = function (head, k) {
+    // if (k === 1)
+    //     return head;
+    var t = new ListNode(0);
+    t.next = head;
+    var s = t;
+
+    while (true) {
+        var cnt = 0;
+        var f = t;
+        while (cnt++ < k && f) {
+            f = f.next;
+        }
+        // console.log(p(t), p(f));
+
+        if (!f || cnt !== k + 1) break;
+        cnt = 0;
+        var a = t.next;
+
+        while (++cnt < k) {
+            var b = a.next;
+            a.next = b.next;
+            b.next = t.next;
+            t.next = b;
+            // console.log(p(t), p(a), p(b));
+        }
+        t = a;
+    }
+
+    return s.next;
+};
+
+function p(n) {
+    var t = n;
+    var s = '';
+    while (t) {
+        s = s + t.val + '->';
+        t = t.next;
+    }
+    s += 'null';
+    return s;
+}
+//
+console.log(p(reverseKGroup({
+    val: 1,
+    next: {
+        val: 2,
+        next: {
+            val: 3,
+            next: {
+                val: 4
+            }
+        }
+    }
+}, 2)))
+
+console.log(p(reverseKGroup({val: 1}, 2)));
+
+console.log(p(reverseKGroup({
+    val: 1,
+    next: {
+        val: 2
+    }
+}, 2)))
+
+console.log(p(reverseKGroup({
+    val: 1,
+    next: {
+        val: 2,
+        next: {
+            val: 3,
+            next: {
+                val: 4,
+                next: {
+                    val: 5,
+                    next: {
+                        val: 6,
+                        next: {
+                            val: 7
+                        }
+                    }
+                }
+            }
+        }
+    }
+}, 3)))
+//
+
+console.log(p(reverseKGroup({
+    val: 1,
+    next: {
+        val: 2,
+        next: {
+            val: 3,
+            next: {
+                val: 4,
+                next: null
+            }
+        }
+    }
+}, 2)));
+

030-Substring-with-Concatenation-of-All-Words.js

@@ -0,0 +1,49 @@
+/**
+ *
+ * https://leetcode.com/problems/substring-with-concatenation-of-all-words/description/
+ * Difficulty:Hard
+ *
+ * You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s)
+ * in s that is a concatenation of each word in words exactly once and without any intervening characters.
+ * For example, given:
+ * s: "barfoothefoobarman"
+ * words: ["foo", "bar"]
+ * You should return the indices: [0,9].
+ * (order does not matter).
+ *
+ */
+/**
+ * @param {string} s
+ * @param {string[]} words
+ * @return {number[]}
+ */
+var findSubstring = function (s, words) {
+    if (!s.length || !words.length) return [];
+    var ans = [];
+    var toFind = {};
+
+    var m = words.length;
+    var n = words[0].length;
+
+    for (var i = 0; i < m; i++) {
+        toFind[words[i]] = (toFind[words[i]] || 0) + 1;
+    }
+
+    for (i = 0; i <= s.length - m * n; i++) {
+        var found = {};
+
+        for (var j = 0; j < m; j++) {
+            var k = i + n * j;
+            var w = s.substr(k, n);
+            if (!toFind[w]) break;
+            found[w] = (found[w] || 0) + 1;
+            if (found[w] > toFind[w]) break;
+        }
+        if (j === m) ans.push(i);
+    }
+
+    return ans;
+
+};
+
+console.log(findSubstring('barfoothefoobarman', ['foo', 'bar']));

031-Next-Permutation.js

@@ -0,0 +1,87 @@
+/**
+ * https://leetcode.com/problems/next-permutation/description/
+ * Difficulty:Medium
+ *
+ * Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.
+ * If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).
+ * The replacement must be in-place, do not allocate extra memory.
+ * Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
+ * 1,2,3 → 1,3,2
+ * 3,2,1 → 1,2,3
+ * 1,1,5 → 1,5,1
+ */
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var nextPermutation = function (nums) {
+
+    if (nums.length < 2) return;
+    var peak = nums.length - 1;
+    for (var i = peak - 1; nums[i] >= nums[peak]; peak = i--);
+
+    if (peak !== 0) {
+        var swapIndex = findSwap(nums, peak, nums.length - 1, peak - 1);
+        if (swapIndex !== -1) {
+            swap(nums, peak - 1, swapIndex);
+        }
+    }
+
+    reverse(nums, peak, nums.length - 1);
+
+};
+
+function findSwap(nums, s, e, target) {
+    for (var i = e; i >= s; i--) {
+        if (nums[i] > nums[target]) return i;
+    }
+    return -1;
+}
+
+function swap(nums, s, e) {
+    var t = nums[s];
+    nums[s] = nums[e];
+    nums[e] = t;
+}
+function reverse(nums, s, e) {
+    // var len = e - s;
+    for (var i = 0; i < Math.ceil((e - s ) / 2); i++) {
+
+        swap(nums, s + i, e - i);
+    }
+    // return nums;
+}
+
+// console.log(reverse([1, 2, 3, 4, 5], 0, 4));
+// console.log(reverse([1, 2, 3, 4, 5], 3, 4));
+// console.log(reverse([1, 2, 3, 4, 5], 2, 3));
+// console.log(reverse([1, 2, 3, 4, 5], 1, 1));
+// console.log(reverse([1, 2, 3, 4, 5], 1, 4));
+
+// var nums = [1, 2, 5, 4, 3];
+// console.log(nums);
+// nextPermutation(nums);
+// console.log(nums);
+//
+console.log('====');
+
+var nums = [2, 3, 1];
+console.log(nums);
+nextPermutation(nums);
+console.log(nums);
+
+console.log('====');
+
+var nums = [1, 1];
+console.log(nums);
+nextPermutation(nums);
+console.log(nums);
+
+console.log('====');
+
+var nums = [3, 2, 1];
+console.log(nums);
+nextPermutation(nums);
+console.log(nums);
+
+

032-Longest-Valid-Parentheses.js

@@ -0,0 +1,50 @@
+/**
+ * https://leetcode.com/problems/longest-valid-parentheses/description/
+ * Difficulty:Hard
+ *
+ * Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.
+ * For "(()", the longest valid parentheses substring is "()", which has length = 2.
+ * Another example is ")()())", where the longest valid parentheses substring is "()()", which has length = 4.
+ */
+
+/**
+ * 使用栈解决
+ * @param {string} s
+ * @return {number}
+ */
+var longestValidParentheses = function (s) {
+    var stack = [];
+    for (var i = 0; i < s.length; i++) {
+        if (s[i] === '(') stack.push(i);
+        else {
+            if (stack.length && s[stack[stack.length - 1]] === '(') stack.length--;
+            else stack.push(i);
+        }
+    }
+
+    if (!stack.length) return s.length;
+    var longest = 0;
+    var end = s.length;
+    var start = 0;
+    while (stack.length) {
+        start = stack[stack.length - 1];
+        stack.length--;
+        longest = Math.max(longest, end - start - 1);
+        end = start;
+    }
+    longest = Math.max(longest, end);
+    return longest;
+};
+
+
+console.log(longestValidParentheses('()'), 2);
+console.log(longestValidParentheses('())'), 2);
+console.log(longestValidParentheses('(()'), 2);
+console.log(longestValidParentheses('))()())((())))'), 6);
+console.log(longestValidParentheses('()'), 2);
+console.log(longestValidParentheses('('), 0);
+console.log(longestValidParentheses(')()()))()()())'), 6);
+console.log(longestValidParentheses('()(()'), 2);
+console.log(longestValidParentheses('()(()'), 2);
+console.log(longestValidParentheses('(()'), 2);
+

033-Search-in-Rotated-Sorted-Array.js

@@ -0,0 +1,46 @@
+/**
+ * https://leetcode.com/problems/search-in-rotated-sorted-array/description/
+ * Difficulty:Medium
+ *
+ * Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+ * (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
+ * You are given a target value to search. If found in the array return its index, otherwise return -1.
+ * You may assume no duplicate exists in the array.
+ */
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function (nums, target) {
+
+
+    var lo = 0;
+    var hi = nums.length - 1;
+    while (lo < hi) {
+        var mid = Math.floor((lo + hi) / 2);
+        if (nums[mid] < nums[hi]) hi = mid;
+        else lo = mid + 1;
+    }
+    var i = lo;
+
+    lo = target < nums[0] ? i : 0;
+    hi = target <= nums[nums.length - 1] ? nums.length - 1 : i;
+
+    // console.log(nums, lo, hi);
+    while (lo <= hi) {
+        mid = Math.floor((lo + hi) / 2);
+        // console.log(lo, mid, hi)
+        if (nums[mid] < target) lo = mid + 1;
+        else if (nums[mid] === target) return mid;
+        else hi = mid - 1;
+    }
+
+    return -1;
+
+};
+
+console.log(search([], 5))
+console.log(search([1], 0))
+console.log(search([4, 5, 6, 7, 0, 1, 2], 2))
+console.log(search([3, 1], 1))