```One of the other solutions preferred cutting out the middle of words
(although it also found ambiguous abbreviations when non-ambiguous ones
exist).

To do something similar with mine, replace this line:

w += 1 if i > 0

with:

#weight by distance of cutout from middle of word (middle being highest)
ideal = (str.size - cutout) / 2
w += i if i <= ideal
w += (ideal * 2) - i if i > ideal

--
brian

On Wed, Jun 21, 2006 at 04:42:28AM +0900, brian.mattern / gmail.com wrote:
> 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])
>
>
>

```