Question

Note: This is a ‘sequel’ question to my previous permutations question.

I would like to generate all permutations of a list in Erlang, but I would like to filter out some of the permutations before they are added to the stack or stored anywhere.

I will filter out the permutations based on some custom ad-hoc rules (let’s call them “Filter”).

In other words, I would like to generate a list of permutations of a large list (50-300 elements), but I would like to throw out most of the generated permutations right during the process (I know that the full number of permutations is N!).

steenslag has given me a nice solution in Ruby:

res = [1,2,3,4].permutation(3).reject do |perm|
  perm.first.even? #Filter: if this line is true, the perm will be rejected
end

How can I write something similar in Erlang?

(I have my Filter functions already written in Erlang, so I would like to do some code reuse).

By the way, can the desired Erlang solution be ‘intrinsically parallel’?

Answer 1

I did a possible implementation for the problem:

-module(perm).

-export([pred_perms/2, pred/1]).

pred(L = [H | _T]) when H > 1 ->
    L;
pred(_L) ->
    [].

do_pred_perms([], _Pred) -> 
    [[]];
do_pred_perms(L, Pred)  -> 
    [Pred([H|T]) || H <- L, T <- do_pred_perms(L--[H], Pred)].

pred_perms(List, Pred) ->
    Res = do_pred_perms(List, Pred),
    lists:filter(fun(E) -> E =/= [] end, Res).

It uses empty lists as placeholders for lists that must be discarded. If this is not acceptable, you can change the implementation to not use list compreension.

The pred/1 function is just an example function to use as predicate.

Hope this helps.