Question

我尝试（未成功）编写JavaScript函数 LetterCount 来计算字符串中的连续字母（而不是总数）。

理想情况下： LetterCount（＆＃34; eeeeeoooohhoooee＆＃34;）= [[＆＃34; e＆＃34;，5]，[＆＃34; o＆＃34;，3]，[＆＃34; h＆＃34;，2 ]，[＆＃34; O＆＃34;，3]，[＆＃34; E＆＃34;，2]]

以下代码仅在我已经知道它们是什么时才会尝试计算字符串中连续字母的数量：

function LetterCount(str) {
for (var i=0; i<str.length;i++) {
    var arr1=[]; arr2=[]; arr3=[]; arr4=[]; arr5=[];
    var e=0; o=0; h=0; o2=0; e2=0;
    if(str[i]="e") {
        arr1 += "e";
        e++;
    }
    arr1.push(e);
    if(str[i]="o") {
        arr2 += "o";
        o++;
    }
    arr2.push(o);
    if(str[i]="h") {
        arr3 += "h";
        h++;
    }
    arr3.push(h);
    if(str[i]="o") {
        arr4 += "o";
        o2++;
    }
    arr4.push(o2);
    if(str[i]="e") {
        arr5 += "e";
        e2++;
    }
    arr5.push(e2);
}
return arr1.concat(arr2).concat(arr3).concat(arr4).concat(arr5);
}

在上面的代码中，我需要首先知道字符串中的字母是什么，以及它们中的字母数量是多少。

INSTEAD：你如何编写一个能够自动识别字母本身的函数，然后返回连续字母的数量。如果答案采用以下格式，也会很棒：

 LetterCount("eeeeeoooohhoooee") = [["e", 5],["o",3],["h",2],["o",3],["e",2]]

非常感谢任何帮助！

Answer 1

您可以使用正则表达式匹配任何字母，后跟零个或多个相同字母的实例。

RX = /（[A-ZA-Z]）\ 1 * /克;

你的例子匹配[＆＃34; eeeee＆＃34;，＆＃34; oooo＆＃34;，＆＃34; hh＆＃34;，＆＃34; ooo＆＃34;，＆＃34; ee＆＃34 ;。]

使用map，返回每个索引的新数组中的首字母和出现次数。

function letterCount(str){
    var s= str.match(/([a-zA-Z])\1*/g)||[];
    return s.map(function(itm){
        return [itm.charAt(0), itm.length];
    });
}

<强> letterCount（＆＃34; eeeeeoooohhoooee＆＃34）

返回值:(数组）

<强> [[＆＃34; E＆＃34;，5]，[＆＃34; O＆＃34;，4]，[＆＃34; H＆＃34;，2]，[＆＃34 ; O＆＃34;，3]，[＆＃34; E＆＃34;，2]]

注意：

var s = str.match（/（[a-zA-Z]）\ 1 * / g）|| [];

返回匹配数组（重复字母）或空数组（[]）。否则，如果字符串不包含任何字母，则会抛出错误（从null调用map）。

\ 1 * 用于允许单个字母的匹配实例与任何顺序重复或不重复。＆＃39; \ 1 +＆＃39;与单个不重复的信件不匹配。
数组 map 需要一个函数并传递三个参数 - 每个索引的值，索引号和对整个数组的引用。在这种情况下，只使用每个索引的值，因此我们可以忽略其他参数。

Answer 2

这是我的答案：

function LetterCount(str) {
    var current, i = 0, l = str.length;
    var outputArr = [];
    while(i<l) {
        current = str.charAt(i);
        if(!i++ || outputArr[outputArr.length-1][0] !== current)
            outputArr[outputArr.length] = [current, 1];
        else outputArr[outputArr.length-1][1]++;
        }
    return outputArr;
    }

作为对kennebec（非常好）答案的修改，因此每次调用父函数时都不会声明匿名函数。与纯粹的简单性相比，这只是为了引用更好的编程实践（这可能是最有效的方法）：

var letterCount = (function(){
    var r = /([A-z])\1*/g,
        f = function(itm){
        return [itm.charAt(0), itm.length];
        };
    return function letterCount(str){
        return str.match(r).map(f);
        };
    }());

Answer 3

实际上＆＃34;已修复＆＃34; ["o",3]至["o",4];）

// node v0.10.31
// assert v1.3.0

var assert = require('assert');

function letterCount(str) {
    var i = 0,
        seq = 0,
        results = [];

    while (i < str.length) {
        var current = str[i],
            next = str[i + 1];

        if (typeof results[seq] === 'undefined') {
            results[seq] = [current, 0];
        }

        results[seq][1]++;

        if (current !== next) {
            seq++;
        }

        i++;
    }

    return results;
}

var actual = letterCount('eeeeeoooohhoooee');
var expected = [["e", 5],["o",4],["h",2],["o",3],["e",2]];

assert.deepEqual(actual, expected);

Answer 4

我使用键入字符的地图来存储连续字符的数量，然后在结尾处构建输出结构。我不确定我根据你的例子确切地理解了你的意思，但是你可以通过调整逻辑来相应地识别一个连续的数字。

function LetterCount(str) {
  var counts = {};
  for (var i = 0, prevChar = null; i < str.length; i++) {
    var char = str.charAt(i);
    if(counts.hasOwnProperty(char) && char === prevChar) {
      counts[char] = counts[char] + 1;  
    } else if (!counts.hasOwnProperty(char)) {
      counts[char] = 0;
    }
    prevChar = char;
  }
  var res = [];
  for (var char in counts) {
    if (counts.hasOwnProperty(char)) {
      res.push([char,counts[char]);
    }
  }
  return res;
}

Answer 5

function LetterCount(text){
    arr = [];
    letter = text[0];
    counter = 0;
    for (c in text+' '){
        if (text[c] != letter){
            newArr = [letter, counter];
            arr.push(newArr);
            letter = text[c];
            counter = 0;
        }
        counter += 1;
    };
    return arr;
}

JavaScript函数自动计算字符串中的连续字母

5 个答案: