Comments on: Dynamic Programming in Haskell and why DP is useful

By: Jedaï

Jedaï — Tue, 30 Jun 2009 13:48:57 +0000

> yes I do need to explore the prelude. It’s one of the things that
> I’m lazy to do whenever i learn a new language but it’s quite important.

In the case of Haskell, exploring the Prelude is both important and interesting because most of this Prelude is written in Haskell (in fact all of it but for some primitives for additions, equalities and so on). It isn’t as dry and boring than reading a list of functions with their type and description, you also have some quite nice code. Reading the Prelude is as much a didactic experience that it is a necessity to write code without reinventing the wheel.

http://www.haskell.org/onlinereport/standard-prelude.html

(not all bits are as interesting, the numeric instances part bore me to tears myself)
The current Prelude code in GHC contains some subtle difference and Data.List and others bring some other functions but the base of Haskell is still the Prelude.

By: akshayk

akshayk — Tue, 30 Jun 2009 13:02:01 +0000

@adrian - I’m not entirely sure what your program is doing but it looks like a 2-d dynamic programming. However, I think it quite inefficient (i.e. exponential) because of all the calls to leMatrix
@phil - it’s a different problem but great. i liked your post and the haskell solution looked good to me.
@internetguy - yeah I know about pattern matching, just haven’t gotten used to using it. I didn’t know about guards but thanks for the tip. I will try to use both of them in the future. Yeah I knew about the empty list problem but the way that I’m calling it will never trigger that so it’s a bad practice but ok in this situation. You’re right about using Maybe though.
@Jedai - yes I do need to explore the prelude. It’s one of the things that I’m lazy to do whenever i learn a new language but it’s quite important. Yeah I will try and incorporate pattern matching and guards into my programming.

thanks for the comments everyone

By: Jedaï

Jedaï — Tue, 30 Jun 2009 11:09:01 +0000

lis :: (Ord a) => [a] -> [a]
lis = snd . maximum . foldr go []
  where
    go x xxs = foldl’ (best x) (1,[x]) xxs : xxs
    best x cur@(len,_) (len’, yys@(y:ys)) = if x < y && len <= len’ then (len’+1, x:yys) else cur

This seems to do the trick.

A remark on your style : you should probably take some time to explore the prelude and Data.List (listGet = (!!), getIndex = elemIndex, listMax = maximum). You also use length too much : length is O(n) and you shouldn’t need it very much (for instance using length in your listMax was completely useless). Instead you should try to use pattern matching more, and guards are good too, though an if…then…else here and there isn’t too bad (as long you don’t start to nest them).

By: Some Internet Guy

Some Internet Guy — Mon, 29 Jun 2009 20:41:20 +0000

I neglected to provide an empty list case for the alternative getIndex I sketched. Your original version contains the same flaw as mine.

getIndex [] i = error “probably this function should return Maybe Int instead of crashing”

If an empty list were passed to your getIndex, then the call to head would crash. If your version doesn’t find the desired item, then it will recurse until the empty list case happens, so you still get a crash.

Functions which are not defined for all inputs are called partial functions and they can ruin your day. head is a partial function because it just crashes (prints an error and aborts the program) if you pass it an empty list. You can make a partial function a total function by returning a Maybe type, and using Maybe’s Nothing value to signal failure.

For example, Data.list.elemIndex returns Maybe Int, such that you get Just 5 if your item is found at index 5, or Nothing if it is not found at all.

By: Some Internet Guy

Some Internet Guy — Mon, 29 Jun 2009 20:19:19 +0000

You can make your code more concise by using pattern matching and guards. Consider this alternative version of your getIndex function (formatting might be eaten by the blog):

getIndex (x:xs) i
| x == i = 0
| otherwise = 1 + getIndex xs i

You can avoid calling head and tail by simply breaking your list apart in the pattern. The ‘|’ things are guards, which simply evaluate some boolean expression to decide which function body will be used.

For even more concision, you can call Data.List.elemIndex instead of using your getIndex function.

By: akrish » Blog Archive » Dynamic Programming in Haskell and why DP …

akrish » Blog Archive » Dynamic Programming in Haskell and why DP … — Mon, 29 Jun 2009 16:48:08 +0000

[...] original here: akrish » Blog Archive » Dynamic Programming in Haskell and why DP … SHARETHIS.addEntry({ title: “akrish » Blog Archive » Dynamic Programming in Haskell and why DP [...]

By: Phil

Phil — Mon, 29 Jun 2009 15:42:40 +0000

I recently solved the longest common subsequence problem at http://programmingpraxis.com/2009/06/09/longest-common-subsequence/. One of the comments provided a Haskell solution.

By: adrian

adrian — Mon, 29 Jun 2009 06:56:56 +0000

import Data.Array

type Matrix = Array (Int,Int) Int

leMatrix :: String -> String -> Matrix
leMatrix s1 s2= let (ls1,ls2)=(length s1, length s2) in array ((0,0), (ls1, ls2)) $
[((x,0),x)|x<-[0.. ls1]] ++ [((0,x),x)|x<-[1.. ls2]] ++ — Initialisierung
[((i,j), minimum [(leMatrix s1 s2)!(i-1,j-1)+ d i j s1 s2, -- Rekursion
(leMatrix s1 s2)!(i-1,j)+1,
(leMatrix s1 s2)!(i,j-1)+1]) | i<-[1.. ls1], j Int -> String -> String -> Int
d i j s1 s2
| s1!!(i-1) == s2!!(j-1) = 0
| otherwise = 1