Odtnhj

I have a code, which generates all the possible variation (with the legnth of N) with repetition.

variation(1, L) ->
 [ [H] || H <- L ];
variation(N, L) ->
 [[H | T] || H <- L, T <- variation(N - 1, L)].

For variation(3, [1,2,3,4]) it will generate:

[[1,1,1,1],[1,1,1,2],[1,1,1,3],[1,1,1,4],[1,1,2,1],...]

I would like to check a condition during the generation of the lists. If a sublist fails, it should stop generating lists, that begins with the certain sublist.
For example if [1,1] sublist fails that condition (check), than it should not generate [1,1,1,1], [1,1,1,2] etc (all of those that begin with [1,1]).

I don't know if its possible with 1 list comprehension.
So far, I have this code:

variation(1, L) ->
 [ [H] || H <- L ];
variation(N, L) ->
 [[H | T] || H <- L, T <- variation(N - 1, L), check([H|T]) ].

This solution will only return those lists, that doesn't fail the condition (it works, but really slow for big input).

If [1,1] fails, it will try to generate [1,1,1,2], but those will fail the check as well. I would need a solution, which doesn't try to generate lists that begin with [1,1,...] (or with a previously failing sublist).

One small detail first: According to your question, variations(3, [1,2,3]). should generate [[1,1,1,1], [1,1,1,2], …] but it actually generates [[1,1,1], [1,1,2], …]. I will assume the code was right and you meant to say that variations(4, [1,2,3]). should generate [[1,1,1,1], [1,1,1,2], …]

I wrote an alternative version of your function that, using a different order on the right side of the LC, avoids generating list when their prefix is already false when checked with check/1:

variation(1, L) ->
 [ [Elem] || Elem <- L ];
variation(N, L) ->
 [ Init ++ [Last] || Init <- variation(N-1, L), check(Init), Last <- L].

As you can see, since check(Init) happens before Last <- L, Last is only generated if check(Init) == true.
That will likely have the effect you were looking for.

But… be careful. I'm using ++ in the left side of the LC. You should definitely benchmark your code and see if that has an impact on performance or not.

If it does, and only if it does, you might want to consider using something like this:

variation3(1, L) ->
 [ [Elem] || Elem <- L ];
variation3(N, L) ->
 [ lists:reverse([Last|lists:reverse(Init)]) || Init <- variation2(N-1, L), check(Init), Last <- L].

Maybe worth it, maybe not… you will need to benchmark your stuff to figure that out.