Is there a more idiomatic "Ruby" way to write this?

Question

I am writing a class that will sort an array of airport codes in a way that would simulate an aircrafts flight path between multiple cities. For example: Given an array [['LAX', 'BWI'], ['BOS', 'SEA'], ['HNL', 'LAX'], ['SEA', 'HNL']] where the first index of each sub array is the departing airport and the second is the destination airport, the sort_flight_path method would return [['BOS', 'SEA'], ['SEA', 'HNL'], ['HNL', 'LAX'], ['LAX', 'BWI']]. I have a method that finds the start point as an index value, and I have the following method that returns a new sorted array.

def sort_flight_path
    flight_path = [] << @list[@start_point]
    start = @start_point
    until flight_path.size == @list.size
      @list.each do |i|
        if @list[start][1] == i[0]
          flight_path << i
          start = @list.index(i)
        end
      end
    end
    flight_path
  end

As I am becoming more comfortable with Ruby, I want to find a more "Ruby like" way to accomplish this.

Working code that you'd like to refactor belongs on [Code Review](http://codereview.stackexchange.com) instead. — Todd A. Jacobs, Apr 12 '15 at 16:38
maybe you should consider generic algorithms, e.g. - gnome sort - (http://en.wikipedia.org/wiki/Gnome_sort) — marmeladze, Apr 12 '15 at 20:59

score 2 · Answer 1 · answered Apr 12 '15 at 16:48

2

I think by far the best thing you can do is to convert the list to an array, so that lookup becomes trivial:

Hash[list] # => {"LAX"=>"BWI", "BOS"=>"SEA", "HNL"=>"LAX", "SEA"=>"HNL"}

Working example:

list = [['LAX', 'BWI'], ['BOS', 'SEA'], ['HNL', 'LAX'], ['SEA', 'HNL']]
start_point = 1

airport = list[start_point][0]
flight_path = []
h = Hash[list]
h.size.times do
  flight_path << [airport, h[airport]]
  airport = h[airport]
end

answered Apr 12 '15 at 16:48

Karoly Horvath

94,607
11
117
176

Using a hash is a good idea. If `h` is that hash and `start` is city where the flight begins (`'BOS'`), you could write `list.size.times.with_object([start]) { |_,a| a << h[a.last] } #=> ["BOS", "SEA", "HNL", "LAX", "BWI"]`. Of course, this is only a slight variant of what you have. – Cary Swoveland Apr 12 '15 at 18:15

score 1 · Accepted Answer · edited May 23 '17 at 11:59

I agree with @Karoly that it makes sense to convert the list to a hash as the first step. Once done, there are many ways to build the flight path. Here's how it could be done using recursion:

list = [['LAX', 'BWI'], ['BOS', 'SEA'], ['HNL', 'LAX'], ['SEA', 'HNL']]
h = list.to_h # Use Hash[list] for versions < 2.0
  #=> {"LAX"=>"BWI", "BOS"=>"SEA", "HNL"=>"LAX", "SEA"=>"HNL"} 

def route(start_city, h)
  return start_city if h.empty?
  [start_city, *route(h.delete(start_city), h)]
end

The determination of the city where the flight began was addressed in your previous question. In your example it is 'BOS', so we compute:

route('BOS',h)
  #=> ["BOS", "SEA", "HNL", "LAX", "BWI"]

In effect, we ask "where do we go from Boston?" and get the answer "Seattle". We then have the same question as before, except we are starting from Seattle, and the list no longer has the "Bos->Sea" leg.

Is there a more idiomatic "Ruby" way to write this?

2 Answers2