```Here is my quick solution to quiz #83.
First I find all possible abbreviations, then try to find unique ones
for each string. If this isn't possible, then it tries for at least a
different abbreviation for each string. Finally, it falls back to the
heighest weighted abbreviation.

Weighting is currently a bit simplistic, and could probably be improved.
Weight is increased for
A) including the first character
B) cutting out 'word boundary' characters (' ', '_', '-', '.')

--
Brian Mattern

#Code below:

require 'pp'

module Compressor
# gets all compressed versions of str
def self.compress(str, len, ellipses = '...')
len = len.to_i
return case
when str.size <= len
[str]
else
ret = []
weight = {}
cutout = str.size - len + ellipses.size - 1
(0..(len-ellipses.size)).to_a.each do |i|
a = str.dup
a[i..(i + cutout)] = ellipses
w = 0
w += 1 if i > 0
[' ', '_', '-', '.'].each do |c|
w += 1 if str[i..(i+cutout)].include?(c)
end
ret << a
weight[a] = w

end

ret.sort{|s1, s2| weight[s2] <=> weight[s1] }
end
end

def self.compress_array(arr, len, ellipses = '...')
candidates = {}
arr.each { |s| candidates[s] = self.compress(s, len, ellipses) }

results = {}
candidates.each { |k, v|
# first try to find a completely unique abbreviation
results[k] = v.find { |s|
candidates.all? { |k2, v2| k2 == k or !v2.include?(s)}
}

# if none was found, just pick one that's different from the other chosen ones
results[k] = v.find { |s| !results.values.include?(s) } if results[k].nil?

# if we still don't have one, pick the first one (heighest weighted)
results[k] = v.first if results[k].nil?
}
arr.collect{ |s| results[s] }
end
end

class Array
def compress(len = 10)
Compressor.compress_array(self, len)
end
end

pp ARGV[1..-1].compress(ARGV[0])

```