Question

How can improve this sort method to meet the following conditions:

• exact matches returned first
• partial matches follow exact matches

def find_me
  records = ["gogol", "garrison", "feathers", "grains"]
  sorted = []   

  print "what are you looking for? "
  term = gets.chomp.downcase    

  records.select do |record|
    if term == record.downcase
      #exact match
      sorted << record
    elsif  term[0] == record[0] or term[1] == record[1] or term[2] == record[2]
      #if the first three chars match add it
      sorted << record
    end
  end

  sorted.sort! {|b| term <=> b }
end

Answer 1

You could make a note of which ones are exact matches and which are full matches:

matches = records.each_with_object([]) do |record, m|
  if term == record.downcase
    m << [ 0, record ]
  elsif term[0, 3] == record[0, 3]
    m << [ 1, record ]
  end
end

and then sort on both values and unpack the internal arrays:

matches.sort.map(&:last)

I’m not sure what you’re expecting this sort to do:

sorted.sort! {|b| term <=> b }

but it is going to do strange things because the sort block is supposed to compare two elements of the array with each other and you’re completely ignoring the second one; for example, this happens for me:

>> [4,2,1,2,4].sort { |x| 3 <=> x }
=> [4, 4, 1, 2, 2]

and the resultant ordering doesn’t make much sense.

---

The each_with_object is doing several things at once:

1. Find the exact matches and mark them as exact matches (the leading 0).
2. Find the prefix matches and mark them as partial matches (the leading 1).
3. Return the combined list to be stored in matches; e.each_with_object(m) hands m to the block as its second argument and returns m.

This leaves you with a matches that looks like this:

[ [0, a], [1, b], [1, c], ... ]

with a leading 0 indicating an exact match and 1 indicating a prefix match. Then you can let sort sort matches normally since Array#<=> compares arrays element by element; 0 comes before 1 so the exact matches end up being first. Then we can throw away the exact/partial indicators using map to call last on each of the inner arrays.