CODEWITHSUNDEEP
javascriptstring
N4pster
N4pster

Reputation: 185

Finding the most frequent character in a string javascript

Assuming I have the following string "355385". I need a simple JavaScript that can tell me that the most mentioned character is 5. Thank you in advance.

I tried with this one but no results.

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;

Upvotes: 11

Views: 52170

Answers (30)

SeyyedKhandon
SeyyedKhandon

Reputation: 6113

You can use array de-structure to loop it through and take the first or all of them in one round or o(1)

function findMostRepeatedChar(str, returnAll = false) {
  const list = {};
  let mostRepeated = { char: "", count: 0 };
  const characters = [...str];

  characters.forEach((char) => {
    list[char] = list[char] ? list[char] + 1 : 1;

    if (list[char] > mostRepeated.count)
      mostRepeated = { char, count: list[char] };
    else if (list[char] === mostRepeated.count && returnAll)
      mostRepeated = {
        char: `${mostRepeated.char},${char}`,
        count: list[char],
      };
  });

  return mostRepeated;
}

console.log(findMostRepeatedChar("355385"))
console.log(findMostRepeatedChar("Hello wolrd!"))
console.log(findMostRepeatedChar("aabb"));
console.log(findMostRepeatedChar("aabb",true));

Upvotes: 0

ebrahim hassan
ebrahim hassan

Reputation: 21

This is simple and optimized solution and it returns the first occurring char if there are chars equals in counts

function maxOccurance(str) {
  let maxOccurringChar = "";
  const charMap = {};
  for (let index = 0; index < str.length; index++) {
    const ele = str.charAt(index);

    if (!charMap[ele]) {
      charMap[ele] = {
        startIndex: index,
        value: 1
      };
    } else {
      charMap[ele].value = charMap[ele].value + 1;
    }

    if (
      !maxOccurringChar ||
      charMap[maxOccurringChar].value < charMap[ele].value
    ) {
      maxOccurringChar = ele;
    } else if (
      charMap[maxOccurringChar].value === charMap[ele].value &&
      charMap[ele].startIndex < charMap[maxOccurringChar].startIndex
    ) {
      maxOccurringChar = ele;
    }
  }

  return maxOccurringChar;
}

console.log(  maxOccurance("bacdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz")
);

Upvotes: 0

Rigers Leka
Rigers Leka

Reputation: 483

Algorithm: Find maximum occurring character in a string (time complex: O(N))

I'll provide my solution to this algo-problem by utilizing the most recent concepts of javascript

const getMaxCharacter = (str) => {
  let max = 0;
  let maxChar = '';
  str.split('').forEach((char) => {
    if (str.split(char).length > max) {
      max = str.split(char).length - 1;
      maxChar = char;
    }
  });
  return `The max letter is : ${maxChar} and the max number of times it is seen is: ${max} times`;
};

Let's express an easy way of testing the function logic I wrote it:

const letter = 'Hello Student';    
getMaxCharacter(letter);

In the function developed, I've used the concepts below:

  • Arrow Function
  • Anonymous Funciton
  • Declare property by using let/const
  • Template Literals
  • forEach(); (array helper) & split()

Upvotes: 0

Sanketh Nayak
Sanketh Nayak

Reputation: 19

let string = "355385";

function printFirstRepeat(str){
    let output= {};
    for (let char of str) {
        char = char.toLowerCase();
        output[char] = ++output[char] || 1;
        if(output[char] > 1) return char;
    }

    return "Not Found"
}

console.log(printFirstRepeat(string));

Upvotes: 0

troglodytto
troglodytto

Reputation: 121

If you want the count of the letter as well, You can do this

  const { letter, count } = input.split("").reduce(
    (acc, letter) => {
      const count = input.split(letter).length - 1;
      return count > acc.count
        ? { letter, count }
        : { letter: acc.letter, count: acc.count };
    },
    { letter: "", count: 0 }
  );

Here We are splitting the string, applying a reduce to the result. The Reduce Counts how many instances of a character are there in a string, using input.split(letter).length - 1; And if the count is greater than the previous count, updates the accumulated value to be the current value

Upvotes: 0

Tatsat
Tatsat

Reputation: 11

Using Hasmaps we can find the most frequent char and occurrence all in O(N) time complexity. Below is the code. I have used one hasmap to save all the values and while i am doing it, i am also calculating the max occurrence and the max char.

var mostFreq = function(s) {
    let myMap = new Map();
    let temp;
    let counter = 0;
    let mostFrequentChar;
    for(let i =0;i <s.length;i++){
       if(myMap.has(s.charAt(i))){
           temp = myMap.get(s.charAt(i));
           temp = temp + 1;
           myMap.delete(s.charAt(i));
           myMap.set(s.charAt(i) , temp)
           if(temp > counter){
               counter = temp;
               mostFrequentChar = s.charAt(i);
           }
       }else{
           myMap.set(s.charAt(i), 1)
       }    
    }
    
    //if you want number of occerance of most frequent char  = counter
    //if you want list of each individual char and its occurrence = myMap
    //if you just want the char that is most frequence = mostFrequentChar;
    
    return mostFrequentChar;
};

Upvotes: 0

Sourabh Kumar
Sourabh Kumar

Reputation: 1

function checkNoofOccurenance(string) {
  const arr = [...new Set(string.split(''))].sort();
  const finalObj = {};
  arr.forEach((item) => {
    finalObj[item] = string.split(item).length - 1;
  });
  const item=Object.keys(finalObj).reduce((occ, toBeComapir)=>finalObj[occ]>finalObj[toBeComapir]?occ:toBeComapir)
  return item;
}

Upvotes: 0

sajad.sharhani
sajad.sharhani

Reputation: 43

The simplest approach will be like this:

function maxChar(str) {
  const charMap = {};
  let max = 0;
  let maxChar = '';

start by making an object of words and how many they repeated, to do that we have to loop through the string using for of and implementing the conditions:

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

and now loop through the object using for in

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

  return maxChar;
}

Upvotes: 1

Tijani Sylla
Tijani Sylla

Reputation: 11

var exp = '35585' ;
var expCounts = { };
let maxChar = ''
let count = 0

for(let i = 0; i < exp.length; i++){
let char = exp[i]

expCounts[char] = expCounts[char] + 1 || 1

if(expCounts[char] > count){
   maxChar = char
   count = expCounts[char]
   
}
console.log(maxChar)
}

Upvotes: 0

Pramod Kumar
Pramod Kumar

Reputation: 106

let str = '355385';
let max = 0;
let char = '';
str.split('').forEach((item) => {
  let current = str.split(item).length;
  if (current > max) {
    max = current;
    char = item;
  }
});

console.log(char + ' occurred ' + (max - 1) + ' times');

Upvotes: 0

prashanthh
prashanthh

Reputation: 31

Here is the code, where it also checks for lower and upperCase characters with the same max count and returns a Lower ASCII character as a Max.

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

Upvotes: 0

Jishnuvas
Jishnuvas

Reputation: 1

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");

Upvotes: 0

codeChinks
codeChinks

Reputation: 1

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");

Upvotes: 0

Givinalis Omachar
Givinalis Omachar

Reputation: 21

Here is yet another answer to this question:

For this I have considered that the character can be of whatevert kind except a space

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
}

Here is how you would use it:

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

Upvotes: 2

Shreyas Kumar
Shreyas Kumar

Reputation: 69

Here str will the string that needs to be verified.

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;

}

input

maxCharacter('asdefdfdsdfseddssdfsdnknmwlqweeeeeeeesssssssssssseeee');

output

"s"

Upvotes: 0

user128511
user128511

Reputation:

None of the answers above take into consideration that JavaScript internally uses 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));

Note: the code above assumes the string is valid UTF-16. It's possible to construct a string that is not valid UTF-16 in which case maybe you could change isPair to

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

But it's not clear what a character with an invalid UTF-16 value means.

It also won't handle more funky unicode

s = "👦🏿👦👦🏿👦👦🏻👦🏽👦🏾👦🏿"

There are many graphmemes that take multiple unicode code points

Also, splitting the string using split is SSSSSSLLLLLOOOOWWWW and a huge memory hog if the string is long.

Upvotes: 2

muqsith
muqsith

Reputation: 19

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

Upvotes: 0

rajeev omar
rajeev omar

Reputation: 166

Simplest way to find maximum number of occurring character in string

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

Upvotes: 0

Kooki Kodes
Kooki Kodes

Reputation: 1

this is a simple Idea that only includes one pass-through with a hashmap. The only thing this does not do is handle several max numbers. I really hope you enjoy my solution :) .

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
}

Upvotes: 0

row1
row1

Reputation: 5588

This will loop over every character in the string and keep track of each character's count and the character with the maximum count:

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]);

Update: Here is an ES6 version that will handle strings where multiple character have the same max count

function maxCount(input) {
    const {max, ...counts} = (input || "").split("").reduce(
    (a, c) => {
        a[c] = a[c] ? a[c] + 1 : 1;
        a.max = a.max < a[c] ? a[c] : a.max;
        return a;
    },
    { max: 0 }
    );

    return Object.entries(counts).filter(([k, v]) => v === max);
}

Example (please excuse the crude output):

maxCount('--aaaa1111--').join(' | ').replace(/,/g, ':');

outputs 1:4 | -:4 | a:4

Upvotes: 17

HappyHands31
HappyHands31

Reputation: 4101

Another way to get the most frequent character in a string - sort frequency map into an array and then return the first (greatest) value from that array: 

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"));

returns "l"

Upvotes: 3

Sumer
Sumer

Reputation: 2867

Want to share this ES6 functional approach. Please provide your input.

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

Upvotes: 1

bajran
bajran

Reputation: 1503

Another Solution

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

Result:

 maxChar('355385') 
  "5"

Upvotes: 3

Angyal Norbert
Angyal Norbert

Reputation: 21

You can use the following solution to find the most frequent character in a string:

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

Upvotes: 2

Alisher Musurmonv
Alisher Musurmonv

Reputation: 845

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");

Upvotes: 0

Julio Munoz
Julio Munoz

Reputation: 9

<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>Untitled Document</title>
</head>

<body>

    <p id = "myString">Hello World! I am Julio!</p>

    <p id = "mRCharacter"></p>

    <script>
        var string = document.getElementById("myString").innerHTML;

        var mRCharater = mostRepetedCharacter(string);
        document.getElementById("mRCharacter").innerHTML = mRCharater;
        console.log(mRCharater);

        function mostRepetedCharacter(string){
            var mRCharater = "";
            var strLength = string.length;
            var i = 0;
            var count = 0;
            var max = 0;
            var rest = strLength - 1;
            while (i < strLength){
                var j = i + 1;
                while (j <= rest){
                    if (string[i] === string[j]){
                        count++;
                    }
                    if (count > max){
                        max = count;
                        mRCharater = string[i];
                    }
                    j++;
                }
                i++;
                count = 0;
            }
            return mRCharater;
        }

    </script>

</body>
</html>

    enter code here

Upvotes: -1

Andrii Gordiichuk
Andrii Gordiichuk

Reputation: 1929

Here is:

let str = '355385';
function mostFrequentCharacter(str) {
        let charactersArr = str.split(''),
            bins = {};

        charactersArr.map(el => bins[el] = (bins[el] || 0) + 1); 
    return Object.keys(bins).map(key => ({
            name: key,
          count: bins[key]
    })).sort((a, b) => b.count - a.count)[0];
}

Upvotes: 1

user3401335
user3401335

Reputation: 2405

this is another (bizarre) way It substitute the current character with blank for check how many times is present in the string making the difference of length with original pattern

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

Upvotes: 0

brutallord
brutallord

Reputation: 871

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

Upvotes: 3

Sarath
Sarath

Reputation: 9156

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

logs

getMax('355385') //5;

getMax('35538533') //3;

in equal case it will return first number

getMax('3553') //3;

Upvotes: 10

Related Questions