字符串中最长的重复字符-Javascript

我最终试图解决代码战的问题

我知道如何找出一个字符在字符串中出现了多少次，但不知道它按顺序出现了多少次

也就是说，给定字符串bbbaaabaaaa，我们可以看到最长的重复字符是长度为4的a

我尝试了一个简单的for循环，将字符与前面的字符进行比较，看它们是否相同：

功能长重复序列{ 让longestChunk=； 对于let i=0；i0{ 如果str[i]==str[i-1]{ chunk+=str[i]； console.log'chunk**'，chunk； } 如果chunk.length>longestcunk.length{ 最长=块； } } } 返回最长的块； }

---

控制台.loglongestreption'bbbaaaaaa' 您可以简单地使用正则表达式查找最长的匹配单字母序列：

str.match(/(.)\1*/g).sort((a,b)=>b.length-a.length)[0]

只需摆弄一下以下小提琴：

document.querySelector'test'。addEventListener'keyup'，functionev{ var res=ev.target.value.match/\1*/g | |[]sorta，b=>b.length-a.length[0]； document.querySelector'out'。innerText=JSON.stringify[res[0]，res.length]； };

---

您可以简单地使用正则表达式查找最长的匹配单字母序列：

str.match(/(.)\1*/g).sort((a,b)=>b.length-a.length)[0]

只需摆弄一下以下小提琴：

document.querySelector'test'。addEventListener'keyup'，functionev{ var res=ev.target.value.match/\1*/g | |[]sorta，b=>b.length-a.length[0]； document.querySelector'out'。innerText=JSON.stringify[res[0]，res.length]； }; 以下是我的解决方案：

功能长重复序列{ 如果str.length==0{ 返回[，0] } 让最长=； 让chunk=； 对于let i=0；i0{ 如果str[i]==str[i-1]{ chunk+=str[i]； console.log'chunk**'，chunk； } 如果str[i]！==str[i-1]{ chunk=str[i]； } 如果chunk.length>longest.length{ 最长=块； } } } 返回[longest[0]，longest.length]； } 以下是我的解决方案：

功能长重复序列{ 如果str.length==0{ 返回[，0] } 让最长=； 让chunk=； 对于let i=0；i0{ 如果str[i]==str[i-1]{ chunk+=str[i]； console.log'chunk**'，chunk； } 如果str[i]！==str[i-1]{ chunk=str[i]； } 如果chunk.length>longest.length{ 最长=块； } } } 返回[longest[0]，longest.length]；

---

} 您可以通过在字符串中的数组上使用reduce来解决此问题：

功能长期保留{ const reducer=acc，值=>{ acc.count=acc.last==值 ？附件计数+1 : 1; acc.last=数值； acc.result=acc.count>acc.result.count ？{count:acc.count，char:value} ：根据结果； 返回acc； } 常量initAcc={ 结果:{ 字符：， 计数：0 } } const{result}=s.split.reducer，initAcc； 返回[result.char，result.count]； }

---

控制台.loglongestreption'aaabbabaaabba' 您可以通过在字符串中的数组上使用reduce来解决此问题：

功能长期保留{ const reducer=acc，值=>{ acc.count=acc.last==值 ？附件计数+1 : 1; acc.last=数值； acc.result=acc.count>acc.result.count ？{count:acc.count，char:value} ：根据结果； 返回acc； } 常量initAcc={ 结果:{ 字符：， 计数：0 } } const{result}=s.split.reducer，initAcc； 返回[result.char，result.count]； }

---

控制台.loglongestreption'aaabbabaaabba' /**您好，我借用了上一个解决方案的想法，然后对其进行了定制，以满足我的目的。功劳归于贡献者*/

function largestConsecRepeatChar(inputStr) {
    let lrgConsRepChar = "";
    if (inputStr && typeof inputStr === 'string' && inputStr.trim()) {
        function reducerCallback(accumulator, currentValue) {
            if (accumulator.lastChar === currentValue) {
                accumulator.count += 1;
            } else {
                accumulator.count = 1;
            }
            accumulator.lastChar = currentValue;
            if (accumulator.count > accumulator.result.countTracker) {
                accumulator.result = { repeatingChar: currentValue, countTracker: accumulator.count };
            } else {
                accumulator.result = accumulator.result;
            }
            return accumulator;
        }
        const initialValue = {
            result: { repeatingChar: "", countTracker: 0 }
        };
        const { result } = inputStr.trim().split('').reduce(reducerCallback, initialValue);
        lrgConsRepChar = result.countTracker > 1 ? result.repeatingChar.repeat(result.countTracker) : "";
        return lrgConsRepChar;
    }
    return lrgConsRepChar;
}

console.log(largestConsecRepeatChar(" ybtyyrjpy "));

---

/**您好，我借用了上一个解决方案的想法，然后对其进行了定制，以满足我的目的。功劳归于贡献者*/

function largestConsecRepeatChar(inputStr) {
    let lrgConsRepChar = "";
    if (inputStr && typeof inputStr === 'string' && inputStr.trim()) {
        function reducerCallback(accumulator, currentValue) {
            if (accumulator.lastChar === currentValue) {
                accumulator.count += 1;
            } else {
                accumulator.count = 1;
            }
            accumulator.lastChar = currentValue;
            if (accumulator.count > accumulator.result.countTracker) {
                accumulator.result = { repeatingChar: currentValue, countTracker: accumulator.count };
            } else {
                accumulator.result = accumulator.result;
            }
            return accumulator;
        }
        const initialValue = {
            result: { repeatingChar: "", countTracker: 0 }
        };
        const { result } = inputStr.trim().split('').reduce(reducerCallback, initialValue);
        lrgConsRepChar = result.countTracker > 1 ? result.repeatingChar.repeat(result.countTracker) : "";
        return lrgConsRepChar;
    }
    return lrgConsRepChar;
}

console.log(largestConsecRepeatChar(" ybtyyrjpy "));

---

以防万一，你想要一个简短的想法：

功能长重复序列{ 让longestChunk=； 设currentChunk=； forlet i=0；ilongestChunk.length{ longestChunk=currentChunk； } } 返回[longestChunk[0]？？，longestChunk.length]； } 控制台.loglongestreption'bbbaaaaaa'； 控制台.loglongestreption'b'；

---

console.loglongestreption 以防万一，你想要一个简短的想法：

功能长重复序列{ 让longestChunk=； 设currentChunk=； forlet i=0；ilongestChunk.length{ longestChunk=currentChunk； } } 返回[longestChunk[0]？？，longestChunk.length]； } 控制台.loglongestreption'bbbaaaaaa'； 控制台.loglongestreption'b'；

---

console.loglongestreption；在每次循环迭代开始时，将块设置为空字符串1。您可以在每次迭代时重置块，使其不会增加太多。2.在for循环中创建一个特殊的if case。如果真的有必要，在外部执行，并在i=1时启动for循环。3.您返回了一个字符串，但规范中只显示了所需的长度。4.无需每次递增，只需跟踪startingSequenceIndex，当序列被破坏时，进行减法运算。5.无需将[i]与[i+1]进行比较，只需将[i]与[c]进行比较。当[i]与[i+1]中给出的字符不同时，只应将块清空。另一种策略：我的提示将使用一个映射对象作为累加器和.reduce函数。在每次循环迭代开始时，将块设置为空字符串1。您可以在每次迭代时重置块，使其不会增加太多。2.在for循环中创建一个特殊的if case。如果真的有必要，在外部执行，并在i=1时启动for循环。3.您返回了一个字符串，但规范中只显示了所需的长度。4.无需每次递增，只需跟踪startingSequenceIndex，当序列被破坏时，进行减法运算。5.无需将[i]与[i+1]进行比较，只需比较[i]对于SPEC中给出的字符，当字符与前一个字符不同时，您应该只清空块。另一个策略：我的提示将使用Map对象作为累加器和.reduce函数。我认为它不会起多大作用，因为一般来说，这些测试在某种程度上是严格的性能测试，我猜是这样的。不过我还是赞成简洁：嘿，伙计们，不要太紧张。我远远超过了你的测试阶段。这一小段代码可以工作。我不是在长度>1000000的字符串上运行它…：D：我认为它不会起多大作用，因为一般来说，这些测试在某种程度上对预期的性能是严格的。不过我还是赞成简洁：嘿，伙计们，不要太紧张。我远远超过了你的测试阶段。这一小段代码可以工作。我不是在长度>1000000的字符串上运行它…：D：如果可能的话，请为否决票添加一个理由，这样我就可以改进这一点和我未来的答案。谢谢。如果可能的话，请为否决票添加一个原因，这样我可以改进这一点和我未来的答案。非常感谢。