0

I've been trying to learn Prolog by writing a simple program that given a list of items, returns/stores a copy of the list without duplicates in the same order. Ex: [1,1,2,3,3,3,5] returns [1,2,3,5]. I'm using the append to add the numbers to an empty list and the member to check if the integer already has been added.

remove_duplicates([], R). 
remove_duplicates([H|T], R) :-
   member(H, R)
-> remove_duplicates(T, R)
;  append(H, R),
   remove_duplicates(T, R).

I've gotten the code to almost work, however when running the code it returns R = [1, 2, 3, 6|_]. I've tried tracing and debugging however I'm unable to understand why the |_ is added at the end.

My thought process for the code is as following, please point out if I'm misunderstanding something.

remove_duplicates([], R). % If first list is empty, return R. (Used to stop the recursion).
remove_duplicates([H|T], R) :-
   member(H, R)
-> remove_duplicates(T, R) % If head is member of R (=true), call remove:_duplicates again without the head. 
;  append(H, R),
   remove_duplicates(T, R). % else (if member(H, R) = false), add the head to list R and call remove_duplicates again with tail and R.
false
  • 10,264
  • 13
  • 101
  • 209
Althosia
  • 1
  • 1
  • Replace `R` by `[]` in the very first line, to "close" the end of the list. Also, no need for `append`. See https://stackoverflow.com/questions/73896679/implement-a-prolog-predicate-that-removes-all-duplicate-elements – brebs Oct 10 '22 at 11:28
  • See [`list_nub/2`](https://stackoverflow.com/a/61719037/772868) for a pure implementation. – false Oct 11 '22 at 09:12

2 Answers2

0

My answer to the question implement a prolog predicate that removes all duplicate elements as noted by @brebs is close, but it will not give you what you want. This

list_set( []     , []     ) .
list_set( [X|Xs] , Ys     ) :- memberchk(X,Xs), !, list_set(Xs,Ys) .
list_set( [X|Xs] , [X|Ys] ) :-                     list_set(Xs,Ys) .

prefers the last of duplicated items, so

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

reduces to

[3,2,1]

Which violates the constraint in your problem statement, that you get

a copy of the list without duplicates in the same order.

We can switch that up to prefer the first of any duplicate elements by using a helper predicate with an accumulator and introducing the use of append/3:

list_set( Xs , Ys ) :- list_set( Xs , [] , Ys ) .

list_set( []     , Ys , Ys ) .
list_set( [X|Xs] , Ts , Ys ) :- memberchk(X,Ts)   , ! , list_set(Xs,Ts,Ys) .
list_set( [X|Xs] , Ts , Ys ) :- append(Ts,[X],T1) ,     list_set(Xs,T1,Ys) .
Nicholas Carey
  • 71,308
  • 16
  • 93
  • 135
0

This is fastest method I've found so far (doesn't use append or reverse):

https://stackoverflow.com/a/74024975/

brebs
  • 3,462
  • 2
  • 3
  • 12