博客原文地点：
https://finget.github.io/2019…

反转整数

给出一个 32 位的有标记整数，你须要将这个整数中每位上的数字举行反转。

示例 1:

输入: 123
输出: 321
 示例 2:

输入: -123
输出: -321
示例 3:

输入: 120
输出: 21
注重:

假定我们的环境只能存储得下 32 位的有标记整数，则其数值局限为 [−231,  231 − 1]。请依据这个假定，假如反转后整数溢出那末就返回 0。

思绪：数字变字符串再变数组，这个重要就是应用的数组的经常运用api了，pop、shift、 unshift、join。

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    let arr = (x + '').split('').reverse()
        let len = arr.length
        // 最大最小边境
        let min = -(2**31)
        let max = (2**31) - 1
        if (arr[len - 1] == '-') {
            arr.pop()
            if (arr[0] == 0) {   
                arr.shift()
                arr.unshift('-')
                let res = Number(arr.join(''))
                return res>=min&&res<=max?res:0
            } else {
                arr.unshift('-')
                let res = Number(arr.join(''))
                return res>=min&&res<=max?res:0
            }

        } else if (arr[0] == '0' && arr[len - 1] != '-') {
            arr.shift()
            let res = Number(arr.join(''))
            return res>min&&res<max?res:0
        } else {
            return Number(arr.join(''))>min&&Number(arr.join(''))<max?Number(arr.join('')):0
        }
};

字符串中的第一个唯一字符

给定一个字符串，找到它的第一个不反复的字符，并返回它的索引。假如不存在，则返回 -1。

案例:

s = "leetcode"
返回 0.

s = "loveleetcode",
返回 2.
 

注重事项：您能够假定该字符串只包括小写字母。

思绪：for of轮回，找出字符涌现的第一个位置和末了一个位置，假如两个值相称，则返回

/**
 * @param {string} s
 * @return {number}
 */
var firstUniqChar = function(s) {
    for (let v of s) {
        if (s.indexOf(v) === s.lastIndexOf(v)) return s.indexOf(v)
    }
    return -1
};

反转字符串中的单词

给定一个字符串，你须要反转字符串中每一个单词的字符递次，同时仍保留空格和单词的初始递次。
示例 1:
输入: "Let's take LeetCode contest"
输出: "s'teL ekat edoCteeL tsetnoc" 
注重：在字符串中，每一个单词由单个空格离开，而且字符串中不会有任何分外的空格。

重要就是用到了数组的split、reverse 、join、map要领，道理：就是把字符串变成数组，再应用数组自带的反转要领，末了再变成字符串返回。

export default (str) => {
  // 1.先将字符串转为数组
  let arr = str.split(' ')
  // 2.遍历数组，反转数组中的每一项
  let result = arr.map(item => {
    return item.split('').reverse().join('')
  })
  // 3.把新天生的数组转成字符串，用空格离开，返回效果
  return result.join(' ')
}

// 兼并写法
export default (str) => {
    return s.split(/\s/g).map(item => {
        return item.split('').reverse().join('')
    }).join(' ')
}

计数二进制子串

给定一个字符串 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”字符。

思绪：运用一个for轮回，将字符串从第一个最先传入match函数中，在match函数中应用正则表达式猎取到字符串开首的字符（或是多个0或是多个1），再运用repeat要领，将开首猎取到的多个0或1应用异或运算反转反复雷同次数（举个例子：猎取到了‘00’，那末反转以后就是‘11’），然后再竖立一个正则表达式，将猎取到的字符和反转后的字符拼接，运用test要领与传入的字符串举行比对，返回第一个比对胜利的字符串，保留到数组r中。以此类推，剃掉原字符串的第一个字符后再挪用一次match要领，直到原字符串只剩下1个字符，返回数组r的长度，即为题解。

export default (str) => {
  // 竖立数据结构，客栈，保留数据
  let r = []
  // 给定任意子输入都返回第一个相符前提的子串
  let match = (str) => {
    // 运用正则表达式猎取字符串开首的字符
    let j = str.match(/^(0+|1+)/)[0]
    // 应用“异或”运算将字符反转并复制雷同个数
    let o = (j[0] ^ 1).toString().repeat(j.length)
    // 兼并上面两个字符串，建立正则表达式
    let reg = new RegExp(`^(${j}${o})`)
    // 与传入的字符串举行比对，返回第一个比对胜利的子串
    if (reg.test(str)) {
      return RegExp.$1
    } else {
      return ''
    }
  }
  // 经由过程for轮回控制程序运转的流程
  for (let i = 0, len = str.length - 1; i < len; i++) {
    let sub = match(str.slice(i))
    if (sub) {
      r.push(sub)
    }
  }
  return r.length
}

有用的字母异位词

给定两个字符串 s 和 t ，编写一个函数来推断 t 是不是是 s 的一个字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true
示例 2:

输入: s = "rat", t = "car"
输出: false
申明:
你能够假定字符串只包括小写字母。

进阶:
假如输入字符串包括 unicode 字符怎么办？你可否调解你的解法来应对这类状况？

思绪：假如两个字符串包括的字母雷同，那末排序的递次也应当一样，基于此做轮回推断。

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function(s, t) {
    let s1 = s.split('').sort()
    let t1 = t.split('').sort()
    if (s1.length != t1.length) {
        return false
    }
    for(let i = 0;i<s1.length;i++) {
        if (s1[i]!=t1[i]) {
            return false
        }
    }
    return true
};

末了

建立了一个前端进修交换群，感兴趣的朋侪，一起来嗨呀！