最长连续子字符串

错误详情

用例输入 "LLLLLLLlllllooooolllll"
预期输出 "LLLLLLLlllll"
实际输出 "LLLLLLL"
？？？ 这个输入case是认真的么？？？

输入一个字符串s，请返回该字符串的“只包含一种字符的最长非空子字符串”。
L 和 l 能严谨点儿么？

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param str string字符串 1 <= str.length <= 1000
 * @return string字符串
 */
function findLongestSubstr( str ) {
    // write code here
    //判断特殊情况
    if(str.length < 2) return str

    let arr = [] , len = 1
    for(let i = 1 ; i < str.length ; i ++){
        if(str[i].toLowerCase() == str[i-1].toLowerCase()){
            len ++
        }else{
            arr.push(str.substring(i-len,i))
            len = 1
        }
        //那如果是都相等呢，那就没有push进去
    }
    //判断处理那种情况
    if(len === str.length) return str
    let maxStr = ''
    let maxLen = 0
    console.log(arr)
    for(let i = 0 ; i < arr.length ; i ++){
        if(arr[i].length > maxLen){
            maxStr = arr[i]
            maxLen = arr[i].length
        }
    }
    return maxStr
}
module.exports = {
    findLongestSubstr : findLongestSubstr
};

 function fun(str){
if (str == '') {
        return '';
    }
    var ans = 1, temp = 1;    //计数重复字符个数，此题没要求
    var str2 = str[0];       //str2保存连续子字符串
    var arr = [];            //将各阶段str2保存至数组，方便后面求取比较最长子串
    arr[0] = str[0];          //考虑单个字符情况
    for (let i = 1; i < str.length; i++) {
        if (str[i] == str[i - 1] || str[i] == str[i - 1].toUpperCase() || str[i] == str[i - 1].toLowerCase()) {
            temp++;
            str2 = str2.concat(str[i]);
            arr.push(str2);
            //console.log(str2);
        } else {
            temp = 1;
            str2 = str[i];
        }
        ans = Math.max(temp, ans);
    }
    var arr = arr.sort(
        (a, b) => { return b.length - a.length; }
    );
   // console.log(arr[0]);
    
   // console.log(ans);
    return arr[0];
};
fun('LLLLLLLlllllllooooolllll');

 function findLongestSubstr(str) {
        if(str === ""){return str}
        let arr = str.split("")
        let res = ""

       function loop(arr2){
           for(let i=0;i<arr2.length-1;i++){
               if(arr2[i] != arr2[i+1]){
                   let temp = arr2.splice(0,i+1).join("")    //splice更改了原数组，返回的是被删除的数组
                   if(temp.length>res.length){
                       res = temp
                   }
               }
           }
       }
        loop(arr)
        //考虑最后剩余的数组
        let strLastArr = arr.join("")
        if(strLastArr.length>res.length){
            res = strLastArr
        }
        return res;
    }

function findLongestSubstr(str) {
  str += "!"; // 给字符串末尾补一位
  let res = "";
  let temp = "";
  for (let i = 0; i < str.length - 1; i++) {
    if (str[i].toLowerCase() === str[i + 1].toLowerCase()) {
      temp += str[i];
    } else {
      temp += str[i];
      if (temp.length > res.length) {
        res = temp;
      }
      temp = "";
    }
  }
  return res;
}

function getLongestSubString(str) {
    if (!str || str === "") return str;
    let maxLen = 0,startPos=0,endPos,lastChar=null,maxLenStart=[],maxLenEnd=[];
    str.split("").map((s,index)=>{
        lastChar = lastChar || s;
        if(lastChar === s){
            endPos = index+1;
        }
        if(lastChar!==s||index===str.length-1){

            let len = endPos - startPos;
            maxLen = Math.max(maxLen,len);
            // maxLenStart = maxLen === len? startPos:maxLenStart;
            // maxLenEnd = mmaxLen === len? endPos:maxLenEnd;
            if(maxLen == len){
                maxLenStart.push(startPos);
                maxLenEnd.push(endPos);
            }

            lastChar = s;
            startPos = index;
            endPos = index+1;
        }
    });
    for(let i=0;i<maxLenStart.length;){
        if(maxLen!==maxLenEnd[i]-maxLenStart[i]){
            maxLenStart.splice(i,1);
            maxLenEnd.splice(i,1);
        }else
            i++;
    }
    let allSubString = [];
    maxLenStart.forEach((startPos,index)=>{
        allSubString.push(str.substring(startPos, maxLenEnd[index]));
        // console.log(allSubString[index]);
    })
    return allSubString;
}

function findLongestSubstr( str ) {
    //将数组转化成字符串
    var arr = str.split('')
    //数组去重
    var arr1 = [...new Set(arr)]
    var max = arr1[0]
    //已去重数组中的每个元素为分割字符，找出最分割后数组长度最长的字符，该字符就是原字符串中最长的子字符串
    for (var i = 0; i < arr.length; i++) {
       if (str.split(max).length < str.split(arr[i]).length){ 
           str.split(max).length = str.split(arr[i]).length;
        }
    }
    var str1 = arr.filter((item)=>{return item==max})
    return str1.join('')
}
console.log(findLongestSubstr("ssssssssssssssshhhhopeeeeeeee"))
module.exports = {
    findLongestSubstr : findLongestSubstr
};

function findLongestSubstr( str ) {
    // f(i) = f(i - 1)&nbs***bsp;1
    let max = str[0];
    const dp = new Array(str.length).fill(0);
    
    // basecase
    dp[0] = 1;
    
    for(let i = 1; i < str.length; i++) {
        if(str[i - 1].toLowerCase() === str[i].toLowerCase()) {
            dp[i] = dp[i - 1] + 1;
        } else {
            dp[i] = 1;
        }
        max = dp[i] > max.length ? str.slice(i + 1 - dp[i], i + 1) : max;
    }
    
    return max;
}

function findLongestSubstr(str) {
        let arr = str.split("");
        let res = "";
        function loop(arr2) {
          for (let i = 0; i < arr2.length - 1; i++) {
            if (arr2[i].toLowerCase() != arr2[i + 1].toLowerCase()) {
              let temp = arr2.splice(0, i + 1).join("");
              if (temp.length > res.length) {
                res = temp;
              }
              loop(arr2);
            }
          }
        }
        loop(arr);

        arr = arr.join("");
        if (arr.length > res.length) {
          res = arr;
        }
        console.log(res);
        return res;
      }