刷题不在多，需要举一反三

1. 两数之和

  1. // 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
  3. // 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
  5. /**
  6.  * @param {number[]} nums
  7.  * @param {number} target
  8.  * @return {number[]}
  9.  */
  10. var twoSum = function (nums, target) {
  11.     for (let i = 0; i < nums.length; i++) {
  12.         let result = target - nums[i];
  13.         if (nums.lastIndexOf(result) !== -1 && nums.lastIndexOf(result) !== i) {
  14.             return [i, nums.lastIndexOf(result)];
  15.         }
  16.     }
  17. };
  19. var twoSum = function (nums, target) {
  20.     for (let i = 0; i < nums.length; i++) {
  21.         let result = nums.lastIndexOf(target - nums[i]);
  22.         if (result > i) {
  23.             return [i, result];
  24.         }
  25.     }
  26. };
  28. var twoSum = function (nums, target) {
  29.     for (let i = 0; i < nums.length - 1; i++) {
  30.         for (let j = i + 1; j < nums.length; j++) {
  31.             if (nums[i] + nums[j] === target) {
  32.                 return [i, j];
  33.             }
  34.         }
  35.     }
  36. };
  38. var twoSum = function (nums, target) {
  39.     let map = new Map();
  40.     for (let i = 0; i < nums.length; i++) {
  41.         let k = target - nums[i];
  42.         if (map.has(k)) {
  43.             return [map.get(k), i];
  44.         }
  45.         map.set(nums[i], i);
  46.     }
  47.     return [];
  48. };

2. 两数相加

  1. // 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
  3. // 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
  5. // 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
  7. /**
  8.  * Definition for singly-linked list.
  9.  * function ListNode(val) {
  10.  *     this.val = val;
  11.  *     this.next = null;
  12.  * }
  13.  */
  14. /**
  15.  * @param {ListNode} l1
  16.  * @param {ListNode} l2
  17.  * @return {ListNode}
  18.  */
  19. var addTwoNumbers = function (l1, l2) {
  20.     let c = 0;
  21.     let r = new ListNode();
  22.     let p = r;
  23.     let p1 = l1;
  24.     let p2 = l2;
  25.     while (p1 || p2 || c) {
  26.         c += (p1 && p1.val) + (p2 && p2.val);
  27.         p.next = new ListNode(c % 10);
  28.         c = parseInt(c / 10);
  29.         p1 && (p1 = p1.next);
  30.         p2 && (p2 = p2.next);
  31.         p = p.next;
  32.     }
  33.     return r.next;
  34. };

3. 无重复字符的最长子串

  1. // 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
  3. /**
  4.  * @param {string} s
  5.  * @return {number}
  6.  */
  7. // var lengthOfLongestSubstring = function (s) {
  8. //   let arr = [], max = 0;
  9. //   for (let i = 0; i < s.length; i++) {
  10. //     let index = arr.indexOf(s[i]);
  11. //     if (index !== -1) {
  12. //       arr.splice(0, index + 1);
  13. //     }
  14. //     arr.push(s.charAt(i));
  15. //     max = Math.max(arr.length, max);
  16. //   }
  17. //   return max;
  18. // };
  20. var lengthOfLongestSubstring = function (s) {
  21.     let index = 0, max = 0;
  22.     for (let i = 0, j = 0; j < s.length; j++) {
  23.         index = s.substring(i, j).indexOf(s[j]);
  24.         if (index === -1) {
  25.             max = Math.max(max, j - i + 1);
  26.         } else {
  27.             i = i + index + 1;
  28.         }
  29.     }
  30.     return max;
  31. };

7. 整数反转

  1. // 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
  3. /**
  4.  * @param {number} x
  5.  * @return {number}
  6.  */
  7. var reverse = function (x) {
  8.     var result = 0;
  9.     var sign = Math.sign(x);
  10.     x = Math.abs(x);
  11.     while (x != 0) {
  12.         result = result * 10 + (x % 10);
  13.         x = (x / 10) | 0;
  14.     }
  15.     if (result > 2147483647 || result < -2147483648) {
  16.         return 0;
  17.     }
  18.     return sign * result;
  19. };

9. 回文数

  1. // 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
  3. /**
  4.  * @param {number} x
  5.  * @return {boolean}
  6.  */
  7. var isPalindrome = function (x) {
  8.     return x.toString() === x.toString().split("").reverse().join("");
  9. };

13. 罗马数字转整数

  1. // 罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
  3. // 字符          数值
  4. // I             1
  5. // V             5
  6. // X             10
  7. // L             50
  8. // C             100
  9. // D             500
  10. // M             1000
  11. // 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
  13. // 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
  15. // I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
  16. // X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
  17. // C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
  18. // 给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
  20. /**
  21.  * @param {string} s
  22.  * @return {number}
  23.  */
  24. var romanToInt = function (s) {
  25.     const map = {
  26.         I: 1,
  27.         V: 5,
  28.         X: 10,
  29.         L: 50,
  30.         C: 100,
  31.         D: 500,
  32.         M: 1000,
  33.     };
  34.     let req = 0;
  35.     for (let i = 0; i < s.length; i++) {
  36.         if (i < s.length && map[s[i]] < map[s[i + 1]]) {
  37.             req -= map[s[i]];
  38.         } else {
  39.             req += map[s[i]];
  40.         }
  41.     }
  42.     return req;
  43. };

17. 电话号码的字母组合

  1. // 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
  2. // 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
  4. /**
  5.  * @param {string} digits
  6.  * @return {string[]}
  7.  */
  8. var letterCombinations = function (digits) {
  9.     if (digits.length <= 0) return [];
  10.     let map = ["", 1, "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"];
  11.     let num = digits.split("");
  12.     let code = [];
  13.     num.forEach((item) => {
  14.         if (map[item]) {
  15.             code.push(map[item]);
  16.         }
  17.     });
  18.     let comb = (arr) => {
  19.         let tmp = [];
  20.         if (arr.length == 1) {
  21.             for (let i = 0; i < arr[0].length; i++) {
  22.                 tmp.push(arr[0][i]);
  23.             }
  24.             return tmp;
  25.         } else {
  26.             for (let i = 0; i < arr[0].length; i++) {
  27.                 for (let j = 0; j < arr[1].length; j++) {
  28.                     tmp.push(`${arr[0][i]}${arr[1][j]}`);
  29.                 }
  30.             }
  31.             arr.splice(0, 2, tmp);
  32.             if (arr.length > 1) {
  33.                 comb(arr);
  34.             } else {
  35.                 return tmp;
  36.             }
  37.             return arr[0];
  38.         }
  39.     };
  40.     return comb(code);
  41. };

20.有效的括号

  1. /**
  2.  * @param {string} s
  3.  * @return {boolean}
  4.  */
  5. var isValid = function (s) {
  6.   let map = {
  7.     '{': '}',
  8.     '(': ')',
  9.     '[': ']'
  10.   };
  11.   let stack = [];
  12.   for (let i = 0; i < s.length; i++) {
  13.     if (map[s[i]]) {
  14.       stack.push(s[i]);
  15.     } else if (s[i] !== map[stack.pop()]) {
  16.       return false;
  17.     }
  18.   }
  19.   return stack.length === 0;
  20. };
  22. /**
  23.  * @param {string} s
  24.  * @return {boolean}
  25.  */
  26. let isValid = function (s) {
  27.   let sl = s.length
  28.   if (sl % 2 !== 0) return false
  29.   let leftToRight = {
  30.     "{": "}",
  31.     "[": "]",
  32.     "(": ")",
  33.   }
  34.   // 建立一个反向的 value -> key 映射表
  35.   let rightToLeft = createReversedMap(leftToRight)
  36.   // 用来匹配左右括号的栈
  37.   let stack = []
  39.   for (let i = 0; i < s.length; i++) {
  40.     let bracket = s[i]
  41.     // 左括号 放进栈中
  42.     if (leftToRight[bracket]) {
  43.       stack.push(bracket)
  44.     } else {
  45.       let needLeftBracket = rightToLeft[bracket]
  46.       // 左右括号都不是 直接失败
  47.       if (!needLeftBracket) {
  48.         return false
  49.       }
  51.       // 栈中取出最后一个括号 如果不是需要的那个左括号 就失败
  52.       let lastBracket = stack.pop()
  53.       if (needLeftBracket !== lastBracket) {
  54.         return false
  55.       }
  56.     }
  57.   }
  59.   if (stack.length) {
  60.     return false
  61.   }
  62.   return true
  63. }
  65. function createReversedMap(map) {
  66.   return Object.keys(map).reduce((prev, key) => {
  67.     const value = map[key]
  68.     prev[value] = key
  69.     return prev
  70.   }, {})
  71. }

21. 合并两个有序链表

  1. // 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
  3. /**
  4.  * Definition for singly-linked list.
  5.  * function ListNode(val) {
  6.  *     this.val = val;
  7.  *     this.next = null;
  8.  * }
  9.  */
  10. /**
  11.  * @param {ListNode} l1
  12.  * @param {ListNode} l2
  13.  * @return {ListNode}
  14.  */
  15. var mergeTwoLists = function (l1, l2) {
  16.     if (l1 === null) return l2;
  17.     let cur = l1;
  18.     while (l2) {
  19.         let node = new ListNode();
  20.         if (cur.val >= l2.val) {
  21.             node.val = cur.val;
  22.             node.next = cur.next;
  23.             cur.val = l2.val;
  24.             cur.next = node;
  25.             l2 = l2.next;
  26.         } else if (cur.next && l2.val <= cur.next.val) {
  27.             node.val = l2.val;
  28.             node.next = cur.next;
  29.             cur.next = node;
  30.             l2 = l2.next;
  31.         } else if (!cur.next) {
  32.             node.val = l2.val;
  33.             node.next = null;
  34.             cur.next = node;
  35.             l2 = l2.next;
  36.             continue;
  37.         }
  38.         cur = cur.next;
  39.     }
  40.     return l1;
  41. };

89. 格雷编码

  1. // 格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
  2. // 给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。即使有多个不同答案，你也只需要返回其中一种。
  3. // 格雷编码序列必须以 0 开头。
  5. /**
  6.  * @param {number} n
  7.  * @return {number[]}
  8.  */
  9. var grayCode = function (n) {
  10.     let make = (n) => {
  11.         if (n === 1) {
  12.             return ["0", "1"];
  13.         } else {
  14.             let prev = make(n - 1);
  15.             let result = [];
  16.             let max = Math.pow(2, n) - 1;
  17.             for (let i = 0; i < prev.length; i++) {
  18.                 result[i] = `0${prev[i]}`;
  19.                 result[max - i] = `1${prev[i]}`;
  20.             }
  21.             return result;
  22.         }
  23.     };
  24.     return make(n);
  25. };
  27. var grayCode = function (n) {
  28.     let make = (n) => {
  29.         if (n === 1) return [0, 1];
  30.         let result = make(n - 1);
  31.         let highBit = 1 << (n - 1);
  32.         for (let i = result.length - 1; i >= 0; i--) {
  33.             result.push(result[i] + highBit);
  34.         }
  35.         return result;
  36.     };
  37.     if (n === 0) return [0];
  38.     return make(n);
  39. };
  41. var grayCode = function (n) {
  42.     let res = [0];
  43.     for (let i = 0; i < n; i++) {
  44.         res = res.concat(res.map((item) => (1 << i) + item).reverse());
  45.     }
  46.     return res;
  47. };

164. 最大间距

给定一个无序的数组，找出数组在排序之后，相邻元素之间最大的差值。
如果数组元素个数小于 2，则返回 0。
示例 1:
输入: [3,6,9,1]
输出: 3
解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。
示例 2:
输入: [10]
输出: 0
解释: 数组元素个数小于 2，因此返回 0。

  1. /**
  2.  * @param {number[]} nums
  3.  * @return {number}
  4.  */
  5. var maximumGap = function (nums) {
  6.   if (nums.length < 2) return 0;
  7.   nums.sort((a, b) => a - b);
  8.   // 保存相邻元素的最大差值
  9.   let max = 0;
  10.   let temp = [];
  11.   for (let i = 0; i < nums.length - 1; i++) {
  12.     temp = nums[i + 1] - nums[i];
  13.     if (temp > max) {
  14.       max = temp;
  15.     }
  16.   }
  17.   return max;
  18. };

258. 各位相加

  1. // 给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。
  2. /**
  3.  * @param {number} num
  4.  * @return {number}
  5.  */
  6. var addDigits = function (num) {
  7.     let arr = [];
  8.     for (let index of num.toString()) {
  9.         arr.push(index);
  10.     }
  11.     if (arr.length === 1) {
  12.         return parseInt(arr[0]);
  13.     }
  14.     let number = 0;
  15.     for (let i = 0; i < arr.length; i++) {
  16.         number += parseInt(arr[i]);
  17.     }
  18.     if (number > 9) {
  19.         return addDigits(number);
  20.     } else {
  21.         return number;
  22.     }
  23. };

349. 两个数组的交

  1. // 给定两个数组，编写一个函数来计算它们的交集。
  3. /**
  4.  * @param {number[]} nums1
  5.  * @param {number[]} nums2
  6.  * @return {number[]}
  7.  */
  9. var intersection = function (nums1, nums2) {
  10.     let arr1 = Array.from(new Set(nums1));
  11.     let arr2 = Array.from(new Set(nums2));
  12.     let arr3 = new Array();
  13.     for (let [v, k] of arr1.entries()) {
  14.         if (arr2.includes(k)) {
  15.             arr3.push(k);
  16.         }
  17.     }
  18.     return arr3;
  19. };
  21. var intersection = function (...arrs) {
  22.     let res = arrs[0];
  23.     for (let i = 1; i < arrs.length; i++) {
  24.         res = res.filter((item) => arrs[i].includes(item));
  25.     }
  26.     return [...new Set(res)];
  27. };

605. 种花问题

  1. // 605. 种花问题
  2. // 假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
  4. // 给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花？能则返回True，不能则返回False。
  5. /**
  6.  * @param {number[]} flowerbed
  7.  * @param {number} n
  8.  * @return {boolean}
  9.  */
  10. var canPlaceFlowers = function (flowerbed, n) {
  11.     let max = 0;
  12.     for (let i = 0; i < flowerbed.length - 1; i++) {
  13.         if (flowerbed[i] === 0) {
  14.             if (i === 0 && flowerbed[1] === 0) {
  15.                 max++;
  16.                 i++;
  17.             } else if (flowerbed[i - 1] === 0 && flowerbed[i + 1] === 0) {
  18.                 max++;
  19.                 i++;
  20.             }
  21.         }
  22.     }
  23.     return max >= n;
  24. };
  26. // var canPlaceFlowers = function (flowerbed, n) {
  27. //   let count = 1, sum = 0;
  28. //   for (val of flowerbed) {
  29. //     if (val == 1) {
  30. //       if (count > 1) sum += Math.floor((count - 1) / 2);
  31. //       count = 0;
  32. //     } else {
  33. //       count++;
  34. //     }
  35. //   }
  36. //   if (count > 1) sum += Math.floor(count / 2);
  37. //   return sum >= n;
  38. // };

914. 卡牌分组

  1. // 给定一副牌，每张牌上都写着一个整数。
  3. // 此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：
  5. // 每组都有 X 张牌。
  6. // 组内所有的牌上都写着相同的整数。
  7. // 仅当你可选的 X >= 2 时返回 true。
  9. /**
  10.  * @param {number[]} deck
  11.  * @return {boolean}
  12.  */
  13. var hasGroupsSizeX = function (deck) {
  14.     if (deck.length <= 1) return false;
  15.     deck.sort((a, b) => {
  16.         a - b;
  17.     });
  18.     let min = Number.MAX_SAFE_INTEGER;
  19.     let dst = [];
  20.     let result = true;
  21.     let tmp = [];
  22.     for (let i = 0; i < deck.length; i++) {
  23.         tmp.push(deck[i]);
  24.         for (let j = i + 1; j < deck.length - 1; j++) {
  25.             if (deck[i] === deck[j]) {
  26.                 tmp.push(deck[j]);
  27.             } else {
  28.                 if (min > tmp.length) {
  29.                     min = tmp.length;
  30.                 }
  31.                 dst.push([].concat(tmp));
  32.                 tmp.length = 0;
  33.                 i = j;
  34.                 break;
  35.             }
  36.         }
  37.     }
  38.     dst.every((item) => {
  39.         if (item.length % min !== 0) {
  40.             result = false;
  41.             return false;
  42.         }
  43.     });
  44.     return result;
  45. };
  47. var hasGroupsSizeX = function (deck) {
  48.     // 最大公约数计算公式
  49.     function gcd(num1, num2) {
  50.         // 利用辗转相除法来计算最大公约数
  51.         return num2 === 0 ? num1 : gcd(num2, num1 % num2);
  52.     }
  54.     // 相同牌出现次数Map
  55.     let timeMap = new Map();
  57.     // 遍历牌
  58.     deck.forEach((num) => {
  59.         // 统计每张牌出现的次数
  60.         timeMap.set(num, timeMap.has(num) ? timeMap.get(num) + 1 : 1);
  61.     });
  63.     // Map.protype.values()返回的是一个新的Iterator对象，所以可以使用扩展运算符(...)来构造成数组
  64.     let timeAry = [...timeMap.values()];
  66.     /*
  67.   最大公约数
  68.   因为该数组是出现次数数组，最小值至少为1（至少出现1次），所以默认赋值为数组首位对公约数计算无干扰
  69.   */
  70.     let g = timeAry[0];
  72.     // 遍历出现次数，计算最大公约数
  73.     timeAry.forEach((time) => {
  74.         // 因为需要比较所有牌出现次数的最大公约数，故需要一个中间值
  75.         g = gcd(g, time);
  76.     });
  78.     // 判断是否满足题意
  79.     return g >= 2;
  80. };

1047. 删除字符串中的所有相邻重复项

  1. // 给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
  3. // 在 S 上反复执行重复项删除操作，直到无法继续删除。
  5. // 在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
  7. /**
  8.  * @param {string} S
  9.  * @return {string}
  10.  */
  11. var removeDuplicates = function (S) {
  12.     let stack = [];
  13.     for (const c of S) {
  14.         let prev = stack.pop();
  15.         if (prev !== c) {
  16.             stack.push(prev);
  17.             stack.push(c);
  18.         }
  19.     }
  20.     return stack.join("");
  21. };

1209. 删除字符串中的所有相邻重复项 II

  1. // 给你一个字符串 s，「k 倍重复项删除操作」将会从 s 中选择 k 个相邻且相等的字母，并删除它们，使被删去的字符串的左侧和右侧连在一起。
  2. // 你需要对 s 重复进行无限次这样的删除操作，直到无法继续为止。
  3. // 在执行完所有删除操作后，返回最终得到的字符串。
  5. /**
  6.  * @param {string} s
  7.  * @param {number} k
  8.  * @return {string}
  9.  */
  10. var removeDuplicates = function (s, k) {
  11.   let stack = [];
  12.   for (const c of s) {
  13.     let prev = stack.pop();
  14.     if (!prev || prev[0] !== c) {
  15.       stack.push(prev);
  16.       stack.push(c);
  17.     } else if (prev.length < k - 1) {
  18.       stack.push(prev + c);
  19.     }
  20.   }
  21.   return stack.join("");
  22. };

1295. 统计位数为偶数的数字

  1. // 给你一个整数数组 nums，
  2. // 请你返回其中位数为 偶数 的数字的个数。
  4. // 示例 1：
  6. // 输入：nums = [12,345,2,6,7896]
  7. // 输出：2
  8. // 解释：
  9. // 12 是 2 位数字（位数为偶数） 
  10. // 345 是 3 位数字（位数为奇数）  
  11. // 2 是 1 位数字（位数为奇数） 
  12. // 6 是 1 位数字 位数为奇数） 
  13. // 7896 是 4 位数字（位数为偶数）  
  14. // 因此只有 12 和 7896 是位数为偶数的数字
  16. // 示例 2：
  18. // 输入：nums = [555,901,482,1771]
  19. // 输出：1
  20. // 解释：
  21. // 只有 1771 是位数为偶数的数字。
  23. // 提示：
  25. // 1 <= nums.length <= 500
  26. // 1 <= nums[i] <= 10^5
  28. /**
  29.  * @param {number[]} nums
  30.  * @return {number}
  31.  */
  32. var findNumbers = function (nums) {
  33.   let time = 0;
  34.   for (let i = 0; i < nums.length; i++) {
  35.     if (String(nums[i]).length % 2 === 0) {
  36.       time++;
  37.     }
  38.   }
  39.   return time;
  40. };
  42. const findNumbers = (nums) => nums.reduce((prev, next) => prev + (String(next).length % 2 === 0 ? 1 : 0), 0);

1313. 解压缩编码列表

  1. // 给你一个以行程长度编码压缩的整数列表 nums 。
  3. // 考虑每对相邻的两个元素 [freq, val] = [nums[2*i], nums[2*i+1]] （其中 i >= 0 ），每一对都表示解压后子列表中有 freq 个值为 val 的元素，你需要从左到右连接所有子列表以生成解压后的列表。
  5. // 请你返回解压后的列表。
  7. /**
  8.  * @param {number[]} nums
  9.  * @return {number[]}
  10.  */
  11. var decompressRLElist = function (nums) {
  12.     const result = [];
  13.     for (let i = 1; i < nums.length; i++) {
  14.         if (i % 2 === 1) {
  15.             result.push(...Array.from(Array(nums[i - 1]), () => nums[i]));
  16.         }
  17.     }
  18.     return result;
  19. };

1317. 将整数转换为两个无零整数的和

  1. // 「无零整数」是十进制表示中 不含任何 0 的正整数。
  3. // 给你一个整数 n，请你返回一个 由两个整数组成的列表 [A, B]，满足：
  4. // A 和 B 都是无零整数
  5. // A + B = n
  7. // 题目数据保证至少有一个有效的解决方案。
  9. // 如果存在多个有效解决方案，你可以返回其中任意一个。
  11. /**
  12.  * @param {number} n
  13.  * @return {number[]}
  14.  */
  15. var getNoZeroIntegers = function (n) {
  16.     let time = 1;
  17.     while (String(time).includes("0") || String(n - time).includes("0")) {
  18.         time++;
  19.     }
  20.     return [time, n - time];
  21. };

剑指 Offer 11. 旋转数组的最小数字

  1. // 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。
  3. /**
  4.  * @param {number[]} numbers
  5.  * @return {number}
  6.  */
  7. // var minArray = function (numbers) {
  8. //     for (let i = 0; i < numbers.length; i++) {
  9. //         if (numbers[i + 1] < numbers[i]) {
  10. //             return numbers[i + 1];
  11. //         }
  12. //     }
  13. //     return numbers[0];
  14. // };
  16. var minArray = function (numbers) {
  17.     let i = 0, j = numbers.length - 1;
  18.     while (i < j) {
  19.         const m = Math.floor((i + j) / 2);
  20.         if (numbers[m] > numbers[j]) {
  21.             i = m + 1;
  22.         } else if (numbers[m] < numbers[j]) {
  23.             j = m;
  24.         } else {
  25.             j--;
  26.         }
  27.     }
  28.     return numbers[i];
  29. };