/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
 const map = {}; // 用来保存每个序号
  for (let i = 0; i < nums.length; i++) {
    const diff = target - nums[i];
    if (map[diff]!==undefined) {
      return [map[diff], i]; // 返回差值的索引与当前元素的索引
    }
    map[nums[i]]  = i; // 将当前元素存入哈希表
  }
};

/**
 * @param {number[]} nums
 * @return {number}
 */
 var longestConsecutive = function (nums) {
        if ( !nums.length ) return 0; // 数组长度校验
        nums = [ ...new Set(nums) ] // 去重
        nums = nums.sort((a, b) => a - b) // 排序
        let max = 0;
        let flag = [];
        // i j 用来双指针左移比对 
        for ( let i = 0, j = i + 1; i < nums.length; i++, j++ ) {
            // 符合要求就推入临时数组
            if ( nums[j] - nums[i] === 1 ) {
                flag.push(nums[i]);
            } else {
                // 当条件不满足时提交最近一次数组的推入 记录数组长度，并制空临时数组方便后续推入
                flag.push(nums[i]);
                max = flag.length > max ? flag.length : max
                flag = [];
            }
        }
        return max;
    };

var moveZeroes = function (nums) {
    let nonZeroIndex = 0 // 用来表示这个索引之前的都是非0的
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== 0) { // 如果不等于0代表需要移动nums[i]到nums[nonZeroIndex]的位置
			// 这里不需要担心后面非0的覆盖前面非0的，因为如果是非零的会触发 nonZeroIndex 自增
			// 如果 nonZeroIndex 与 i 不同步了代表当前的nums[nonZeroIndex] 为0可以覆盖
            nums[nonZeroIndex] = nums[i]
            nonZeroIndex++
        }
    }
    for (let i = nonZeroIndex; i < nums.length; i++) {
        nums[i] = 0
    }
    return nums
};
moveZeroes([0,1,0,3,12])
/**
 * i = 0 n = 0 [0,1,0,3,12]
 * i = 1 n = 1 [1,1,0,3,12]
 * i = 2 n = 1 [1,1,0,3,12]
 * i = 3 n = 2 [1,3,0,3,12]
 * i = 4 n = 3 [1,3,12,3,12]
 * */
/**
 * i=3 [1,3,12,0,12] i = 4
 * i=4 [1,3,12,0,0]  i = 5
 * break
 * */

// 双重for循环暴力解法
function fn(strs) {
	if (strs.length <=1) return strs.length
    let tempStr = ''
     let max = 0
     for (let i = 0; i < strs.length; i++) {
         for (let j = i; j < strs.length; j++) {
             if (!tempStr.includes(strs[j])){
                 tempStr += strs[j]
             }else{
                 if (max<tempStr.length){max = tempStr.length}
                 tempStr = ''
                 break
             }
         }
     }
     return max
}

console.log(fn('safwwfw5151'))
 /**
 * @param {string} s
 * @return {number}
 * 双指针写法
 */
var lengthOfLongestSubstring = function(strs) {
    if(strs.length<=1){return strs.length}
    let l=0,max=0,r=1;
    
        while (r<strs.length) {
            let temp = strs.slice(l,r);
            if (temp.indexOf(strs[r])!==-1){
                l++
                continue
            }else{
                r++
            }
            if (r-l>max){
                max = r-l
            }
        }
        return max
};

var groupAnagrams = function(strs) {
  const map = new Map() // 用于存放 ate eat tea 排序后形成统一的 key ate :[] 数组用来存放原始数据
  for (let item of strs) { // 遍历每个分词
    let s = [...item].sort().join('') // 对分词的单个字符进行拆分排序组合 找出共同的key 
    if (map.has(s)) { // 如果这个key已经存在
      map.get(s).push(item) // 直接将当前 分词 push进去
    } else {
    // key第一次出现时，key与当前分词保存到map中
      map.set(s, [item])
    }
  }
  return [...map.values()]
};

const fn = (str = "({[]})") => {
    let chartMap = {
        '(': ')', '{': '}', '[': ']'
    }
    const tempRightList = []
    for ( let i = 0; i < str.length; i++ ) {
        if ( str[i] in chartMap ) {
            tempRightList.push(chartMap[str[i]])
        } else {
            if ( tempRightList.length === 0 || tempRightList.pop() !== str[i] ) {
                return false
            }
        }
    }
    return tempRightList.length === 0
}