planner 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 63093d4582c46625834f301072d0028811166a5a
+  data.tar.gz: d214c079dd8c04a60cdfbc52d3bbc9e3b7efb6ce
+SHA512:
+  metadata.gz: eed262eeb94e21853e3406b9af3700c8303994e40a00e5bfb0afa7270806370de518eb171e31d636266a6a4c3b382336f8c7b7a4276e71abfad1825172c13e00
+  data.tar.gz: 569dd0f55ee1ecaba3dbe8ddacdd43938f1854355052c0c6c50f4c7bfcd26fd291453a6f0458381ebecc2f489b607d1243e8d31544aaad37ff8e561e88391856

data/bin/planner

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+unless ARGV.first and File.exist? ARGV.first
+  abort "Type:  #{$PROGRAM_NAME} samples/sample.txt"
+end
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require "route_planner"
+
+planner = nil
+
+def answer(task, result)
+  puts "#{task}: #{result}"
+end
+
+File.foreach(ARGV.first) do |line|
+
+  case line
+
+    when /\AGRAPH: (.+)/
+      planner = RoutePlanner.new($1)
+
+    when /\ADISTANCE (\w+): (\w+)/
+      if planner 
+        answer $1, planner.distance($2) || 'NO SUCH ROUTE'
+      end
+
+    when /\ASHORTEST (\w+): (\w) (\w)/
+      if planner 
+        answer $1, planner.shortest_distance($2, $3) || 'NO SUCH ROUTE'
+      end
+
+    when /\ACOUNT_ROUTES (\w+): (\w) (\w) (\d+) (\d+) (\d+)/
+      if planner 
+        opts = { :min_stops => $4.to_i, :max_stops => $5.to_i, :max_distance => $6.to_i }
+        answer $1, planner.trips_number($2, $3, opts)
+      end
+  end  
+
+end

data/lib/route_planner.rb

@@ -0,0 +1,81 @@
+
+
+class RoutePlanner
+  Infinity = 1.0 / 0
+
+  def initialize(graph_info)
+    @graph = { }
+    graph_info.scan(/\w\w\d+/).each do |x|
+      start = x[0,1]
+      finish = x[1,1]
+      @graph[start] ||= { }
+      @graph[start][finish] = x[2..-1].to_i
+    end    
+  end
+  
+  # Determines the distance between two points (towns).
+  # Returns nil if no path is available.
+  def distance(path)
+    dist = 0
+    path.each_char.map.inject do |prev, cur|
+      return nil unless @graph[prev][cur]
+      dist += @graph[prev][cur]
+      cur
+    end
+    dist
+  end
+  
+  # Number of possible trips between two points (towns)
+  def trips_number(start, finish, opts = { })
+    opts = { :min_stops => 1, :max_stops => Infinity, :max_distance => Infinity }.merge(opts)
+    total = 0
+    explore_routes(start, finish, opts) { total += 1}
+    total
+  end
+  
+  def shortest_distance(start, finish)
+    all_nodes = @graph.each.map { |k,v| [k, v.keys] }.flatten.uniq
+    dist = { }
+    all_nodes.each { |x| dist[x] = Infinity }
+    dist[start] = 0
+    if start == finish then
+
+      all_nodes.delete(start)
+      dist[start] = Infinity
+      @graph[start].each { |nxt, how_far| dist[nxt] = how_far }
+    end
+        
+    while not all_nodes.empty? do
+      min_node = all_nodes.min { |a,b| dist[a] <=> dist[b] }
+      if !min_node || min_node == Infinity
+        return nil 
+      end
+      all_nodes.delete(min_node)
+      
+      @graph[min_node].each_key do |v|
+        alt = dist[min_node] + (@graph[min_node][v] || Infinity)
+        dist[v] = alt if dist[v] && alt < dist[v]
+      end
+    end
+    return nil if dist[finish] == Infinity
+    dist[finish]
+  end
+  
+  private
+
+  # Traverses the graph until maximum stops or distance is reached.
+  def explore_routes(start, finish, opts, stats = {:distance => 0, :stops => 0}, &callback)
+    lower_bound_ok = stats[:stops] >= opts[:min_stops]
+    upper_bound_ok = stats[:distance] <= opts[:max_distance] && stats[:stops] <= opts[:max_stops]
+    
+    callback.call(stats[:path]) if start == finish && lower_bound_ok && upper_bound_ok
+    # Recursion basis: stop exploration when reached upper-bound restrictions
+    if upper_bound_ok    
+      @graph[start].each do |nxt, dist|
+        inner_stats = {:distance => stats[:distance] + dist, :stops => stats[:stops] + 1}
+        explore_routes(nxt, finish, opts, inner_stats, &callback)
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: planner
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Marc Bluemner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-20 00:00:00.000000000 Z
+dependencies: []
+description: Train route planner
+email: marc.bluemner@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/planner
+- lib/route_planner.rb
+homepage: https://rubygems.org/gems/planner
+licenses:
+- apache
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Planner!
+test_files: []
+has_rdoc: