在字符串javascript中查找最常见的字符

Question

假设我有以下字符串“35538​​5”。我需要一个简单的JavaScript，可以告诉我最常提到的字符是5.提前谢谢你。

我试过这个但没有结果。

var exp = '355385' ;

var exps =exp.split("");

var expCounts = { };

for (var i=0;i<exp.length;i++)

{expCounts["_" + exps[i]] = (expCounts["_" + exps[i]] || 0) + 1 ;

if (expCounts==3) exps=exps[i]; }; exps;

Answer 1

这将循环遍历字符串中的每个字符，并跟踪每个字符的计数和具有最大计数的字符：

var exp = '3553853335' ;
var expCounts = {};
var maxKey = '';
for(var i = 0; i < exp.length; i++)
{
    var key = exp[i];
    if(!expCounts[key]){
     expCounts[key] = 0;
    }
    expCounts[key]++;
    if(maxKey == '' || expCounts[key] > expCounts[maxKey]){
        maxKey = key;
    }
}

console.debug(maxKey + ":" + expCounts[maxKey]);

Answer 2

var getMax = function (str) {
 var max = 0,
     maxChar = '';
  str.split('').forEach(function(char){
    if(str.split(char).length > max) {
        max = str.split(char).length;
        maxChar = char;
     }
  });
  return maxChar;
};

日志

getMax('355385') //5;

getMax('35538533') //3;

在相同的情况下，它将返回第一个数字

getMax('3553') //3;

Answer 3

var string  = "355385",
    counter = {};

for (var i = 0, len = string.length; i < len; i += 1) {
    counter[string[i]] = (counter[string[i]] || 0) + 1;
}

var biggest = -1, number;
for (var key in counter) {
    if (counter[key] > biggest) {
        biggest = counter[key];
        number = key;
    }
}

console.log(number);
# 5

Answer 4

获取字符串中最频繁出现的字符的另一种方法-将频率映射表排序为数组，然后从该数组返回第一个（最大）值：

function highest (string) {
  let array = Array.from(string);
  let frequencyMap = {};
  array.forEach((value, index) => {
    if (!frequencyMap[value]) {
      frequencyMap[value] = 0;
    }
    frequencyMap[value] += 1;
  })
  let frequencyArray = Object.entries(frequencyMap);
  frequencyArray.sort((a, b) => {
    if (a[1] < b[1]) {
      return 1;
      }
    if (a[1] > b[1]) {
      return -1;
      }
      return 0;
    });
  return(frequencyArray[0][0]);
}

console.log(highest("hello World"));

  

返回“ l”

Answer 5

另一种解决方案

'Red hat'

结果：

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; 
}

Answer 6

想分享这种ES6功能方法。请提供您的输入。

function maxChar(myStr) {
  let charObj = {};
  return [...myStr].reduce((_, char) => {
    if (char in charObj) charObj[char]++;
    else if (char !== " ") charObj[char] = 1;
    return Object.keys(charObj).reduce((a, b) => {
      return charObj[a] > charObj[b] ? a : b;
    });
  });
}

Answer 7

var exp = '355385';
var findMostFrequent = function (string) {
    var chars = {}, first = string.charAt(0);
    chars[first] = 1;
    var maxChar = first, maxCount = 1;

    for (var i = 1; i < string.length; i++) {
        var char = string.charAt(i);
        if (chars[char]) {
            chars[char]++;
        } else {
            chars[char] = 1;
        }
        if (chars[char] > maxCount) {
            maxChar = char;
        }
    }
    return maxChar;
};

Answer 8

这里是这个问题的另一个答案：

为此，我认为角色可以是空格以外的任何类型

function findHighestFreqInString(str) {
    if (!str) return null
    let cleanedStr = str.replace(/\s/g, '') //assumes no spaces needed
    if (cleanedStr.length === 0) return null
    let strObj = {}
    let topChar = ''
    for (let val of cleanedStr) {
        strObj[val] = (strObj[val] || 0) + 1
        if (topChar === '' || strObj[val] >= strObj[topChar]) topChar = val
    }
    return topChar
}

这是您将如何使用它：

findHighestFreqInString('my name is Someone') // returns: e
findHighestFreqInString('') // returns: Null
findHighestFreqInString('    ') // returns: Null

Answer 9

这是另一种（奇怪的）方式 它将当前字符替换为空白，以检查字符串中存在多少次，使长度与原始模式的差异

var str = "355385";
var mostLength = 0;
var characterMostLength;
for(t = 0; t< 10; t++)
{
    var res = str.length - str.replace(new RegExp(t, "g"), "").length;
    if (res > mostLength){
        characterMostLength = t;
        mostLength = res;
    }
}

Answer 10

onDragOver(event) {
    // do something
    event.preventDefault();
}
onDragLeave(event) {
    // do something
    event.preventDefault();
}

Answer 11

function solution(N) {
    var textToArr = N.split('');
    var newObj = {};
    var newArr = [];

    textToArr.map((letter) => {
        if(letter in newObj){
            newObj[letter] = newObj[letter]+1;
        } else {
            if(letter !== ' '){
               newObj = Object.assign(newObj, {[letter]: 1})
            }
        }
    });

    for(let i in newObj){
        newArr.push({name: i, value: newObj[i]})
    }

    var res = newArr.sort((a,b) => b.value-a.value)[0];
    return res.name+':'+res.value
}

solution("hello world");

Answer 12

您可以使用以下解决方案来查找字符串中最频繁出现的字符：

function getMostRepeatedCharacter(string) {
    return string.split('').reduce((acc,char)=>{
        let len = string.split(char).length - 1;
        return len > acc[1] ? [char,len] : acc
    },['',0])[0]
}

getMostRepeatedCharacter('wediuaududddd') // d

Answer 13

这是一个简单的想法，仅包含一个哈希表传递。唯一不做的就是处理多个最大数字。我真的希望您喜欢我的解决方案:)。

function maxChar(str) {
    //Create the output and the hashmap
    let m = {}, ans

    //Loop through the str for each character
    //Use reduce array helper because of the accumulator

    str.split('').reduce((a, c) => {

        //Increments Map at location c(character) unless it does not already exist

        m[c] = m[c] + 1|| 1

        //This checks to see if the current passthrough of m[c] is greater than or equal to the accumulator, if it is, set the answer equal to the current character. If it's not keep the ans the same.

        ans = m[c] >= a ? c : ans

        //Only increment the accumulator if Map at location c(character) is greater than the accumulator. Make sure to return it otherwise it won't increment.

        return a = m[c] > a ? a + 1 : a
    }, 1)

    //Lastly return the answer
    return ans
}

Answer 14

查找字符串中出现的最大字符数的最简单方法

var arr = "5255522322";
    var freq:any = {};
    var num;
    for(let i=0;i<arr.length;i++) {
      num = arr[i];
    freq[num] = freq[num] >= 1 ? freq[num] + 1 : 1;
    }
    var sortable:any = [];
    for(let i in freq)
    {
      sortable.push(i);   
    }
    var max = freq[sortable[0]];
     var data:any = "";
   var value = sortable[0];
    for(let i=0;i<sortable.length;i++) {

      if(max > freq[sortable[i]]){
        data = "key" + value + " " + "value" + max;
      }else{
        value = sortable[i]
        max = freq[sortable[i]];
      }
    }

    console.log(data);

Answer 15

function maxChara(string) {
  charMap = {};
  maxNum = 0;
  maxChar = "";

  string.toString().split("").forEach(item => {
    if (charMap[item]) {
      charMap[item]++;
    } else {
      charMap[item] = 1;
    }
  });

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

let result = maxChara(355385);
console.log(result);

Answer 16

以上答案均未考虑到JavaScript在内部使用UTF-16

const s = "???????????";

function getMostFrequentChar(s) {
  const len = s.length;
  const freq = {};
  let maxFreq = 0;
  let maxChar;
  for (let i = 0; i < len; ++i) {
    const isPair = (s.charCodeAt(i) & 0xF800) == 0xD800;
    const c = isPair ? s.substr(i++, 2) : s[i];
    const f = (freq[c] || 0) + 1;
    freq[c] = f;
    if (f > maxFreq) {
      maxFreq = f;
      maxChar = c;
    }
  }
  return {maxFreq, maxChar, freq}
}

console.log(getMostFrequentChar(s));

注意：上面的代码假定字符串为有效的UTF-16。可以构造一个无效的UTF-16字符串，在这种情况下，您可以将isPair更改为

const isPair = len - i > 1 &&
               s.charCodeAt(i    ) & 0xF800) == 0xD800 &&
               s.charCodeAt(i + 1) & 0xF800) == 0xD800;

但是尚不清楚具有无效UTF-16值的字符的含义。

它也不会处理更多时髦的unicode

s = "??????????????"

There are many graphmemes that take multiple unicode code points

此外，使用split拆分字符串是SSSSSSLLLLLOOOOWWWW，如果字符串很长，则会占用大量内存。

Answer 17

此处 str 将需要验证的字符串。

function maxCharacter(str){

let str1 = str; let reptCharsCount=0; let ele='';let maxCount=0;
let charArr = str1.split('');
for(let i=0; i< str1.length; i++){
    reptCharsCount=0;
    for(let j=0; j< str1.length; j++){
        if(str1[i] === str1[j]) {
            reptCharsCount++;
        }
    }

    if(reptCharsCount > maxCount) {
        ele = str1[i];
        maxCount = reptCharsCount; 
    }
}
return ele;

}

输入

maxCharacter（'asdefdfdsdfseddssdfsdnknmwlqweeeeeeeessssssssssseeee'）;

输出

“ s”

Answer 18

function freq(str) {
        var freqObj = {};
        str.forEach((item) => {
            if (freqObj[item]) {
                freqObj[item]++;
            }
            else {
                freqObj[item] = 1;
            }

        });
        return freqObj;


    }
    function findmaxstr(str) {
        let max = 0,res,freqObj;
        freqObj = freq(str.split(""));
        for(let keys in freqObj){
            if (freqObj[keys] > max) {
                max = freqObj[keys];
                res = keys;
            }
        }
        console.log(res);
        return res;
    }



findmaxstr("javasdasdsssssscript");

Answer 19

const maxChar = (str) => {
  let obj = {};
  for (let char of str) {
    (!obj[char]) ? obj[char] = 1: obj[char]++;
  }
  maxCharcount = Math.max(...Object.values(obj));
  const key = Object.keys(obj).filter(key => obj[key] === maxCharcount);
  console.log(`Most repeated character/characters in the given string "${str}" is/are given below which repeated ${maxCharcount} times`);
  console.log(...key);
}

maxChar("355385");

Answer 20

这是代码，它还会检查具有相同最大计数的小写和大写字符，并返回一个作为最大计数的小写 ASCII 字符。

function mostFrequent(text) {
let charObj={}
for(let char of text){
if(char!==' '){
if(charObj.hasOwnProperty(char)) charObj[char]=charObj[char]+1;
else charObj[char]= 1
}
} let maxOccurance= Object.keys(charObj)[0], i=0;
for(let property in charObj){
if(i>0){
if(charObj[property]> charObj[maxOccurance]) 
maxOccurance= property
else if(charObj[property]=== charObj[maxOccurance]) 
{
if(property<maxOccurance) maxOccurance=property } } 
i++
}
return [maxOccurance, charObj[maxOccurance]]
}