Мне нужно написать какой-то цикл, который может подсчитывать частоту каждой буквы в строке.
Например: "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));
Здесь вы идете:
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;
};
некоторый синтаксис 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 }
Другое решение:
function count (string) {
var count = {};
string.split('').forEach(function(s) {
count[s] ? count[s]++ : count[s] = 1;
});
return count;
}
Более декларативный способ получить гистограмму слов будет заключаться в том, чтобы использовать сокращение для повторения букв и создания нового объекта, который содержит буквы как ключи и частоты в качестве значений.
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}Вот еще один вариант с использованием underscore.js:
function charCount(str) {
return _(str.split('')).countBy(function(char) {
return char.toLowerCase();
});
}
charCount('aaabbbbdd') выходы Object {a: 3, b: 4, d: 2}
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);
const recorrences = ['a', 'b', 'c', 'a', 'b','a']
.map(i => !!~i.indexOf('a'))
.filter(i => i)
.length;
console.log(`recorrences ${recorrences}`)
//recorrences 3Вот еще один способ:
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 и т.д.
Простой, элегантный, лаконичный.
более простое и функциональное решение:
const buildFreqDict = string =>
string.split('').reduce((freqDict, char) => {
freqDict[char] = (freqDict[char] || 0) + 1;
return freqDict;
}, {})
console.log(buildFreqDict("banana"))// 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;
};
Другое решение
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"
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));
То же решение, но рефакторинг. Как здорово, что мы можем решить эту проблему с помощью множества разных ответов :)
function getFrequency(string) {
var freq = {};
for (let character in string) {
let char = string[character];
(freq[char]) ? freq[char]++ : freq[char] = 1
}
return freq;
};
Вы можете использовать это. Просто передайте строку, и она вернет объект со всей частотой символов.
function buildCharMap(string) {
const charMap = {};
string.replace(/[^\w]/g, '').toLowerCase();
for (let char of string) {
charMap[char] = charMap[char] + 1 || 1;
}
return charMap;
}
Чит-код для подсчета частоты символа в строке
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)
Простой способ Кроме того, вы получите отсортированный по алфавиту список. Он проходит по массиву и оценивает, находится ли символ уже в объекте: если 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)
Я рассмотрел и думаю, что это очень хорошо адаптируется к потребностям, которые они представляют. Мне бы хотелось, чтобы это было в одной строке, но я не знаю, как генерировать объект динамически.
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 }