JavaScript函數自動計算字符串中的連續字母

Question

我正在嘗試 （不成功）編寫JavaScript函數LetterCount來計算字符串中的連續字母（而不是總數）。

理想情況下：LetterCount（“eeeeeoooohhoooee”）= [[“e”，5]，[“o”，3]，[“h”，2]，[“o”，3]，[“e”，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 * /克;

你的例子匹配[“eeeee”，“oooo”，“hh”，“ooo”，“ee”]。

使用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（ “eeeeeoooohhoooee”）

返回值：（數組）

[[ “E”，5]，[ “○”，4]，[ “H”，2]，[ “○”，3]，[ “E”，2]]

筆記：

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

返回匹配數組（重復字母）或空數組（[]）。 否則，如果字符串不包含任何字母，則會拋出錯誤（從null調用map）。

2. \\ 1 *用於允許單個字母的匹配實例與任何順序重復或不重復。 '\\ 1+'與單個未重復的字母不匹配。

3. 數組映射需要一個函數並傳遞三個參數 - 每個索引的值，索引號和對整個數組的引用。 在這種情況下，只使用每個索引的值，因此我們可以忽略其他參數。

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

實際上“固定” ["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;
}