G'day all. At 06:01 10/08/04 +0200, Florian Boehl wrote:

If I know the length 'l' of the 'locklist', I can solve the problem via generators. E.g.:

l = 2: [[a,b] | a <- [0..locklist!!0], b <- [0..locklist!!1]]

But if the length is unknown (because it's dynamic) this solutions (of course) fails. Is it possible to solve this problem in haskell in an elegant way?

This is a transformation that it's useful to know about: [ E | x <- Xs, y <- Ys ] = concat [ [ E | y <- Ys ] | x <- Xs ] Whether or not it's any use to you is another matter. :-) Cheers, Andrew Bromage

Oops, just realised that I didn't include the mailing list in my original reply to Florian -- here was my reply: --------- Hi, I would write it as one of the following, ---- keys [] = [[]] keys (x:xs) = [0..x] >>= (\k -> map (k:) (keys xs)) -- or, keys' [] = [[]] keys' (x:xs) = do { k <- [0..x] ; map (k:) (keys' xs) } -- or, keys'' [] = [[]] keys'' (x:xs) = concat [map (k:) (keys'' xs) | k <- [0..x]] -- or, keys''' [] = [[]] keys''' (x:xs) = concat (map (\k -> map (k:) (keys''' xs)) [0..x]) ---- Each of which does what I think you want. The first two use the fact that lists are a monad, using bind and do notation respectively. (You might have a look at http://www.haskell.org/hawiki/MonadsAsContainers for more information and intuition about what's going on there.) The third makes use of a list comprehension, and the fourth is written using just list functions without any special syntax. The general idea is that to construct keys (x:xs) you add each of [0..x] to the front of each list produced by keys xs. Which of these is most elegant is up to you :) - Cale

Henning Thielemann wrote:

On Wed, 11 Aug 2004, Lyle Kopnicky wrote:

...

Here's my version:

combs [] = [] combs [n] = [[i] | i <- [0..n]] combs (n:r) = let combsr = combs r in [i:cr | i <- [0..n], cr <- combsr]

Since there is one zero combination, it should be

...

combs [] = [[]]

Ah, yes. I knew I must be missing something. That would be a lock which has no numbers on it, but can be opened at any time.

Then you can also remove the definition of combs [n] .

What is the advantage of introducing 'combsr' instead of using 'combs r' immediately?

I initially did that to save recalculation, but later shifted things around, and now I see there is no need for it. Thanks. Here is the improved version: combs [] = [[]] combs (n:r) = [i:cr | i <- [0..n], cr <- combs r] - Lyle

I bow to your superior ingenuity. :) - Lyle

Why so long-winded :-)?

combs = mapM (enumFromTo 0)

mike

Lyle Kopnicky writes: ...

...

Here is the improved version:

combs [] = [[]] combs (n:r) = [i:cr | i <- [0..n], cr <- combs r] ...

Even shorter: c=mapM(\k->[0..k]) - Lyle Fritz Ruehr wrote:

Well, as far as that goes, we can shave off a little bit (around 7%) this way:

combs = mapM (\k->[0..k])

(As a bonus, it's even a bit more cryptic/symbolic, in the fine tradition of APL one-liner character-shavings.)

But who's counting? :) :) :)

-- Fritz Ruehr