Как посчитать, сколько раз определенные символы находятся в строке

Ответ 1

Вы можете посчитать вхождения с одинаковым значением массива, используя карту и фильтр:

let str="I love JavaScript and Node.js ";
let arr=str.replace(/[^a-zA-Z]/g, '').split('');

const mapped = [...new Set(arr)].map(a => '${a} occurs ${arr.filter(a1 => a1 === a).length  } time(s)');
console.log(mapped);

Ответ 2

Во-первых, и для обобщения метода будет лучше, если calc_fit() также будет принимать массив букв в качестве аргумента. Затем вы можете создать карту из массива со счетчиком каждой буквы, начиная с 0. Наконец, вы пересекаете строку и при необходимости увеличиваете соответствующий счетчик каждой буквы.

function calc_fit(element, fitness_let)
{
    // Create a Map from the array of letters to search.
    let map = new Map(fitness_let.map(l => ([l, 0])));

    // Traverse the string and increment counter of letters.    
    for (const c of element)
    {
        if (map.has(c))
            map.set(c, map.get(c) + 1);
    }
    
    return map;
}

let res = calc_fit("This is a string with some letters", ["e","l","m","n","t"]);
res.forEach((counter, letter) => console.log('${letter} => ${counter}'));

.as-console {background-color:black !important; color:lime;}
.as-console-wrapper {max-height:100% !important; top:0;}

Ответ 3

Один из подходов состоит в том, чтобы выполнить итерацию массива и выполнить глобальное удаление регулярных выражений для каждой буквы. Затем сравните длину замененной строки с исходной длиной ввода, чтобы определить количество вхождений.

function calc_fit(element) {
var fitness_let = ["e", "l", "m", "n", "t"];

for (var i=0; i < fitness_let.length; i++) {
    var letter = fitness_let[i];
    var numtimes = element.length - element.replace(new RegExp(letter, 'g'), '').length;
    console.log(fitness_let[i] + " occurs: " + numtimes + " times.");
}

}

var input = "elements are elemental";
calc_fit(input);

Ответ 4

Если вы хотите получить нет. раз появляется каждый символ, чем вы можете использовать reduce и Map

let getTotal = (element) => {
  let fitness = ["e", "l", "m", "n", "t"]
  let newMap = new Map(fitness.map(v=>[v,v]))
  return element.split('').reduce((op,inp)=>{
    if(newMap.has(inp)){
      op[inp] = op[inp] || 0
      op[inp]++
    }
    return op
  },{})
}

console.log(getTotal('element'))
console.log(getTotal('eleabc'))

Ответ 5

Вы можете создать хеш-карту и использовать уменьшение для подсчета всех найденных экземпляров

Пример:

const counts = {};
["e", "l", "m", "n", "t"].forEach( e => counts[e] = 0 );
const letters = "hey look! a string!".split("");
const results = letters.reduce( (acc, curr) => {
	if (acc.hasOwnProperty(curr)) { acc[curr] += 1; }
  return acc;
}, counts);


console.log(results);

Ответ 6

Здесь немного другой подход, основанный на генераторах функций.

Нет никакой соответствующей причины использовать это по сравнению с другими решениями, но это позволяет дать дополнительный контроль над всем циклом.

Как примечание: строка повторяется только один раз, поэтому весь цикл "итерации" должен быть достаточно быстрым.

Объяснение прямо в коде ниже.

Выходные данные - это объект, в котором каждая клавиша представляет собой символ и содержит количество вхождений, в котором содержатся все найденные иглы.

Если массив искомых символов не передается, он автоматически создается внутри функции calc_fit, при этом в отдельности будут возвращаться как прописные, так и строчные буквы, включая знаки пунктуации и символы. Это легко настроить, хотя.

// Iterates a string and yield the current looped char if it exists in the chars list.
function* matchChars(s, chars) {
  for (var char of s) {
    if (chars.indexOf(char) > -1) yield { char: char };
  }
}

// not sure why the function was named in this way in the original code, but hey, it the OP function name.
function calc_fit(element, chars) {
  chars = chars || [...new Set(element)];
  // builds an object from the above array, where the structure has the key which is the char, and the value which is initially 0.
  const matchList = chars.reduce((acc,next) => (acc[next] = 0, acc), {});
  // Iterates all the matches. For each match, it increments the amount of matches of matchList.
  for (var match of matchChars(element, chars)) matchList[match.char]++;
  // finally, returns matchList.
  return matchList;
}

// assertions: should match all the characters.
console.log(calc_fit('element', ["e", "l", "m", "n", "t"]));
// assertions: should return all zeros.
console.log(calc_fit('', ["e", "l", "m", "n", "t"]));
// assertions: should automatically detect chars, even upper case and lower case.
console.log(calc_fit('hello, world. ThIs is beatiful!'));