A common algorithm used in web applications is a word counter. Although with ruby, we can use regex to get a ton of information on our text in very few lines of code. I wanted to make a readable and comprehensive guide on how awesome ruby is at handling operations like this. Feel free to look at the code and test it out on repl.it
Creating a TextAnalyzer Class
The first step is to move all of our methods that deal with regexing the string/text and finding the information on it into its own class. In this instance we are going to call it TextAnalyzer.
Our class might look a little something like this at the beginning, allowing us to initialize with a text attribute and then normalizing this all to uppercase (which will help us down the road, lowercase would also work but looks less appetizing).
class TextAnalyzer
attr_reader :text
def initialize(text)
# upcase for ease of counting
@text = text.upcase
self
end
end
Adding Our Basic Methods
Counting Words
Since we have our text as one lengthy string, we simply need to split this text at every space and then count the size of the array we split it into. Giving us the amount of words in our string, we don't care about punctuation or digits only spaces.
Our method would look something like:
def word_count
text.split(' ').size
end
Counting Characters
First we need to think of our pre-requisite:
- A character is any text within a string (including spaces, punctuation, digits, etc)
Since we don't care about what the actual character is, we can just split all of text after every character. Which would look like:
def chars
text.split('')
end
# and to count would be simply
def character_count
chars.size
end
Counting Letters
Again lets think of our pre-requisites for a letter:
- Can't be punctuation
- Can't be a digit
- Can't be whitespace
Using a sweet tool called Rubular we can test our regex before implementing it. Using the Regex \W will select any non-word character, using String#gsub we can then replace those non-word characters, with empty strings ('').
All together it would look something like:
def letters
text.gsub(/[\W]/, '')
end
# a little helper method to make the string into an array
def letters_array
letters.split('')
end
# counts the letters in our long string
def letter_count
# don't forget to split our string into an array first!
letters_array.size
end
Counting Consonants and Vowels
Again lets check our pre-requisites for a vowel:
- Must be A, E, I, O, or U
And for consonants:
- Must not be a vowel
For both operations we can make use of the String#scan method that ruby provides. And once again utilizing the regex tool to either find all vowels, or all consonants. The regex we would use would be [ ] containing the letters we want to search for.
All together the methods would look something like:
# counts the vowels from our #letters string
def vowel_count
letters.scan(/[AEIOU]/).size
end
# counts the consonants from our #letters string
def consonant_count
# adding ^ before our characters within the scan
# will find anything except the given characters
letters.scan(/[^AEIOU]/).size
end
It is important to note that because of our operations in our letters method, we don't need to check for punctuation, digits, or whitespace.
Finding the Most Common Letter(s)
In order to find the most common occurrence of a letter, many people build a large while loop or confusing regexes to find the most common occurrence (example). Ruby is simple, expandable, and flexible and we should code that way.
In the case of a tie we wouldn't want our #most_common_letters method to return just the first or last, we want to return all of our ties and then let someone outside our method decide which item they would like to choose. (Whether its first, last, or somewhere in-between!)
# finds the most common character from our #letters string
def most_common_letters
char_hash = {}
letters_array.each do |c|
char_hash[c] ||= 0 unless char_hash[c]
char_hash[c] += 1
end
# finds the highest occurrence
# could use char_has.max_by {|k,v| v} to get the max and character at the same time
# although we would rather return ALL in the case of a tie
max = char_hash.values.max
# returns all in the case of a tie
char_hash.map {|k,v| {k => v} unless v < max }.compact
end
I've found the best way to do this by creating a hash to keep track of unique letters as the key (since we are counting them) and then update their value by 1 every time there is a new occurrence of that letter. This will return the most common letter(s) with their count as the value.
Counting the Most Common Letter
Now that we can find our most common letters with the frequency it is up to us how we want to choose our winner in the case of a tie (remember that we are returning an array of letters).
Let's say we want the first tie, we could call most_common_letters.first. Since this is returning an array of hashes (letters with their frequency) we need to specify the letter and the frequency.
Our code would look something like this:
# holds the key, value pair for the most common letter
def most_common
# gets the first match from our array
most_common_letters.first
end
# gets the letter from the most common hash
def most_common_letter
most_common.keys.first
end
# gets the most common letters value
def most_common_letter_count
most_common.values.first
end
Using Our TextAnalyzer
Now we are all set up and ready to go, displaying the results is as easy as initializing with the string and displaying the associated methods.
text_to_analyze = "Hey! Isn't ruby amazing?!?"
text = TextAnalyzer.new(text_to_analyze)
display_string = <<-STR
Word Count: #{text.word_count}
Sentence Count: #{text.sentence_count}
Character Count: #{text.character_count}
Letter Count: #{text.letter_count}
Vowel Count: #{text.vowel_count}
Consonant Count: #{text.consonant_count}
Most Common Letter: #{text.most_common_letter} used #{text.most_common_letter_count} times.
STR
puts display_string
Conclusion
Ruby is awesome! It let's use use regex and hashes to operate on strings and find occurrences under many different variables. If you find yourself looping over a string to find certain occurrences of characters you might want to use regex!
Combining regex with other ruby functionalities such as hashes and loops can make this extremely powerful for keeping track of occurrences of variables or sorting by any set of pre-requisites.
- View the completed project on repl.it
A Reminder on how to Regex
One way I love to find my regex for the string I am working with is ask myself:
What do I want after the regex? What is going into the regex? Should I look for included characters or excluded characters?
It is very helpful to list out your requirements for the string you want after the regex.
Oldest comments (0)