Question

I wrote the following code to find the contiguous subarray with maximum sum, which I tink pretty ugly:

The problem is my internal thinking of this problem (using DP) is imperative. How can I refactor this piece of code and make it more functional (and DRY)? Any recommendations on how to think algorithms in functional language? (maybe should be a sperate question though).

class Object
  def sum(lst)
    lst.reduce(:+)
  end
end

def dp_max_subarray(lst)
  i=0
  s=0
  while i<lst.length
    (i...lst.length).each do |j|
      t = sum lst[i..j]
      if t > s
        s= sum lst[i..j]
        next
      elsif t < 0
        i=j+1
        break
      end
    end
    i+=1
  end
  s
end

Answer 1

Look here for a O(n) Python solution. Translating it to functional Ruby is straightforward:

def max_subarray(xs)
  xs.inject([0, 0]) do |(max_so_far, max_up_to_here), x|
    new_max_up_to_here = [max_up_to_here + x, 0].max
    new_max_so_far = [max_so_far, new_max_up_to_here].max
    [new_max_so_far, new_max_up_to_here]
  end.first
end

xs = [31, -41, 59, 26, -53, 58, 97, -93, -23, 84]
max_subarray(xs) #=> 187