在Haskell中生成所有可能的路径

Question

I am very bad at wording things, so please bear with me.

I am doing a problem that requires me to generate all possible numbers in the form of a lists of lists, in Haskell.

For example if I have x = 3 and y = 2, I have to generate a list of lists like this:

[[1,1,1], [1,2,1], [2,1,1], [2,2,1], [1,1,2], [1,2,2], [2,1,2], [2,2,2]]

x and y are passed into the function and it has to work with any nonzero positive integers x and y.

I am completely lost and have no idea how to even begin.

For anyone kind enough to help me, please try to keep any math-heavy explanations as easy to understand as possible. I am really not good at math.

Answer 1

Assuming that this is homework, I'll give you the part of the answer, and show you how I think through this sort of problem. It's helpful to experiment in GHCi, and build up the pieces we need. One thing we need is to be able to generate a list of numbers from 1 through y . Suppose y is 7. Then:

λ> [1..7]
[1,2,3,4,5,6,7]

But as you'll see in a moment, what we really need is not a simple list, but a list of lists that we can build on. Like this:

λ> map (:[]) [1..7]
[[1],[2],[3],[4],[5],[6],[7]]

This basically says to take each element in the array, and prepend it to the empty list [] . So now we can write a function to do this for us.

makeListOfLists y = map (:[]) [1..y]

Next, we need a way to prepend a new element to every element in a list of lists. Something like this:

λ> map (99:) [[1],[2],[3],[4],[5],[6],[7]]
[[99,1],[99,2],[99,3],[99,4],[99,5],[99,6],[99,7]]

(I used 99 here instead of, say, 1, so that you can easily see where the numbers come from.) So we could write a function to do that:

prepend x yss = map (x:) yss

Ultimately, we want to be able to take a list and a list of lists, and invoke prepend on every element in the list to every element in the list of lists. We can do that using the map function again. But as it turns out, it will be a little easier to do that if we switch the order of the arguments to prepend , like this:

prepend2 yss x = map (x:) yss

Then we can do something like this:

λ>  map (prepend2 [[1],[2],[3],[4],[5],[6],[7]]) [97,98,99]
[[[97,1],[97,2],[97,3],[97,4],[97,5],[97,6],[97,7]],[[98,1],[98,2],[98,3],[98,4],[98,5],[98,6],[98,7]],[[99,1],[99,2],[99,3],[99,4],[99,5],[99,6],[99,7]]]

So now we can write that function:

supermap xs yss = map (prepend2 yss) xs

Using your example, if x=2 and y=3, then the answer we need is:

λ> let yss = makeListOfLists 3
λ> supermap [1..3] yss
[[[1,1],[1,2],[1,3]],[[2,1],[2,2],[2,3]],[[3,1],[3,2],[3,3]]]

(If that was all we needed, we could have done this more easily using a list comprehension. But since we need to be able to do this for an arbitrary x, a list comprehension won't work.)

Hopefully you can take it from here, and extend it to arbitrary x.

Answer 2

For the specific x, as already mentioned, the list comprehension would do the trick, assuming that x equals 3, one would write the following:

 generate y = [[a,b,c] | a<-[1..y], b<-[1..y], c <-[1..y]]

But life gets much more complicated when x is not predetermined. I don't have much experience of programming in Haskell, I'm not acquainted with library functions and my approach is far from being the most efficient solution, so don't judge it too harshly.

My solution consists of two functions:

strip [] = []
strip (h:t) = h ++ strip t

populate y 2 = strip( map (\a-> map (:a:[]) [1..y]) [1..y])
populate y x = strip( map (\a-> map (:a) [1..y]) ( populate y ( x - 1) ))

strip is defined for the nested lists. By merging the list-items it reduces the hierarchy so to speak. For example calling

strip [[1],[2],[3]]

generates the output:

[1,2,3]

populate is the tricky one.

On the last step of the recursion, when the second argument equals to 2, the function maps each item of [1..y] with every element of the same list into a new list. For example

map (\a-> map (:a:[]) [1..2]) [1..2])

generates the output:

[[[1,1],[2,1]],[[1,2],[2,2]]]

and the strip function turns it into:

[[1,1],[2,1],[1,2],[2,2]]

As for the initial step of the recursion, when x is more than 2, populate does almost the same thing except this time it maps the items of the list with the list generated by the recursive call. And Finally:

populate 2 3

gives us the desired result:

[[1,1,1],[2,1,1],[1,2,1],[2,2,1],[1,1,2],[2,1,2],[1,2,2],[2,2,2]]

As I mentioned above, this approach is neither the most efficient nor the most readable one, but I think it solves the problem. In fact, theoritically the only way of solving this without the heavy usage of recursion would be building the string with list comprehension statement in it and than compiling that string dynamically, which, according to my short experience, as a programmer, is never a good solution.