JavaScript刷LeetCode-字符串类解题技巧4

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-words-in-a-string-iii

/** * @param {string} s
 * @return {string} */
var reverseWords = function(s) {
    let arr = s.split(' ')
    let result = arr.map(item=>{
        return item.split('').reverse().join('')
    })
   return  result.join(' ')
};

var reverseWords = function(s) {
   return  s.split(' ').map(item => item.split('').reverse().join('')
   ).join(' ')
};

var reverseWords = function(s) {
   return  s.split(/\s/g).map(item => item.split('').reverse().join('')
   ).join(' ')
};

var reverseWords = function(s) {
   return  s.match(/[\w']+/g).map(item => item.split('').reverse().join('')
   ).join(' ')
};

String.prototype.split
String.prototype.match
Array.prototype.map
Array.prototype.reverse
Array.prototype.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”字符。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-binary-substrings

for i=0;i<str.length-1;i++
    r=match(str.slice(i))
    if r
        result.push(r)

/** * @param {string} str
 * @return {number} */
var countBinarySubstrings = function(str) {
    let resultArr = [];
    let match = (str) => {
        let beforeStr = str.match(/^(0+|1+)/)[0]
        let afterStr = (beforeStr[0]^1).toString().repeat(beforeStr.length)
        let reg = new RegExp(`^(${beforeStr}${afterStr})`)
        if(reg.test(str)){
            return RegExp.$1
        } else {
            return ''
        }
    }
    for(i=0;len=str.length-1,i<len;i++) {
        let subStr = match(str.slice(i));
        if(subStr) {
            resultArr.push(subStr)
        } 
    }
    return resultArr.length
};

String.prototype.slice
String.prototype.match
Array.prototype.repeat
Array.prototype.push
RegExp

/**
 * @param {string} s
 * @return {number}
 */
var countBinarySubstrings = function(s) {
    let pre = 0, cur = 1, count = 0
    for (let i = 0, len = s.length - 1; i < len; i++) {

        if (s[i] === s[i+1]) {
            cur++ 
        } else {
            pre = cur
            cur = 1
        }
        if (pre >= cur) { 
            count++
        }
    }
    return count
};

const countBinarySubstrings = function(s) {
 let count = 0,len=s.length-1,resultArr = [];
 for (i=0;i<=len;i++) {
     count ++ ;
     if(s[i]!==s[i+1]) {
        resultArr.push(count);
        count = 0;
     } 
 }
    let sum=0;
    for(i=0,len=resultArr.length-1;i<len;i++) {
        sum += Math.min(resultArr[i],resultArr[i+1])
    }
    return sum;
}