CODEWITHSUNDEEP
prolog
Radek
Radek

Reputation: 3941

Replace elements of a list in Prolog

I have a predicate variablize/3 that takes a list and replaces each item, in turn, with a variable, example:

% ?- variablize([a,b,c], X, L).
% L = [[X, b, c], [a, X, c], [a, b, X]]

Now I am trying to extend this predicate to accept a list of variables, example:

% ?- variablize([a,b,c], [X,Y], L).
% L = [[X, Y, c], [X, b, Y], [a, X, Y]]

My code so far is:

replace_at([_|Tail], X, 1, [X|Tail]).
replace_at([Head|Tail], X, N, [Head|R]) :- M is N - 1, replace_at(Tail, X, M, R).

replace_each([], _, _, [], _).
replace_each([_|Next], Orig, X, [Res|L], N) :-
    replace_at(Orig, X, N, Res),
    M is N + 1,
    replace_each(Next, Orig, X, L, M).

variablize(I, X, L) :- replace_each(I, I, X, L, 1).

Any pointers? Do I extend replace_at/4 to have a list of indexes that should be skipped?

Upvotes: 4

Views: 3546

Answers (2)

尾崎隆大
尾崎隆大

Reputation: 158

variablize(L1,L2,L) :-
    append(L1,L2,L3),
    length(L1,Len1),
    length(L2,Len2),
    findall(L4,(combination(L3,Len1,L4),var_count(L4,Len2)),L).

combination(X,1,[A]) :-
    member(A,X).
combination([A|Y],N,[A|X]) :-
    N > 1,
    M is N - 1,
    combination(Y,M,X).
combination([_|Y],N,A) :-
    N > 1,
    combination(Y,N,A).

var_count([],0).
var_count([V|R],N) :-
    var(V),
    var_count(R,N1),
    N is N1 + 1,
    !.
var_count([A|R],N) :-
    var_count(R,N).

Upvotes: 0

CapelliC
CapelliC

Reputation: 60014

A simplified, builtin based way of implementing variablize/3

variablize(I, X, L) :-
    bagof(R, U^select(U, I, X, R), L).

put in evidence that instead of select/4 we could have a distribute/3 that applies replacements of elements of X, when X becomes a list. select/4 can be implemented in this way

myselect(B, I, X, R) :-
    append(A, [B|C], I), append(A, [X|C], R).

and this form is convenient because we have the part to the right of input list I, where I suppose you need to distribute remaining variables. Then a recursion on X elements should do:

distribute(I, [X|Xs], L) :-
    append(A, [_|C], I),
    distribute(C, Xs, R),
    append(A, [X|R], L).
distribute(I, [], I).

distribute/3 behaves this way:

?- distribute([a,b,c,d],[1,2],X).
X = [1, 2, c, d] ;
X = [1, b, 2, d] ;
X = [1, b, c, 2] ;
X = [a, 1, 2, d] ;
X = [a, 1, c, 2] ;
X = [a, b, 1, 2] ;
false.

thus

variablize_l(I, X, L) :-
    bagof(R, distribute(I, X, R), L).

give us:

?- variablize_l([a,b,c],[X,Y],L).
L = [[X, Y, c], [X, b, Y], [a, X, Y]].

edit

I initially wrote this way, for here the evidence of separating the distribution phase from list construction:

replace_v([_|T], X, [X|T]).
replace_v([L|T], X, [L|R]) :-
    replace_v(T, X, R).
variablize(I, X, L) :-
    bagof(E, replace_v(I, X, E), L).

Upvotes: 2

Related Questions