字符串计算

3. 无重复字符的最长子串

var lengthOfLongestSubstring = function(s) {
    let max = 0;
    for(let i = 0; i < s.length; i++) {
        let len = 1, flag = false;
        for(let j = i+1; j < s.length; j++) {
            len = j - i;
            let str = s.substr(i, len);
            if (str.indexOf(s[j]) !== -1) {
                flag = false;
                break;
            }
            flag = true;
        }
        // 若最后一个不一样，len需要+1
        if(flag) len++;
        len > max ? max = len : null;
    }
    console.log(max)
    return max;
};

2116. 判断一个括号字符串是否有效

题目：
思路：将locked[i]=='0’视为万能符，左右各判断一遍。从左到右时，右半括号的数量不应大于左半括号和万能符的数量和；从右到左时，左半括号的数量不应大于右半括号和万能符的数量和

var canBeValid = function(s, locked) {
    if (s.length % 2) return false;
    let l = '(', r = ')', lc = rc = 0;
    for(let i = 0; i < s.length; i++) {
        s[i] === l || locked[i] === '0' ? lc++ : rc++;
        if (rc > lc) return false;
    }
    lc = rc = 0;
    for(let i = s.length - 1; i > -1; i--) {
        s[i] === r || locked[i] === '0' ? lc++ : rc++;
        if (rc > lc) return false;
    }
    return true;
};

5. 最长回文子串

1. 一般解法——两层循环

// 最长回文子串——一般解法，不考虑时间复杂度
var longestPalindrome = function(s) {
    var arr = s.split('');
    let index = 0, max = 1;
    for(let i = 0; i < arr.length; i++) {
        let index1 = i, max1 = 1;
        for(let j = i + 1; j <= arr.length; j++) {
            let str = arr.slice(i, j);
            let re = [...str].reverse().join('');
            if (str.join('') === re) {
                j > max1 ?  max1 = j : null;
            }
        }
        if(max1 - index1 > max - index) {
            index = index1;
            max = max1;
        }
    }
    
    console.log(index, max, arr.slice(index, max).join(''))
    return arr.slice(index, max).join('');
};

longestPalindrome("xabay")

2. 中心法

// 中心法
var longestPalindrome = function(s) {
    if(s.length === 1) {
        return s;
    } else if (s.length === 2) {
        return s[0] == s[1] ? s : s[0];
    }
    let start = 0, end = 0;
    for(let i = 0; i < s.length; i++) {
        let len1 = getMaxLen(s, i, i);// 中心为元素
        let len2 = getMaxLen(s, i, i+1);// 中心不是元素
        let len = Math.max(len1, len2);
        if (end - start < len) {
            let d = Math.floor(len / 2)
            if (len1 > len2) {
                start = i - d;
            } else {
                start = i - (d - 1);
            }
            end = i + d;
        }
    }
    console.log(start, end+1);
    return s.slice(start, end+1);

    function getMaxLen(s, left, right) {
        while(left >= 0 && right < s.length && s[left] == s[right]) {
            left--;
            right++;
        }
        return right - left - 1;
    }
};

3. 动态规划

// 动态规划

7.整数反转

var reverse = function(x) {
    let f = x < 0 ? -1 : 1;
    let str = x.toString();
    f < 0 && (str = str.slice(1));
    str = str.split('').reverse().join('');
    str.replace(/^0+/, '');
    if (!str) return 0;
    str *= f;
    str = str >= (-2) ** 31 && str <= 2**31 - 1 ? str : 0;
    return str;
};

注： 次方 基数**指数 或者 Math.Pow()

8.字符串转整数

var myAtoi = function(s) {
    if (!s || !s.length) return 0;
    // 删除前面的空白字符
    s = s.replace(/^\s+/, "");
    let flag = 1, i = 0,res = 0;
    // 判断第一位
    if(s[0] === '-' || s[0] === '+') {
        if(s[0] === '-') flag = -1;
        i++;
    } else if (/[^0-9]/.test(s[0])) return 0*flag;
    for(;i < s.length; i++) {
        // if (Number.isNaN(Number(s[i]))) return res*flag; // Number(' ') === 0
        if (/[^0-9]/.test(s[i])) return res*flag;
        // 按位计算res值
        res = res*10 + Number(s[i]);
        if (flag > 0 && res > 2**31 - 1) return 2**31 - 1;
        // 注意res没乘flag
        if (flag < 0 && res > 2**31) return (-2)**31;
    }
    return res*flag;
};

一次编辑

first比second长度长的情况满足：

1. 两字符串长度之差 <=1;
2. 当 first , second 长度相等时，两字符串各对应位置只有一个字符不同；
3. 当 first , second 长度之差为 1，仅需在某位置添加一个字符；

var oneEditAway = function(first, second) {
    let len = Math.abs(first.length - second.length);
    if (len <= 1) {
        if (first.length < second.length) {
            return oneEditAway(second,first);
        }
        let count = 0;
        for(let i = 0; i < first.length; i++) {
            if (first[i] !== second[i - len * count] && ++count > 1) {
                return false;
            }
        }
        return true;
    } 
    return false;
};

千分位展示数字

如： 89333444234.998 => 89, 333, 444, 234.998

function getKNum(num) {
    // 处理小数部分的精度
    let str = '.' + (num * 1000) % 1000;
    num = parseInt(num);
    while(num > 0) {
        str = ',' + num % 1000 + str;
        num = parseInt(num / 1000);
    }
    console.log(str.substring(1));
    return str.substring(1)
}
getKNum(89333444234.998)

处理小数的计算会遇到各种精度问题，
解决方法：将小数*10^n次方转为整数计算

持续更新中。。。。。