leetcode刷题记录(36)-简单

1.分糖果II

题目：

排排坐，分糖果。

我们买了一些糖果 candies，打算把它们分给排好队的 n = num_people 个小朋友。

给第一个小朋友 1 颗糖果，第二个小朋友 2 颗，依此类推，直到给最后一个小朋友 n 颗糖果。

然后，我们再回到队伍的起点，给第一个小朋友 n + 1 颗糖果，第二个小朋友 n + 2 颗，依此类推，直到给最后一个小朋友 2 * n 颗糖果。

重复上述过程（每次都比上一次多给出一颗糖果，当到达队伍终点后再次从队伍起点开始），直到我们分完所有的糖果。注意，就算我们手中的剩下糖果数不够（不比前一次发出的糖果多），这些糖果也会全部发给当前的小朋友。

返回一个长度为 num_people、元素之和为 candies 的数组，以表示糖果的最终分发情况（即 ans[i] 表示第 i 个小朋友分到的糖果数）。

思路：按顺序遍历。初始化数组，记录每个人的糖果，直到糖果分完

/**
 * @param {number} candies
 * @param {number} num_people
 * @return {number[]}
 */
var distributeCandies = function(candies, num_people) {
  const res = new Array(num_people).fill(0);
  let i = 1;
  while (candies) {
    if (candies >= i) {
      res[(i - 1) % num_people] += i;
      candies -= i;
    } else {
      res[(i - 1) % num_people] += candies;
      candies = 0;
    }
    i++;
  }
  return res;
};

2.IP地址无效化

题目：

给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。

所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."。

思路：正则或分割成数组合并都行

/**
 * @param {string} address
 * @return {string}
 */
var defangIPaddr = function(address) {
  return address.replace(/\./g, "[.]");
};

/**
 * @param {string} address
 * @return {string}
 */
var defangIPaddr = function(address) {
  return address.split('.').join('[.]')
};

3.数组的相对排序

题目：

给你两个数组，arr1 和 arr2，

arr2 中的元素各不相同
arr2 中的每个元素都出现在 arr1 中
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。

思路：用sort方法。判断arr1成员是否在arr2内，然后比较顺序

/**
 * @param {number[]} arr1
 * @param {number[]} arr2
 * @return {number[]}
 */
var relativeSortArray = function(arr1, arr2) {
  return arr1.sort((a, b) => {
    const i1 = arr2.findIndex((i) => i == a);
    const i2 = arr2.findIndex((i) => i == b);
    if (i1 < 0 && i2 < 0) {
      return a - b;
    } else if (i1 >= 0 && i2 >= 0) {
      return i1 - i2;
    } else {
      return i2 - i1;
    }
  });
};

4.等价多米诺骨牌对的数量

题目：

给你一个由一些多米诺骨牌组成的列表 dominoes。

如果其中某一张多米诺骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。

形式上，dominoes[i] = [a, b] 和 dominoes[j] = [c, d] 等价的前提是 a==c 且 b==d，或是 a==d 且 b==c。

在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。

思路：记录每一组的数量，然后用等差数列求和的方式计算

/**
 * @param {number[][]} dominoes
 * @return {number}
 */
var numEquivDominoPairs = function(dominoes) {
  const map = new Map();
  for (const [a, b] of dominoes) {
    if (map.get(`${a}-${b}`)) {
      map.set(`${a}-${b}`, map.get(`${a}-${b}`) + 1);
    } else if (map.get(`${b}-${a}`)) {
      map.set(`${b}-${a}`, map.get(`${b}-${a}`) + 1);
    } else {
      map.set(`${a}-${b}`, 1);
    }
  }
  let count = 0;
  for (const n of map.keys()) {
    count += (map.get(n) * (map.get(n) - 1)) / 2;
  }
  return count;
};

5.第N个泰波那契数

题目：

泰波那契序列 Tn 定义如下： 

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2

给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

思路：和斐波那契数一样，动态规划。可以常数空间

/**
 * @param {number} n
 * @return {number}
 */
var tribonacci = function(n) {
  const list = new Array(n + 1);
  list[0] = 0;
  list[1] = 1;
  list[2] = 1;
  for (let i = 3; i <= n; i++) {
    list[i] = list[i - 2] + list[i - 1] + list[i - 3];
  }
  return list[n];
};

/**
 * @param {number} n
 * @return {number}
 */
var tribonacci = function(n) {
  let a = 0;
  let b = 1;
  let c = 1;
  if (n == 0) return a;
  if (n == 1) return b;
  while (n > 2) {
    [a, b, c] = [b, c, a + b + c];
    n--;
  }
  return c;
};