JavaScript anagram comparison

Question

I\'m trying to compare two strings to see if they are anagrams.

My problem is that I\'m only comparing the first letter in each string. For example, \"Mary\" and \"

Answer 1

Instead of comparing letter by letter, after sorting you can join the arrays to strings again, and let the browser do the comparison:

function compare (a, b) {
    var y = a.split("").sort().join(""),
        z = b.split("").sort().join("");
    console.log(z === y
        ? a + " and " + b + " are anagrams!"
        : a + " and " + b + " are not anagrams."
    );
}

Answer 2

function validAnagramOrNot(a, b) {
      if (a.length !== b.length)
      return false;
      const lookup = {};
      for (let i = 0; i < a.length; i++) {
          let character = a[i];
          lookup[character] = (lookup[character] || 0) + 1;
      }
      for (let i = 0; i < b.length; i++) {
          let character = b[i];
          if (!lookup[character]) {
            return false;
          } else {
             lookup[character]--;
          }
       }
  return true;
}
 validAnagramOrNot("a", "b"); // false
 validAnagramOrNot("aza", "zaa"); //true

Answer 3

Make the function return false if the length between words differ and if it finds a character between the words that doesn't match.

// check if two strings are anagrams
var areAnagrams = function(a, b) {
    // if length is not the same the words can't be anagrams
    if (a.length != b.length) return false;
    // make words comparable
    a = a.split("").sort().join("");
    b = b.split("").sort().join("");
    // check if each character match before proceeding
    for (var i = 0; i < a.length; i++) {
        if ((a.charAt(i)) != (b.charAt(i))) {
            return false;
        }
    }
    // all characters match!
    return true;
};

It is specially effective when one is iterating through a big dictionary array, as it compares the first letter of each "normalised" word before proceeding to compare the second letter - and so on. If one letter doesn't match, it jumps to the next word, saving a lot of time.

In a dictionary with 1140 words (not all anagrams), the whole check was done 70% faster than if using the method in the currently accepted answer.

Answer 4

A more modern solution without sorting.

function(s, t) {
 if(s === t) return true
 if(s.length !== t.length) return false

 let count = {}

 for(let letter of s)
  count[letter] = (count[letter] || 0) + 1

 for(let letter of t) { 
  if(!count[letter]) return false
  else --count[letter]
 }

 return true;
}

Answer 5

I modified your function to work.

It will loop through each letter of both words UNTIL a letter doesn't match (then it knows that they AREN'T anagrams).

It will only work for words that have the same number of letters and that are perfect anagrams.

function compare (a, b) {
  y = a.split("").sort();
  z = b.split("").sort();
  areAnagrams = true;
  for (i=0; i<y.length && areAnagrams; i++) {
    console.log(i);
    if(y.length===z.length) {
      if (y[i]===z[i]){
        // good for now
        console.log('up to now it matches');
      } else {
        // a letter differs
        console.log('a letter differs');
        areAnagrams = false;
      }
    }
    else {
      console.log(a + " has a different amount of letters than " + b);
      areAnagrams = false;
    }

  }
  if (areAnagrams) {
    console.log('They ARE anagrams');
  } else {
    console.log('They are NOT anagrams');
  }
    return areAnagrams;
}

compare("mary", "arms");

Answer 6

    function compare (a, b) {
  y = a.split("").sort();
  z = b.split("").sort();
  if(y.length==z.length) {
   for (i=0; i<y.length; i++) {
    if (y[i]!==z[i]){
     console.log(a + " and " + b + " are not anagrams!");
     return false;
    }
   }
   return true;
  } else { return false;}}

compare("mary", "arms");