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)
+}
+