Подсчет частоты символов в строке с использованием javascript

Мне нужно написать какой-то цикл, который может подсчитывать частоту каждой буквы в строке.

Например: "aabsssd"

: a: 2, b: 1, s: 3, d: 1

Также нужно сопоставить тот же символ, что и имя свойства в объекте. Любая хорошая идея, как это сделать?

Я не уверен, как это сделать.

Вот где я до сих пор:

var arr = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];

function counter(x) {
    var count=0, temp = [];
    x = x.split('');
    console.log(x);
    for(var i=0, len = x.length; i < len; i++) {
        if(x[i] == "a") {
            count++;
        }
    }
    return count;
}
var a = "aabbddd";
console.log(counter(a));

ОТВЕТЫ

Ответ 1

Здесь вы идете:

function getFrequency(string) {
    var freq = {};
    for (var i=0; i<string.length;i++) {
        var character = string.charAt(i);
        if (freq[character]) {
           freq[character]++;
        } else {
           freq[character] = 1;
        }
    }

    return freq;
};

Ответ 2

некоторый синтаксис ES6 с уменьшением:

let counter = str => {
  return str.split('').reduce((total, letter) => {
    total[letter] ? total[letter]++ : total[letter] = 1;
    return total;
  }, {});
};

counter("aabsssd"); // => { a: 2, b: 1, s: 3, d: 1 }

Ответ 3

Другое решение:

function count (string) {  
  var count = {};
  string.split('').forEach(function(s) {
     count[s] ? count[s]++ : count[s] = 1;
  });
  return count;
}

Ответ 4

Более декларативный способ получить гистограмму слов будет заключаться в том, чтобы использовать сокращение для повторения букв и создания нового объекта, который содержит буквы как ключи и частоты в качестве значений.

function getFrequency(str) {
  return str.split('').reduce( (prev, curr) => {
    prev[curr] = prev[curr] ? prev[curr] + 1 : 1;
    return prev;
  }, {});
};

console.log(getFrequency('test')); // => {t: 2, e: 1, s: 1}

Ответ 5

Вот еще один вариант с использованием underscore.js:

function charCount(str) {
    return _(str.split('')).countBy(function(char) {
        return char.toLowerCase();
    });
}

charCount('aaabbbbdd') выходы Object {a: 3, b: 4, d: 2}

Ответ 6

for(i = strlen(string)var string = 'aabsssd';
var chars = new Array();
for(var i = 0; i < string.length; i++){
    var char = string.charAt(i);
    if(chars[char] == undefined){
        chars[char] = 0;
    }
    chars[char]++;
}
console.log(chars);

Ответ 7

 const recorrences = ['a', 'b', 'c', 'a', 'b','a']
                .map(i => !!~i.indexOf('a'))
                .filter(i => i)
                .length;
console.log(`recorrences ${recorrences}`) 
//recorrences 3

Ответ 8

Вот еще один способ:

const freqMap = s => [...s].reduce((freq,c) => {freq[c] = -~freq[c]; return freq} ,{})

Или, если вы предпочитаете цикл "for":

function freqMap(s) { 
   freq={}; 
   for (let c of s) 
      freq[c]=-~freq[c]; 
   return freq;
}

например, freqMap ("MaMaMia") возвращает объект {M: 3, a: 3, i: 1}

Этот метод использует тот факт, что в javascript, поразрядно не на "undefined" дает -1, тогда как "undefined + 1" дает NaN). Итак, - ~ undefined равен 1, - ~ 1 равен 2, - ~ 2 равен 3 и т.д.

Таким образом, мы можем перебирать символы строки и просто увеличивать freq [c] без всякого "если". В первый раз, когда мы встречаемся с символом c, freq [c] будет неопределенным, поэтому мы устанавливаем его в - ~ freq [c], который равен 1. Если мы впоследствии встретимся с c снова, мы снова установим freq [c] в - ~ freq [c], который теперь будет 2 и т.д.

Простой, элегантный, лаконичный.

Ответ 9

более простое и функциональное решение:

используя стрелки ES6 & Логические операторы:

const buildFreqDict = string =>
  string.split('').reduce((freqDict, char) => {
    freqDict[char] = (freqDict[char] || 0) + 1;
    return freqDict;
  }, {})

console.log(buildFreqDict("banana"))

Ответ 10

// Count frequency of characters in a string
// input: 'Hello, I'm Paul!'
// result: {
//      H: 1,
//      E: 1,
//      L: 3,
//      ... and so on ...
// }

const countChars = (string) => {
    let charStats = {};
    string = string.replace(' ', '').toUpperCase().split('');

    string.forEach((char) => {
        if (charStats[char]) {
            charStats[char]++;
        } else {
            charStats[char] = 1;
        }
    });

    return charStats;
};

Ответ 11

Другое решение

    function maxChar(str) {

        const charMap = {};
        let max = 0;
        let maxChar = '';

        for(let char of str){
            if(charMap[char]){
                charMap[char]++;
            }else{
                charMap[char] = 1;
            }
        }

        for(let char in charMap){
            if(charMap[char] > max){
                max = charMap[char];
                maxChar = char;
            }
        }

        return maxChar; 
}

===>

 maxChar('355385') 
  "5"

Ответ 12

var str = 'abcccdddd';

function maxCharCount(target) {
    const chars = {};

    let maxChar = '';
    let maxValue = 1;

    for (let char of target) {
        chars[char] = chars[char] + 1 || 1;
    }

    return chars;
}

console.log(maxCharCount(str));

Ответ 13

То же решение, но рефакторинг. Как здорово, что мы можем решить эту проблему с помощью множества разных ответов :)

function getFrequency(string) {

    var freq = {};

    for (let character in string) {

         let char = string[character];        
         (freq[char]) ? freq[char]++ : freq[char] = 1

    }

    return freq;

};

Ответ 14

Вы можете использовать это. Просто передайте строку, и она вернет объект со всей частотой символов.

function buildCharMap(string) {
  const charMap = {};
  string.replace(/[^\w]/g, '').toLowerCase();
  for (let char of string) {
    charMap[char] = charMap[char] + 1 || 1;
  }
  return charMap;
}

Ответ 15

Чит-код для подсчета частоты символа в строке

let target = "e";
let string = " i want to see that person that came in here last";
let frequency = string.split(target).length;

или все в одной строке 

console.log(string.split("e").length)

Ответ 16

Простой способ Кроме того, вы получите отсортированный по алфавиту список. Он проходит по массиву и оценивает, находится ли символ уже в объекте: если false, символ добавляется к объекту, если true, его частота увеличивается на единицу.

const text= "Lorem ipsum dolor sit amet consectetur adipiscing"
const textAsArray = text.split('').sort()
let charactersList = {}

for (char of textAsArray) {

   if (!charactersList[char]) {
    charactersList[char]=1;
   }
   else {
    charactersList[char]++
  }
}

console.log(charactersList)

Ответ 17

Я рассмотрел и думаю, что это очень хорошо адаптируется к потребностям, которые они представляют. Мне бы хотелось, чтобы это было в одной строке, но я не знаю, как генерировать объект динамически.

const uniqueCount=(arr)=>{
let rs ={};
arr.sort().join("").match(/(.)(\1*)/g).map(i=>rs[i[0]]=i.length);
return rs;
};
console.log(uniqueCount(["a","b","c","d","d","e","a","b","c","f","g","h","h","h","e","a"]));
//{ a: 3, b: 2, c: 2, d: 2, e: 2, f: 1, g: 1, h: 3 }