我对 Prolog 完全陌生，并尝试了一些练习。其中之一是：
写一个谓词集(InList,OutList) 它将任意输入作为输入 列表，并返回一个列表，其中每个 输入列表的元素只出现 一次。
这是我的解决方案：
member(X,[X|_]).
member(X,[_|T]) :- member(X,T).
set([],[]).
set([H|T],[H|Out]) :-
not(member(H,T)),
set(T,Out).
set([H|T],Out) :-
member(H,T),
set(T,Out).
我不允许使用任何内置谓词（最好不要使用not/1）。问题是，set/2 提供了多个 same 解决方案。输入列表中的重复次数越多，产生的解决方案就越多。我究竟做错了什么？提前致谢。
【问题讨论】：
由于 Prolog 的回溯，您获得了多种解决方案。从技术上讲，提供的每个解决方案都是正确的，这就是生成它的原因。如果您只想生成一个解决方案，您将不得不在某个时候停止回溯。这就是 Prolog cut 的用途。您可能会发现阅读这些内容可以帮助您解决这个问题。
更新：没错。如果第一个变量在第二个变量中的多个位置，则您的 member() 谓词以几种不同的方式评估为 true。
我为这个谓词使用了名称mymember()，以免与GNU Prolog 的内置member() 谓词冲突。我的知识库现在看起来像这样：
mymember(X,[X|_]).
mymember(X,[_|T]) :- mymember(X,T).
not(A) :- \+ call(A).
set([],[]).
set([H|T],[H|Out]) :-
not(mymember(H,T)),
set(T,Out).
set([H|T],Out) :-
mymember(H,T),
set(T,Out).
因此，mymember(1, [1, 1, 1]). 以三种不同的方式评估为 true：
| ?- mymember(1, [1, 1, 1]).
true ? a
true
true
no
如果你只想得到一个答案，你将不得不使用一个cut。将mymember() 的第一个定义更改为：
mymember(X,[X|_]) :- !.
解决您的问题。
此外，如果您愿意，可以通过自己定义 notamember() 谓词来完全避免 not()。选择权在你。
【讨论】：
not() 谓词。您能否概述一下您的 not() 谓词是如何定义的？
你在正确的轨道上...... 保持纯洁---这很容易！
使用具体的相等谓词=/3 和dif/3 与if_/3 结合使用，在Prolog union for A U B U C 中实现：
=(X, Y, R) :- X == Y, !, R = true.
=(X, Y, R) :- ?=(X, Y), !, R = false. % syntactically different
=(X, Y, R) :- X \= Y, !, R = false. % semantically different
=(X, Y, R) :- R == true, !, X = Y.
=(X, X, true).
=(X, Y, false) :-
dif(X, Y).
% dif/3 is defined like (=)/3
dif(X, Y, R) :- X == Y, !, R = false.
dif(X, Y, R) :- ?=(X, Y), !, R = true. % syntactically different
dif(X, Y, R) :- X \= Y, !, R = true. % semantically different
dif(X, Y, R) :- R == true, !, X \= Y.
dif(X, Y, true) :- % succeed first!
dif(X, Y).
dif(X, X, false).
if_(C_1, Then_0, Else_0) :-
call(C_1, Truth),
functor(Truth,_,0), % safety check
( Truth == true -> Then_0 ; Truth == false, Else_0 ).
基于这些谓词，我们构建了一个具体的成员谓词list_item_isMember/3。它在语义上与@false 的memberd_truth/3 等价。我们重新排列参数顺序，因此列表是第一个参数。这将启用 first-argument 索引，从而防止留下无用的选择点，因为 memberd_truth/3 会创建。
list_item_isMember([],_,false).
list_item_isMember([X|Xs],E,Truth) :-
if_(E = X, Truth = true, list_item_isMember(Xs,E,Truth)).
list_set([],[]).
list_set([X|Xs],Ys) :-
if_(list_item_isMember(Xs,X), Ys = Ys0, Ys = [X|Ys0]),
list_set(Xs,Ys0).
一个简单的查询表明所有多余的答案都已消除并且目标成功没有留下任何选择点：
?- list_set([1,2,3,4,1,2,3,4,1,2,3,1,2,1],Xs)。 Xs = [4,3,2,1]。 % 确定性地成功@Ludwig 对set/2 的回答启发了我，如下所示：
set([],[]).
set([H|T],[H|T1]) :- subtract(T,[H],T2), set(T2,T1).
SWI-Prolog 的内置谓词subtract/3 可以是非单调的，这可能会限制其使用。 list_item_subtracted/3 是它的单调变体：
list_item_subtracted([],_,[]).
list_item_subtracted([A|As],E,Bs1) :-
if_(dif(A,E), Bs1 = [A|Bs], Bs = Bs1),
list_item_subtracted(As,E,Bs).
list_setB/2 类似于set/2，但基于list_item_subtracted/3---不是subtract/3：
list_setB([],[]).
list_setB([X|Xs1],[X|Ys]) :-
list_item_subtracted(Xs1,X,Xs),
list_setB(Xs,Ys).
以下查询比较list_set/2 和list_setB/2：
【讨论】：
memberd_truth/2 需要更好的实现。
一个更简单（并且可能更快）的解决方案是使用库谓词 sort/2 来删除 O(n log n) 中的重复项。绝对适用于 Yap prolog 和 SWIPL
【讨论】：
我认为更好的方法是：
set([], []).
set([H|T], [H|T1]) :- subtract(T, [H], T2), set(T2, T1).
所以，例如?- set([1,4,1,1,3,4],S) 给你作为输出：
S = [1, 4, 3]
【讨论】：
将我的答案添加到这个旧线程：
notmember(_,[]).
notmember(X,[H|T]):-X\=H,notmember(X,T).
set([],[]).
set([H|T],S):-set(T,S),member(H,S).
set([H|T],[H|S]):-set(T,S),not(member(H,S)).
此解决方案的唯一优点是它仅使用在此练习出现在original text 中的那一点已经引入的谓词。
【讨论】：
这在没有剪切的情况下有效，但它需要更多的行和另一个参数。 如果我在第三行将 [H2|T2] 更改为 S，它将产生多个结果。我不明白为什么。
setb([],[],_).
setb([H|T],[H|T2],A) :- not(member(H,A)),setb(T,T2,[H|A]).
setb([H|T],[H2|T2],A) :- member(H,A),setb(T,[H2|T2],A).
setb([H|T],[],A) :- member(H,A),setb(T,[],A).
set(L,S) :- setb(L,S,[]).
【讨论】：
你只需要停止 Prolog 的回溯。
enter code here
member(X,[X|_]):- !.
member(X,[_|T]) :- member(X,T).
set([],[]).
set([H|T],[H|Out]) :-
not(member(H,T)),
!,
set(T,Out).
set([H|T],Out) :-
member(H,T),
set(T,Out).
【讨论】：
使用 Tim 的支持函数 mymember，如果集合中元素的顺序不重要，您可以这样做：
mymember(X,[X|_]).
mymember(X,[_|T]) :- mymember(X,T).
mkset([],[]).
mkset([T|C], S) :- mymember(T,C),!, mkset(C,S).
mkset([T|C], S) :- mkset(C,Z), S=[T|Z].
所以，例如?- mkset([1,4,1,1,3,4],S) 给你作为输出：
S = [1, 3, 4]
但是，如果您想要一个具有列表中排序元素的集合，您可以使用：
mkset2([],[], _).
mkset2([T|C], S, D) :- mkset2(C,Z,[T|D]), ((mymember(T,D), S=Z,!) ; S=[T|Z]).
mkset(L, S) :- mkset2(L,S,[]).
这个解决方案，与上一个例子的输入相同，给你：
S = [1, 4, 3]
这次元素的顺序与它们在输入列表中出现的顺序相同。
【讨论】：
/* Remove duplicates from a list without accumulator */
our_member(A,[A|Rest]).
our_member(A, [_|Rest]):-
our_member(A, Rest).
remove_dup([],[]):-!.
remove_dup([X|Rest],L):-
our_member(X,Rest),!,
remove_dup(Rest,L).
remove_dup([X|Rest],[X|L]):-
remove_dup(Rest,L).
【讨论】：