Find anagrams in a list

Question

Write a program that, given a word and a list of possible anagrams, selects the correct sublist.

Given "listen" and a list of candidates like "enlists" "google" "inlets" "banana" the program should return a list containing "inlets".

Here is my solution:

class Anagram(word: String) {
  val sorted_word = word.toLowerCase.sorted
  val origin_word = word.toLowerCase

  def matches(words: Seq[String]) = {
    words.filter(w => w.toLowerCase.sorted == sorted_word && w.toLowerCase != origin_word)
  }

}

Here is the gist with specs.

Answer 1

Looks good! Just one little thing that I, personally would do to remove one .toLowerCase call per item: map it first. So, instead of calling .toLowerCase in the filter, you can do this:

words.map(w => w.toLowerCase)
     .filter(w => w.sorted == sorted_word && w != origin_word)

You've also got a random newline before the end of the class.

Aside from that little niggle, it looks good! There's... really not much I can say. It's short code.

Answer 2

If you call this several times, it will be more efficient to put all of words into a Map[String, List[String]] where the keys are sorted

words.groupBy(_.sorted)

Which allows you to get all the words in a simple lookup from there on in.

Answer 3

CASE CLASS

I would change Anagram to a case class. One reason for this change is more concise object declaration, e.g:

  val a = Anagram("silent")
  // as opposed to ...
  val b = new Anagram("inlets")

Another benefit is that wordOrigin automatically becomes a field for any Anagram object (this is also possible with standard class declaration by prepending val to the front of the parameter.) These two examples don't really demonstrate the full utility of case classes so if you'd like to learn more check out this link.

STYLE

Current Scala dogma utilizes camelCase. So I've swapped word_origin and word_sorted for wordSorted and wordOrigin. I also added a return type to your method matches.

A QUICK NOTE ON TYPES

One of the cool things about types is that they allow you to constrain your program. For example, as your matches method currently stands there are over twenty different collection types (of the mutable and immutable variety) that may be passed in for words (see these inheritance graphs). Long story short, I swapped Seq for List.

STRING OPERATIONS

Finally, to get around calling toLowerCase I utilized a method from StringOps called equalsIgnoreCase which returns true if the caller and the input String are equal (regardless of capitalization), false otherwise. To be honest I only changed this bit to show you another possibility.

case class Anagram(wordOrigin: String) {
  val wordSorted = wordOrigin.sorted

  def matches(xs: List[String]): List[String] = {
    xs.filter(w => 
      w.sorted.equalsIgnoreCase(wordSorted) && !w.equalsIgnoreCase(wordOrigin) 
    )
  }
}

NAMES

Whoops, one more thing. I think I would also rename your class from Anagram to Word or something similar and rename the method from matches to anagrams. That is:

case class Word(...) {
  // ...
  def anagrams(...) = { ... }
}