我的javascript代码返回最常见的字母有什么问题？

Question

I am trying to write a solution that will return the most common letter in a string, and the number of times that letter appears. The solution I came up was to loop through the string, holding one letter at a time in a variable called letter, and comparing all other letters to this. Then once the string ended, the loop would hold the second letter and repeat.

The problem I am getting is it just returns the first letter in the string ever time. It gets the number of matches correct, but it ignores the fact that other letters have more matches.

What am I doing wrong?

 var match = 0; var matchCount = 0; var letter = 0; var count = 0; indx1 = 0; indx2 = 0; function problemTen(a) { while (indx1 < a.length) { letter = a[indx1]; //hold the first letter in the string in the letter variable while (indx2 < a.length) { //now rotate through every other letter to compare if (a[indx2] == letter) { //compare count += 1; // if there is a match, add one to the count variable to hold the number of matches } indx2 += 1; //cycle through the rest of the string } if (matchCount === 0 || count > matchCount) { // if it's the first time around, or if this letter had more matches than the previous letter match = letter; // hold the letter in the match variable matchCount = count; //hold the number of matches in the count variable } indx1 += 1; //cycle through the first variable that you compare } return [match, matchCount]; //return results } console.log(problemTen("astrings")); 

edit: here is the solution I came up with.

function problemTen (a) {
  var match = 0;
  var matchCount = 0;
  var letter;

  for(var indx1 = 0; indx1<a.length; indx1++) {
    letter = a[indx1];              
    var count = 1;                  

    for(var indx2 = indx1 + 1; indx2<a.length; indx2++) {         
      if(a[indx2] == letter) {        
        count +=1;                 
      }
    }
    if(matchCount === 0 || count>matchCount) { 
      match = letter;                  
      matchCount =count;               
    }   
  }
  return [match, matchCount];       
}

console.log(problemTen("iamatinystring"));

Answer 1

Maybe check this solution, it's time complexity is linear compared to the one you're trying to achieve, which is quadraple:

function problemTen(a) {
  var array = a.split('');
  var max = 0;
  var letter;

  var counter = array.reduce(function(memo, item) {
    memo[item] = memo[item] ? memo[item] + 1 : 1;
    if (memo[item] > max) {
      max = memo[item];
      letter = item;
    }
    return memo;
  }, {});

  return [letter, max];
}

console.log(problemTen("astrings"));

If you want to stick to your solution though, the problem is, when you run the outer while loop again, you're not resetting the indx2 and count variables, so, indx2 = a.length already, and the inner while loop doesn't run anymore to count letters. with adding these resets, your code should be something like this:

function problemTen(a) {
  var match = 0;
  var matchCount = 0
  var letter = 0;
  var count = 0;
  indx1 = 0;
  indx2 = 0;

  while (indx1 < a.length) {
    letter = a[indx1]; //hold the first letter in the string in the letter variable

    while (indx2 < a.length) { //now rotate through every other letter to compare
      if (a[indx2] === letter) { //compare 
        count += 1; // if there is a match, add one to the count variable to hold the number of matches
      }
      indx2 += 1; //cycle through the rest of the string  
    }
    if (matchCount === 0 || count > matchCount) { // if it’s the first time around,     or if this letter had more matches than the previous letter
      match = letter; // hold the letter in the match variable
      matchCount = count; //hold the number of matches in the count     variable
    }
    indx1 += 1; //cycle through the first variable that you compare

    // HERE WE RESET indx2 and match to 0
    indx2 = 0;
    match = 0;

  }
  return [match, matchCount]; //return results
}

console.log(problemTen("astrings"));

In fact, to achieve O(n) time complexity, you don't necessarily use reduce, you can do it just using one loop as well, and it will surely be much faster, I just prefer functional programming as it results better readibility:

function problemTen(a) {
  var max = 0;
  var letter;
  var counter = {};

  for (var i = 0, l = a.length; i<l; i++) {
    counter[a[i]] = counter[a[i]] ? counter[a[i]] + 1 : 1;
    if (counter[a[i]] > max) {
      max = counter[a[i]];
      letter = a[i];
    }
  }

  return [letter, max];
}

console.log(problemTen("astrings"));

Hope this helps.

Answer 2

You task is to find the (first) character with the highest number of occurences in a given string. If you do not want to use extra memory like in Ahmet Cetin's answer you really need two loops here. You also need on point for the current character and its number of occurences and one for the actaul top postion and its number of occurances, four variables.

This is a place where a for loop would be better suited than your while -loops but both would work.

var teststring = "teststring";

function problemTen(s){
  var count = 0;      // counter for current character
  var last = 0;       // counter for actual highest character
  var character = ""; // current character
  var top = "";       // highest character

  for(var i = 0;i < s.length;i++){     // Loop over the full string
    character = s[i];                  // set current character
    for(var j = 0;j < s.length; j++){  // Loop over the full string
      if(s[j] === character){          // we found another occurence
        count++;                       // increment the counter
      }
    }
    if(last < count){   // the actual char. has more occ. than the last one
      last = count;     // set the top counter to the current counter
      top = character;  // set the top character to the current character
    }
    count = 0;        // reset the current counter
  }
  return [top,last];    // return the character and count of the to one
}

problemTen(teststring);

Answer 3

As is, the code loops through the string only once. For that you should reset indx2 to 0 before the inner while loop. Done that then you will have to also reset the 'count' variable at every inner loop.

An optimization is to have indx2 start from indx1+1, and have count=1 at the beginning of the inner loop.

 var match = 0; var matchCount = 0; var letter = 0; var count = 0; indx1 = 0; indx2 = 0; function problemTen(a) { while (indx1 < a.length) { letter = a[indx1]; //hold the first letter in the string in the letter variable indx2 = 0; // <---- [sal] reset the inner loop starting point count = 0; // <---- [sal] reset the inner loop counter while (indx2 < a.length) { //now rotate through every other letter to compare if (a[indx2] == letter) { //compare count += 1; // if there is a match, add one to the count variable to hold the number of matches } console.log(letter, a[indx2], count); indx2 += 1; //cycle through the rest of the string } if (matchCount === 0 || count > matchCount) { // if it's the first time around, or if this letter had more matches than the previous letter match = letter; // hold the letter in the match variable matchCount = count; //hold the number of matches in the count variable } indx1 += 1; //cycle through the first variable that you compare } return [match, matchCount]; //return results } console.log(problemTen("astrings"));