✨ next premutation

Author: tangweikun

src/2-add-two-numbers/index.js

@@ -1,24 +1,31 @@
-// HELP:
-import { ListNode } from '../_utils';
-
-export const addTwoNumbers = (l1, l2) => {
-  const dummyHead = new ListNode(0);
-  let curr = dummyHead;
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function (l1, l2) {
+  const node = new ListNode();
+  let cur = node;
   let carry = 0;
 
   while (l1 || l2) {
-    let x = l1 ? l1.val : 0;
-    let y = l2 ? l2.val : 0;
-    let sum = carry + x + y;
-    if (l1) l1 = l1.next;
-    if (l2) l2 = l2.next;
+    const sum = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + carry;
+    carry = sum >= 10 ? 1 : 0;
+    cur.next = new ListNode(sum % 10);
+    cur = cur.next;
 
-    carry = ~~(sum / 10);
-    curr.next = new ListNode(sum % 10);
-    curr = curr.next;
+    l1 && (l1 = l1.next);
+    l2 && (l2 = l2.next);
   }
 
-  if (carry > 0) curr.next = new ListNode(carry);
+  carry && (cur.next = new ListNode(carry));
 
-  return dummyHead.next;
+  return node.next;
 };

src/3-longest-substring-without-repeating-characters/index.js

@@ -1,16 +1,20 @@
-// TODO:
-export function lengthOfLongestSubstring(str) {
-  const strLength = str.length;
-  let maxLength = 0;
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function (s) {
+  const len = s.length;
   const map = new Map();
-  let i = 0;
-  for (let j = 0; j < strLength; j++) {
-    if (map.has(str.charAt(j))) {
-      i = Math.max(map.get(str.charAt(j)), i);
+  let start = 0;
+  let res = 0;
+
+  for (let end = 0; end < len; end++) {
+    if (map.has(s[end])) {
+      start = Math.max(map.get(s[end]), start);
     }
-    maxLength = Math.max(maxLength, j - i + 1);
-    map.set(str.charAt(j), j + 1);
+    res = Math.max(res, end - start + 1);
+    map.set(s[end], end + 1);
   }
 
-  return maxLength;
-}
+  return res;
+};

src/31-next-premutation/index.js

@@ -0,0 +1,38 @@
+const assert = require('assert').strict;
+
+function nextPermutation(nums) {
+  let i = nums.length - 2; // 向左遍历，i从倒数第二开始是为了nums[i+1]要存在
+
+  // 寻找第一个小于右邻居的数
+  while (i >= 0 && nums[i] >= nums[i + 1]) {
+    i--;
+  }
+
+  // 这个数在数组中存在，从它身后挑一个数，和它换
+  if (i >= 0) {
+    let j = nums.length - 1; // 从最后一项，向左遍历
+
+    // 寻找第一个大于 nums[i] 的数
+    while (j >= 0 && nums[j] <= nums[i]) {
+      j--;
+    }
+
+    [nums[i], nums[j]] = [nums[j], nums[i]]; // 两数交换，实现变大
+  }
+
+  // 如果 i = -1，说明是递减排列，如 3 2 1，没有下一排列，直接翻转为最小排列：1 2 3
+  let l = i + 1;
+  let r = nums.length - 1;
+  while (l < r) {
+    // i 右边的数进行翻转，使得变大的幅度小一些
+    [nums[l], nums[r]] = [nums[r], nums[l]];
+    l++;
+    r--;
+  }
+
+  return nums;
+}
+
+assert.deepEqual(nextPermutation([1, 2, 3]), [1, 3, 2]);
+assert.deepEqual(nextPermutation([3, 2, 1]), [1, 2, 3]);
+assert.deepEqual(nextPermutation([1, 1, 5]), [1, 5, 1]);

src/5-longest-palindromic-substring/index.js

@@ -3,22 +3,21 @@
  * @return {string}
  */
 
-// 字节跳动
-// HELP:
-
-var longestPalindrome = function(s) {
+var longestPalindrome = function (s) {
   let n = s.length;
-  let res = "";
-  let dp = Array.from(new Array(n), () => new Array(n).fill(0));
+  let dp = Array.from({ length: n }, () => Array(n).fill(false));
+  let start = 0;
+  let end = 0;
 
   for (let i = n - 1; i >= 0; i--) {
     for (let j = i; j < n; j++) {
-      dp[i][j] = s[i] == s[j] && (j - i < 2 || dp[i + 1][j - 1]);
-      if (dp[i][j] && j - i + 1 > res.length) {
-        res = s.slice(i, j + 1);
+      dp[i][j] = s[i] === s[j] && (j - i < 2 || dp[i + 1][j - 1]);
+      if (dp[i][j] && j - i > end - start) {
+        start = i;
+        end = j;
       }
     }
   }
 
-  return res;
+  return s.slice(start, end + 1);
 };