Printing the n most frequent words in a file (string) - ruby

Question

The goal:
Write a function that takes two parameters: (1) a String representing a text document and (2) an integer providing the number of items to return. Implement the function such that it returns a list of Strings ordered by word frequency, the most frequently occurring word first. Use your best judgement to decide how words are separated. Your solution should run in O(n) time where n is the number of characters in the document.
My thoughts were that, in the worst case, the input to the function could be the total number of words in the document, reducing the problem to sorting the words by their frequencies. This made me think that the lower bound for time complexity would be O (n log n) if I used a comparison sorting method. So, my thought was that the best approach was to implement a counting sort. Here is my code.
I would like for you to tell me whether my analysis is correct, I've annotated the code with my idea of what the time complexity is, but it could definitely be incorrect. What is the actual time and space complexity of this code? Also I would like to hear if this is in fact a good approach, if there are any alternate approaches that would be used in practice.
### n is number of characters in string, k is number of words ###
def word_frequencies(string, n)
words = string.split(/\s/) # O(n)
max = 0
min = Float::INFINITY
frequencies = words.inject(Hash.new(0)) do |hash,word| # O(k)
occurrences = hash[word] += 1 # O(1)
max = occurrences if occurrences > max # O(1)
min = occurrences if occurrences < min # O(1)
hash; # O(1)
end
### perform a counting sort ###
sorted = Array.new(max + words.length)
delta = 0
frequencies.each do |word, frequency| #O(k)
p word + "--" + frequency.to_s
index = frequency
if sorted[index]
sorted[index] = sorted[index].push(word) # ??? I think O(1).
else
sorted[index] = [word] # O(1)
end
end
return sorted.compact.flatten[-n..-1].reverse
### Compact is O(k). Flatten is O(k). Reverse is O(k). So O(3k)
end
### Total --- O(n + 5k) = O(n). Correct?
### And the space complexity is O(n) for the hash + O(2k) for the sorted array.
### So total O(n).
text = "hi hello hi my name is what what hi hello hi this is a test test test test hi hi hi what hello these are some words these these"
p word_frequencies(text, 4)

Answer 1

Two ways:
def word_counter(string, max)
string.split(/\s+/)
.group_by{|x|x}
.map{|x,y|[x,y.size]}
.sort_by{|_,size| size} # Have to sort =/
.last(max)
end
def word_counter(string, max)
# Create a Hash and a List to store values in.
word_counter, max_storage = Hash.new(0), []
#Split the string an and add each word to the hash:
string.split(/\s+/).each{|word| word_counter[word] += 1}
# Take each word and add it to the list (so that the list_index = word_count)
# I also add the count, but that is not really needed
word_counter.each{|key, val| max_storage[val] = [*max_storage[val]] << [key, val]}
# Higher count will always be at the end, remove nils and get the last "max" elements.
max_storage.compact.flatten(1).last(max)
end

Answer 2

One idea is following:
You are already constructing a hash map that gives the frequency of a given word.
Now iterate through this hash map and create a reverse "hash set". That is the set of words for a given frequency.
Find the maximum frequency and output the set of words for that frequency.
Decrement it, and check for words in the hash set.
Keep doing this till the required number of words.
The order of this algorithm shall be O(f) where f is the maximum frequency of any word. The maximum frequency of any word shall be at most n where n is the number of characters as required.

Answer 3

Sample, quick way :)
#assuming you read from the file and get it to a string called str
h = {}
arr = str.split("\n")
arr.each do |i|
i.split(" ").each do |w|
if h.has_key[w]
h[w] += 1
else
h[w] = 1
end
end
end
Hash[h.sort_by{|k, v| v}.reverse]
This works, but could be improved.