Merge branch 'master' of github.com:everthis/leetcode-js

Author: everthis

1041-robot-bounded-in-circle.js

@@ -0,0 +1,14 @@
+/**
+ * @param {string} instructions
+ * @return {boolean}
+ */
+const isRobotBounded = function(instructions) {
+  let x = 0, y = 0, i = 0, d = [[0, 1], [1, 0], [0, -1], [ -1, 0]];
+  for (let j = 0; j < instructions.length; ++j)
+    if (instructions.charAt(j) === 'R') i = (i + 1) % 4;
+    else if (instructions .charAt(j) === 'L') i = (i + 3) % 4;
+    else {
+        x += d[i][0]; y += d[i][1];
+    }
+  return x == 0 && y == 0 || i > 0;
+};

1043-partition-array-for-maximum-sum.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} A
+ * @param {number} K
+ * @return {number}
+ */
+const maxSumAfterPartitioning = function(A, K) {
+  const N = A.length
+  const dp = new Array(N).fill(0);
+  for (let i = 0; i < N; ++i) {
+    let curMax = 0;
+    for (let j = 1; j <= K && i - j + 1 >= 0; j++) {
+      curMax = Math.max(curMax, A[i - j + 1]);
+      dp[i] = Math.max(dp[i], (i >= j ? dp[i - j] : 0) + curMax * j);
+    }
+  }
+  return dp[N - 1];
+};

1047-remove-all-adjacent-duplicates-in-string.js

@@ -0,0 +1,15 @@
+/**
+ * @param {string} S
+ * @return {string}
+ */
+const removeDuplicates = function(S) {
+  const queue = []
+  for(let i = 0; i < S.length; i++) {
+    if(queue.length > 0 && queue[queue.length - 1] === S[i]) {
+       queue.pop()
+    } else {
+      queue.push(S[i])
+    }
+  }
+  return queue.join('')
+};

1048-longest-string-chain.js

@@ -0,0 +1,21 @@
+/**
+ * @param {string[]} words
+ * @return {number}
+ */
+const longestStrChain = function(words) {
+  words.sort((a, b) => a.length - b.length)
+  const dp = {}
+  for(let el of words) {
+    dp[el] = 1
+  }
+  
+  let res = Number.MIN_VALUE
+  for(let w of words) {
+    for(let i = 0; i < w.length; i++) {
+      let prev = w.slice(0, i) + w.slice(i + 1)
+      dp[w] = Math.max(dp[w], (dp[prev] || 0) + 1 )
+    }
+    if(dp[w] > res) res = dp[w]
+  }
+  return res
+};

1049-last-stone-weight-ii.js

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+const lastStoneWeightII = function(stones) {
+  let sum=stones.reduce((a,b)=>a+b)
+  let dp=Array(sum+1).fill(0)
+  dp[0]=1
+  for(let i=0;i<stones.length;i++){
+    let cur=stones[i]
+    for(let j=dp.length-1;j>=0;j--){
+      if(j-stones[i]<0)break
+      if(dp[j-stones[i]]){
+        dp[j]=1
+      }
+    }
+  }
+
+  let minLen=Infinity
+  for(let i=0;i<dp.length;i++){
+    if(dp[i]){
+      if(i*2-sum>=0)minLen=Math.min(minLen,i*2-sum)
+    }
+  }
+  return minLen
+};

1051-height-checker.js

@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+const heightChecker = function(heights) {
+  const arr = heights.slice(0).sort((a, b) => a - b)
+  let res = 0
+  for(let i = 0, len = heights.length; i < len; i++) {
+    if(arr[i] !== heights[i]) res++
+  }
+  
+  return res
+};

1052-grumpy-bookstore-owner.js

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} customers
+ * @param {number[]} grumpy
+ * @param {number} X
+ * @return {number}
+ */
+const maxSatisfied = function(customers, grumpy, X) {
+  if (customers.length === 1) return customers[0]
+  const totalSatisfiedCustomers = customers.reduce(
+    (ac, el, idx) => ac + (grumpy[idx] === 0 ? el : 0),
+    0
+  )
+  const arr = customers.map((el, idx) => (grumpy[idx] === 1 ? el : 0))
+  const acArr = []
+  let ac = 0
+  for (let i = 0, len = arr.length; i < len; i++) {
+    acArr[i] = ac = ac + arr[i]
+  }
+  let max = 0
+  for (let i = X - 1, len = grumpy.length; i < len; i++) {
+    let tmp = i - X < 0 ? 0 : acArr[i - X]
+    if (acArr[i] - tmp > max) max = acArr[i] - tmp
+  }
+
+  return totalSatisfiedCustomers + max
+}

1053-previous-permutation-with-one-swap.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} A
+ * @return {number[]}
+ */
+const prevPermOpt1 = function(A) {
+  let n = A.length, left = n - 2, right = n - 1;
+  while (left >= 0  && A[left] <= A[left + 1]) left--;
+  if (left < 0) return A;
+  while (A[left] <= A[right]) right--;
+  while (A[right - 1] == A[right]) right--;
+  swap(A,left,right)
+  return A;
+};
+function swap(a, i, j) {
+  let tmp = a[i]
+  a[i] = a[j]
+  a[j] = tmp
+}

1054-distant-barcodes.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} barcodes
+ * @return {number[]}
+ */
+const rearrangeBarcodes = function(barcodes) {
+	const map = {};
+	barcodes.forEach(b => map[b] = (map[b] || 0) + 1);
+	const keys = Object.keys(map).sort((k1, k2) => map[k1] - map[k2]);
+
+	let idx = 1;
+	for (let k of keys) {
+		let t = map[k];
+
+		for (let i = 0; i < t; i++) {
+			if (idx >= barcodes.length) idx = 0;
+			barcodes[idx] = k;
+			idx += 2;
+		}
+	}
+
+	return barcodes;
+};

124-binary-tree-maximum-path-sum.js

@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const maxPathSum = function(root) {
+  let obj = {
+    max: Number.MIN_SAFE_INTEGER
+  }
+  traverse(root, obj)
+  
+  return obj.max
+};
+
+function traverse(node, obj) {
+  if(node === null) return 0
+  let left = Math.max(0, traverse(node.left, obj))
+  let right = Math.max(0, traverse(node.right, obj))
+  obj.max = Math.max(obj.max, node.val+left+right)
+  return node.val + Math.max(left, right)
+}
+

132-palindrome-partitioning-ii.js

@@ -2,24 +2,54 @@
  * @param {string} s
  * @return {number}
  */
+
+const minCut = function(s) {
+  const n = s.length
+  if (n <= 1) return 0
+  const dp = new Array(n).fill(0)
+  for (let i = 1; i < n; i++) dp[i] = i
+  for (let i = 1; i < n; i++) {
+    // odd
+    for (
+      let start = i, end = i;
+      end < n && start >= 0 && s[end] === s[start];
+      start--, end++
+    ) {
+      dp[end] = Math.min(dp[end], start === 0 ? 0 : dp[start - 1] + 1)
+    }
+    // even
+    for (
+      let start = i - 1, end = i;
+      end < n && start >= 0 && s[end] === s[start];
+      start--, end++
+    ) {
+      dp[end] = Math.min(dp[end], start === 0 ? 0 : dp[start - 1] + 1)
+    }
+  }
+  return dp[n - 1]
+}
+
+
+
+// another
+
 const minCut = function(s) {
   const n = s.length
   const cut = new Array(n + 1).fill(0)
   for (let i = 0; i <= n; i++) cut[i] = i - 1
   for (let i = 0; i < n; i++) {
-    for (
-      let j = 0;
-      i - j >= 0 && i + j < n && s[i - j] == s[i + j];
-      j++ // odd length palindrome
-    )
-      cut[i + j + 1] = Math.min(cut[i + j + 1], 1 + cut[i - j])
-
+    // odd
+    for (let j = 0; i + j < n && i - j >= 0 && s[i + j] === s[i - j]; j++) {
+      cut[i + j + 1] = Math.min(cut[i + j + 1], cut[i - j] + 1)
+    }
+    // even
     for (
       let j = 1;
-      i - j + 1 >= 0 && i + j < n && s[i - j + 1] == s[i + j];
-      j++ // even length palindrome
-    )
-      cut[i + j + 1] = Math.min(cut[i + j + 1], 1 + cut[i - j + 1])
+      i + j < n && i - j + 1 >= 0 && s[i + j] === s[i - j + 1];
+      j++
+    ) {
+      cut[i + j + 1] = Math.min(cut[i + j + 1], cut[i - j + 1] + 1)
+    }
   }
   return cut[n]
 }

135-candy.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} ratings
+ * @return {number}
+ */
+const candy = function(ratings) {
+  const candies = new Array(ratings.length).fill(1);
+  for (let i = 1; i < candies.length; i++) {
+    if (ratings[i] > ratings[i - 1]) {
+      candies[i] = candies[i - 1] + 1;
+    }
+  }
+  let sum = candies[candies.length - 1];
+  for (let i = candies.length - 2; i >= 0; i--) {
+    if (ratings[i] > ratings[i + 1]) {
+      candies[i] = Math.max(candies[i], candies[i + 1] + 1);
+    }
+    sum += candies[i];
+  }
+  return sum;
+};

136-single-number.js

@@ -0,0 +1,9 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const singleNumber = function(nums) {
+  let xor = nums[0]
+  for(let i = 1; i< nums.length; i++) xor ^= nums[i]
+  return xor
+};

215-kth-largest-element-in-an-array.js

@@ -23,3 +23,85 @@ const findKthLargest = function(nums, k) {
   else if (k - larger.length - pivotCount <= 0) return pivot;
   else return findKthLargest(smaller, k - larger.length - pivotCount);
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const findKthLargest = function(nums, k) {
+  return quickselect(nums, 0, nums.length - 1, k)
+};
+function quickselect(arr, lo, hi, k) {
+  let pivtIdx = Math.floor(Math.random() * (hi - lo + 1)) + lo
+  let pivtVal = arr[pivtIdx]
+  ;[arr[hi], arr[pivtIdx]] = [arr[pivtIdx], arr[hi]]
+  let i = lo
+  let j = hi - 1
+
+  while (i <= j) {
+    if (arr[i] <= pivtVal) {
+      i++
+    } else {
+      ;[arr[j], arr[i]] = [arr[i], arr[j]]
+      j--
+    }
+  }
+
+  ;[arr[i], arr[hi]] = [arr[hi], arr[i]]
+
+  pivtIdx = i
+
+  if (pivtIdx === arr.length - k) return arr[pivtIdx]
+  if (pivtIdx < arr.length - k) return quickselect(arr, pivtIdx + 1, hi, k)
+  return quickselect(arr, lo, pivtIdx - 1, k)
+}
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const findKthLargest = function(list, k) {
+  const len = list.length
+  let lo = 0
+  let hi = len - 1
+  let pivot = 0
+  let t = len - k
+  while(lo < hi) {
+    pivot = partition(list, lo, hi)
+    if(pivot === t) {
+      break
+    } else if(pivot < t) {
+      lo = pivot + 1
+    } else if(pivot > t) {
+      hi = pivot - 1
+    }
+  }
+  
+  return list[t]
+}
+
+function partition(arr, s, e) {
+  let t = arr[e]
+  let i = s
+  for(let j = s; j <= e - 1; j++) {
+    if(arr[j] <= t) {
+      swap(arr, i, j)
+      i++
+    }
+  }
+  swap(arr, i, e) 
+  return i
+}
+
+function swap(arr, i, j) {
+  let tmp = arr[i]
+  arr[i] = arr[j]
+  arr[j] = tmp
+}
+