查找字符串中连续重复出现次数最多的字符，并返回该子串

Question

比如输入字符串'abcaabcaaaaqwe'，输出'aaaa'，自己写的代码如下，整体思想就是把字符串转换为数组，对每一个数组元素求取连续出现的次数，保存在temp数组中。虽然可行，但是感觉很蹩脚，求一种更优的写法。

function search(str) {
    let val,index,length,temp,arr;
    length=str.length;
    temp=new Array(length);
    temp.fill(0);
    arr=Array.from(str);
    for(let i=0;i<length-1;i++){
        let n=1,j=i+1;
        while(j<=length){
            if(arr[j]===arr[i]){
                n++;
            }else{
                break;
            }
            j++;
        }
        temp[i]=n;
    }
    val=Math.max(...temp);
    index=temp.indexOf(val);
    return str[index].repeat(val)
}

Answer 1

function search(str) {
    return str.match(/(\w)\1+/g).sort((x, y) => y.length - x.length)[0];
}

Answer 2

function search(str){
  const regex = /(\w)\1+/g;
  let m, max = '';
  while ((m = regex.exec(str)) !== null) {
      m.index === regex.lastIndex && regex.lastIndex++;
      max = m[0].length>max.length ? m[0] : max;
  }
  return max
}
console.log(search('abcaabcaaaaqwe'))

有帮助的话请upvote和采纳~w~

好吧，如果题主对字符类型有要求，改/(\w)\1+/g这个正则的捕获组就行，如果纯英文字符就改成/([a-zA-Z])\1+/g，数字就改成/([0-9])\1+/g，所有字符就改成/(.)\1+/g

Answer 3

这是一个效率比正则表达式高又好理解又可以搜索任何字符（不仅仅是\w）的算法：

function search(input) {
  if (input.length <= 1) return input;
  let start = 0, length = 1;
  let len = 1;
  for (let end = 1; end < input.length; end++) {
    if (input.charAt(end) === input.charAt(end - 1)) len++;
    else {
      if (len > length) {
        start = end - len;
        length = len;
      }
      len = 1;
    }
  }
  if (len > length) return input.substr(input.length - len);
  return input.substr(start, length);
}
console.log(search('abcaabcaaaaqwe'));

Answer 4

function findMostLetter(str) {
// 去除空格并排序
  let _str = str
    .replace(" ", "")
    .split("")
    .sort()
    .join("");
  let reg = /(\w)\1*/g;
  let match = _str.match(reg);
  let i = 0;
  let len = 0;
  match.forEach((val, key) => {
    if (val.length > len) {
      i = key;
    }
  });
  return str[i];
}

Answer 5

之前项目中用过的，分享一下：

function getStringInfo(str) {

    // 转换成string类型
    str += '';

    let // 每个字符出现的次数表
    times = {},
    // 字符数组
    charsArray = [],
    // 连续字符串
    chars = '',
    // 初始值
    init = str.charAt(0);

    Array.from(str).reduce((prev, cur) = >{
        // 如果这个字符已经存在次数表中，次数+1，否则初始化值1
        times[prev] ? times[prev]++:times[prev] = 1;
        // 判断是否为连续字符
        prev == cur ? chars += prev: (charsArray.push(chars), chars = cur);
        return cur;
    },
    init);
    // 存放字符串最后一个子串
    charsArray.push(chars);
    return {
        times: times,
        chars: charsArray
    };
}

按照你的需求，可以这样： console.log(getStringInfo(123456789).chars.sort(a, b) =>
(b.length - a.length)[0])

我个人是觉得一个方法最好能同时满足几个类似的需求，这样不用每次都写一个方法，这次是返回一个重复值最大的子串，下次可能就是最小的子串，等等（我个人觉得哈）