00

有5个人偷了一堆苹果，准备在第二天分赃。
晚上，有一人出来，把所有菜果分成5份，但是多了一个，他顺手把这个苹果扔给树上的猴，自己先拿1/5藏了起来。
结果其他四人也都是这么想的，都如第一个人一样把苹果分成5份，把多的那一个扔给了猴子，偷走了1/5。
第二天，大家分赃，也是分成5份多一个扔给猴子。最后一人分了一份。
问:共有多少苹果?
解：

  let peach = 5;
  while (1) {
    peach++;
    if (peach % 5 === 1) {
      let peach2 = peach - Math.floor(peach / 5) - 1;
      if (peach2 % 5 === 1) {
        let peach3 = peach2 - Math.floor(peach2 / 5) - 1;
        if (peach3 % 5 === 1) {
          let peach4 = peach3 - Math.floor(peach3 / 5) - 1;
          if (peach4 % 5 === 1) {
            let peach5 = peach4 - Math.floor(peach4 / 5) - 1;
            if (peach5 % 5 === 1) {
              let peach6 = peach5 - Math.floor(peach5 / 5) - 1;
              if (peach6 % 5 === 1) {
                console.log(peach);
                break;
              }
            }
          }
        }
      }
    }
  }

01-LeetCode-两数之和(*)

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解：

  var twoSum = function (nums, target) {
    //将出现过的数字的索引进行，保存到1个对象上
    let prevNums = {};
    for (let i = 0; i < nums.length; i++) {
      const curNum = nums[i];
      const targetNum = target - curMum;
      //从prevNums中看是否能够衮取到targetMum的索引值
      const targetNumIndex = prevums[targetNum];
      if (targetNumIndex === undefined) {
        prevNums[curNum] = i; //如果判断当前没有目标值对应数的索引，那么将数据存放到prevWums
      } else {
        return [targetMumIndex, i];
      }
    }
  };

var twoSum = function(nums, target) {
    const map = new Map();
    for(let i = 0; i < nums.length; i++){
        const temp = target - nums[i]
        if (map.has(temp)){
            return [map.get(temp),i]
        } else {
            map.set(nums[i], i)
        }
    }
    return []
};

02-leetCode-两数相加(**)(+)

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

解：

var addTwoNumbers = function(l1, l2) {
    //创建1个新的链表，这个链表即为返回的链表
    let node = new ListNode("head");
    //作为每次相加的临时节点;
    let temp = node;
    //使用1个变量判断是否进1
    let add = 0;
    //每次相加的值
    let sum = 0;
    //判断每次相加的节点是否还有，作为继续循环的判断
    while (l1 || l2) {
        sum = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + add;
        temp.next = new ListNode(sum % 10);
        temp = temp.next;
        add = sum >= 10 ? 1 : 0;
        l1 && (l1 = l1.next);
        l2 && (l2 = l2.next);
    }
    add && (temp.next = new ListNode(add));
    return node.next;
};

07-LeetCode-整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例1

输入: 123
输出: 321

示例2

输入: -123
输出: -321

示例3
输入: 120
输出: 21
注意
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
解

var reverse = function (x) {
  // 取绝对值
  // 转成字符串
  // 转成数组
  // 翻转数组
  // 合并数组的字符串
  //  字符串转换成整数
  const res = parseInt(
    Array.from(Math.abs(x) + "")
      .reverse()
      .join("")
  );
  if (-res < -(2 ** 31) || res > 2 ** 31 - 1) {
    return 0;
  }
  return x < 0 ? -res : res;
};

08-LeetCode-字符串转换整数（atoi）

请你来实现一个 atoi 函数，使其能将字符串转换成整数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下：

如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。
假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。
该字符串在有效的整数部分之后也可能会存在多余的字符，那么这些字符可以被忽略，它们对函数不应该造成影响。
注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换，即无法进行有效转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0 。

提示：

本题中的空白字符只包括空格字符 ' ' 。
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

示例1

输入: "42"
输出: 42

示例2

输入: "   -42"
输出: -42
解释: 第一个非空白字符为 '-', 它是一个负号。
     我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。

示例3

输入: "4193 with words"
输出: 4193
解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。

示例4

输入: "words and 987"
输出: 0
解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
     因此无法执行有效的转换。

示例5

输入: "-91283472332"
输出: -2147483648
解释: 数字 "-91283472332" 超过 32 位有符号整数范围。 
     因此返回 INT_MIN (−231) 。

解：

var myAtoi = function (str) {
  let res = str.trim().match(/^(\-|\+)?\d+/g);
  return res
    ? Math.max(Math.min(Number(res[0]), 2 ** 31 - 1), -(2 ** 31))
    : 0;
};

09-LeetCode-回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例1

输入: 121
输出: true

示例2

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例3

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

解：

var isPalindrome = function(x) {
   return x === Number(x.toString().split("").reverse().join(""));  
};

179-LeetCode-最大数

给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。
注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。
示例 1：

输入：nums = [10,2]
输出："210"

示例 2：

输入：nums = [3,30,34,5,9]
输出："9534330"

示例 3：

输入：nums = [1]
输出："1"

示例 4：

输入：nums = [10]
输出："10"

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 109

解：

var largestNumber = function (nums) {
    nums.sort((a, b) => b + "" + a - (a + "" + b));
    return nums[0] === 0 ? "0" : nums.join("");
};