javascript版算法学习记录（1）

锻炼js算法能力记录一

文章中的题目来源为力扣，思路通过慕课网学习获得。

1.反转字符串中的单词

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1:

输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”
注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-words-in-a-string-iii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解法：
1.

(str) => {
  return str.split(' ').map(item => {
     return item.split('').reverse().join('')
  }).join(' ')

 (str) => {
  return str.match(/[\w']+/g).map(item => {
    return item.split('').reverse().join('')
  }).join(' ')

2.计数二进制字串：

给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。

重复出现的子串要计算它们出现的次数。

示例 1 :

输入: “00110011”
输出: 6
解释: 有6个子串具有相同数量的连续1和0：“0011”，“01”，“1100”，“10”，“0011” 和 “01”。

请注意，一些重复出现的子串要计算它们出现的次数。

另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。
示例 2 :

输入: “10101”
输出: 4
解释: 有4个子串：“10”，“01”，“10”，“01”，它们具有相同数量的连续1和0。
注意：

s.length 在1到50,000之间。
s 只包含“0”或“1”字符。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-binary-substrings
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解法：

(str) => {
// 映射电话键盘数字与字母对应关系
  let map = ['', 1, 'abc', 'def', 'ghi', 'jkl', 'mno', 'pqrs', 'tuv', 'wxyz']
  // 将输入字符串数字转化为数组
  let searchArr = str.split('')
  // 储存从映射关系获取输入的数字字符串对应的字母
  let mapStr = []
  searchArr.forEach(item => {
    mapStr.push(map[item])
  })
  // 建立函数，将mapStr的一二为进行遍历获得对应关系并临时储存，用临时储存替换一二位然后回调函数
  let put = (arr) => {
    let app = []
    for (let i = 0; i < arr[0].length; i++) {
      for (let j = 0; i < arr[1].length; j++) {
        app.push(`${arr[0][i]}${arr[1][j]}`)
      }
      // 替换
      arr.splice(0, 2, app)
      if (arr.length > 1) {
        put(arr)
      } else {
        return app
      }
    }
    return arr[0]
  }
  return put(mapStr)
}

3.卡牌分组：

给定一副牌，每张牌上都写着一个整数。
此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：
每组都有 X 张牌。
组内所有的牌上都写着相同的整数。
仅当你可选的 X >= 2 时返回 true。

示例 1：

输入：[1,2,3,4,4,3,2,1]
输出：true
解释：可行的分组是 [1,1]，[2,2]，[3,3]，[4,4]
示例 2：

输入：[1,1,1,2,2,2,3,3]
输出：false
解释：没有满足要求的分组。
示例 3：

输入：[1]
输出：false
解释：没有满足要求的分组。
示例 4：

输入：[1,1]
输出：true
解释：可行的分组是 [1,1]
示例 5：

输入：[1,1,2,2,2,2]
输出：true
解释：可行的分组是 [1,1]，[2,2]，[2,2]

提示：

1 <= deck.length <= 10000
0 <= deck[i] < 10000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/x-of-a-kind-in-a-deck-of-cards
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解法：

(arr) => {
  // 对整数卡牌进行sort排序，注意箭头函数中只有return一句时，省略{}与return，尽量精简代码
  arr.sort((a, b) => a - b)
  //  Number.MAX_SAFE_INTEGER 是js的数字最大值
  let min = Number.MAX_SAFE_INTEGER
  // 用来储存分组过后的数组的数组
  let dist = []
  // 遍历排序后的数组
  for (let i = 0, temp = []; i < arr.length; i++) {
    temp.push(arr[i])
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j]) {
        temp.push(arr[j])
      } else {
        // 获得最短数组长度
        if (min > temp.length) {
          min = temp.length
        }
        // 不能直接push这个temp数组，因为数组是引用对象，如果直接push结果错误
        dist.push([].concat(temp))
        // 标准清空
        temp.length = 0
        // 跳过已经遍历过的arr[i]
        i = j
      }
    }
  }
  return dist.every(item => {
    if (item.length % min !== 0) {
      return false
    }
    return true
  })
}

4.花台种花：

假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花？能则返回True，不能则返回False。

示例 1:

输入: flowerbed = [1,0,0,0,1], n = 1
输出: True
示例 2:

输入: flowerbed = [1,0,0,0,1], n = 2
输出: False
注意:

数组内已种好的花不会违反种植规则。
输入的数组长度范围为 [1, 20000]。
n 是非负整数，且不会超过输入数组的大小。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/can-place-flowers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解法：

(arr, n) => {
  let max = 0
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === 0) {
      if (i === 0 && arr[1] === 0) {
        max++
        arr[i] = 1
        // 直接跳过下一位
        i++
      } else if (arr[i - 1] === 0 && arr[i + 1] === 0) {
        max++
        // 直接跳过下一位
        arr[i] = 1
        i++
      } else if (i === arr.length - 1 && arr[i - 1] === 0) {
        max++
      }
    }
  }

  return max >= n
}

5.格雷编码：

格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。格雷编码序列必须以 0 开头。

示例 1:

输入: 2
输出: [0,1,3,2]
解释:
00 - 0
01 - 1
11 - 3
10 - 2

对于给定的 n，其格雷编码序列并不唯一。
例如，[0,2,3,1] 也是一个有效的格雷编码序列。

00 - 0
10 - 2
11 - 3
01 - 1
示例 2:

输入: 0
输出: [0]
解释: 我们定义格雷编码序列必须以 0 开头。
给定编码总位数为 n 的格雷编码序列，其长度为 2n。当 n = 0 时，长度为 20 = 1。
因此，当 n = 0 时，其格雷编码序列为 [0]。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/gray-code
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解法：

(n) => {
  let mark = (n) => {
    let arr = []
    if (n === 1) {
      return ['0', '1']
    } else {
      let prev = mark(n - 1)
      let max = Math.pow(2, n) - 1
      for (let i = 0; i < prev.length; i++) {
        arr[i] = `0${prev[i]}`
        arr[max - i] = `1${prev[i]}`
      }
    }
    return arr
  }
  return mark(n)
}