Question

I am trying to solve the maximum sub array problem with a brute force approach i.e generating all the possible subarrays combinations. I got something that works but it’s not satisfying at all because it produces way too many duplicated subarrays.

Does anyone knows a smart way to generate all the subarrays (in [[]] form) with a minimal number of duplicated elements ?

By the way, I’m new to Haskell. Here’s my current solution:

import qualified Data.List as L

maximumSubList::[Integer]->[Integer]
maximumSubList x = head $ L.sortBy (\a b -> compare (sum b) (sum a)) $ L.nub $ slice x
     where 
        -- slice will return all the "sub lists"
        slice [] = []
        slice x = (slice $ tail x) ++ (sliceLeft x) ++ (sliceRight x)

        -- Create sub lists by removing "left" part
        -- ex [1,2,3] -> [[1,2,3],[2,3],[3]]
        sliceRight [] = []
        sliceRight x = x : (sliceRight $ tail x)

        -- Create sub lists by removing "right" part
        -- ex [1,2,3] -> [[1,2,3],[1,2],[1]]
        sliceLeft [] = []
        sliceLeft x = x : (sliceLeft $ init x)

Answer 1

There are many useful functions for operating on lists in the standard Data.List module.

import Data.List

slice :: [a] -> [[a]]
slice = filter (not . null) . concatMap tails . inits