```Here is my own solution. I had hoped to do a bit more work on this,
but alas I do not expect to have time this week to do anymore, so here
it is, as-is.

It's a quick-n-dirty solution, storing hashes of hashes. The keys were
groups of X words at a time, X being the order.

require 'enumerator'

ORDER = 3

class Markov
def initialize
@graph = Hash.new { |h, k| h[k] = Hash.new(0) }
@count = Hash.new(0)
end

def <<(group)
source, sink = group[0...-1].join(' '), group[-1]
@graph[source][sink] += 1
@count[source] += 1
end

def [](group)
return '' if group.empty?

source = group.join(' ')
return self[group[1..-1]] if @count[source].zero?

x = rand(@count[source])
@graph[source].each do |sink, freq|
return sink if x < freq
x -= freq
end
end
end

m = Markov.new

length = 0
number = 0

ARGV.each do |arg|

words  = [''] * ORDER
words += File.open(arg).read.split(/\s+/).reject { |x| x.empty? }

words.each_cons(ORDER+1) do |group|
m << group
length += 1
end
number += 1
end

text = []
group = [''] * ORDER
(length / number).times { text << group.push(m[group]).shift }

puts text.join(' ')

```