/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLongestSubstring = function (s) {
    const arr = [...s]
    let res = 1;
    let result = arr.reduce((total, cur, i, arr) => {
        if (i == 0) {
            return cur;
        } else {
            if (total.indexOf(cur) < 0) {
                return total + cur
            } else if (res < total.length) {
                res = total.length
                return total.slice(total.indexOf(cur) + 1, total.length) + cur
            } else {
                return total.slice(total.indexOf(cur) + 1, total.length) + cur
            }
        }
    }, "")
    if (res < result.length) {
        res = result.length
    }

    return res
};

console.log(lengthOfLongestSubstring("loddktdji"))
console.log(lengthOfLongestSubstring("dvdf"))
console.log(lengthOfLongestSubstring("adfafwefffdasdcx"))

/**
 * 题目：字符串出现的不重复最长长度
 * 整体思路：
 * 用一个滑动窗口装没有重复的字符，枚举字符记录最大值即可
 * 对于遇到重复字符如何收缩窗口大小？
 * 我们可以用 map 维护字符的索引，遇到相同的字符，把左边界移动过去即可
 * 挪动的过程中记录最大长度
 */
var lengthOfLongestSubstring = function (s) {
    let map = new Map();
    let i = -1
    let res = 0
    let n = s.length
    for (let j = 0; j < n; j++) {
        if (map.has(s[j])) {
            i = Math.max(i, map.get(s[j]))
        }
        res = Math.max(res, j - i)
        map.set(s[j], j)
    }
    return res
};

const lengthOfLongestSubString = (s: string) => {
  let left = 0,
    right = 0,
    res = 0,
    map = new Map();
  while (right < s.length) {
    if (map.has(s[right])) {
      left = Math.max(left, right);
    }
    res = Math.max(res, right - left + 1);
    map.set(s[right], right);
    right++;
  }
  return res;
};

console.assert(lengthOfLongestSubString("") === 0);

console.assert(lengthOfLongestSubString("aa") === 1);

console.assert(lengthOfLongestSubString("aabc") === 3);

function lenSetStr (str) {
    return [...new Set(str)].length
}

function lengthOfStr (str) {
  let res = ""
  let result = [...str].reduce((acc, v, i) => {
    if (i === 0) {
      return v;
    } else {
      if (acc.indexOf(v) < 0) {
        return acc + v
      } else {
        res = res.length < acc.length ? acc : res
        return acc.slice(acc.indexOf(v) + 1, acc.length) + v
      }
    }
  }, "")
  console.log(res.length > result.length ? res : result)
  return Math.max(res.length, result.length)
}

/*
 * @Author: codytang
 * @Date: 2020-07-18 17:54:20
 * @LastEditTime: 2020-07-18 18:01:55
 * @LastEditors: codytang
 * @Description: 第 4 题：字符串出现的不重复最长长度
 */

function longNoRepeatStr(str) {
  let max = -Infinity;
  let count = 0;
  let pre = null;

  for (let index = 0; index < str.length; index += 1) {
    const cur = str[index];

    if (cur !== pre) {
      count += 1;
    } else {
      count = 1;
    }

    pre = cur;
    if (count > max) max = count;
  }
  return max;
}

console.log(longNoRepeatStr("aabccddabcde"));  //6

const lengthOfLongestSubstring = function (s) {
    let map = new Map();
    let i = -1
    let res = 0
    let n = s.length
    for (let j = 0; j < n; j++) {
        if (map.has(s[j])) {
            i = Math.max(i, map.get(s[j]))
        }
        res = Math.max(res, j - i)
        map.set(s[j], j)
    }
    return res
};
console.log(lengthOfLongestSubstring("abcabcdeabcd"))

function lengthOfLongestSubstring(s){
        let i = 0
        let j = 0
        let n = s.length
        let set = new Set()
        let max = 0
        while(j < n){
            while(set.has(s[j])){
                set.delete(s[i++])
            }
            set.add(s[j])
            j++
            max = Math.max(max, j - i)
        }
        return max
    }

/**
 * 最长无重复子串
 * 移动窗口法
 * @param {*} str
 */
function maxLength(str) {
  const set = new Set();
  let max = ""; // 最大子串
  let left = 0; // 左指针left,右指针i
  for (let i = 0; i < str.length; i++) {
    const char = str[i];
    // 有重复，左指针移到右指针，清空set
    if (set.has(char)) {
      left = i;
      set.clear();
    } else {
      // 如果窗口扩大了，就记录新的子串
      if (i - left + 1 > max.length) {
        max = str.slice(left, i + 1);
      }
    }
    set.add(char);
  }
  console.log(max);
}

maxLength("abcabcdagaiuytaabb"); // 输出aiuyt

    function fn(s) {
      let res = ''
      let max = 0
      for (let c of s) {
        let index = res.indexOf(c)
        if (index === -1) {
          res += c
        } else {
          res = res.slice(index + 1) + c
        }
        max = Math.max(res.length, max)
      }
      return max
    }

function fn(str) {
    let left = 0, right = 0
    let maxLen = 0
    while(left <= right && right < str.length) {
      const index = str.slice(left, right + 1).indexOf(str[right + 1])
      maxLen = Math.max(maxLen, str.slice(left, right + 1).length)
      if (index > -1) {
        right++
        left = right
      } else {
        right++
      }
    }
    return maxLen;
  }