如何从序言中的列表中删除反向重复列表？

发布于 2025-01-18 12:24:51 字数 291 浏览 0 评论 0原文

我是新手学习序言的新手，我想实现以下谓词。


removereverse([[1,5],[5,1],[2,3],[3,2]],List).  ---> Input

what I want:

List = [[1,5],[2,3]].

真皮


removes([],[]).
removes([[N1,N2]|T],[[N1,N2]|New]):-
    \+member([N1,N2],New),
    removes(T,New).

原文

I'm new to learn the prolog, I want to fulfill the predicate below.


removereverse([[1,5],[5,1],[2,3],[3,2]],List).  ---> Input

what I want:

List = [[1,5],[2,3]].

mycode


removes([],[]).
removes([[N1,N2]|T],[[N1,N2]|New]):-
    \+member([N1,N2],New),
    removes(T,New).

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

以可爱出名 2025-01-25 12:24:51

像这样的东西吗？

首先，我们定义一个谓词来告诉我们列表中的列表中的列表是否重复。如果列表或其反向列表存在于目标列表列表中，则将列表视为重复项：

duplicated(X,Ls) :-               member(X,Ls).
duplicated(X,Ls) :- reverse(X,R), member(R,Ls).

然后我们可以说：

clean( []     ,    []  ) .
clean( [X|Xs] ,    Ys  ) :- duplicated(X,Xs), !, clean(Xs,Ys) .
clean( [X|Xs] , [X|Ys] ) :-                      clean(Xs,Ys) .

保留找到的最后一个“重复项”并丢弃源列表中它们之前的列表。要保留第一个这样的“重复”，只需更改递归发生的位置：

clean( []     ,    []  ) .
clean( [X|Xs] ,    Ys  ) :- clean(Xs,Ys), duplicated(X,Xs), !.
clean( [X|Xs] , [X|Ys] ) :- clean(Xs,Ys).

另一种方法使用辅助谓词：

这保留第一个：

clean( Xs, Ys ) :- clean(Xs,[],Y0), reverse(Y0,Ys).

clean( []     , Ys, Ys ) .
clean( [X|Xs] , Ts, Ys ) :- duplicated(X,Ts), !, clean(Xs,   Ts ,Ys).
clean( [X|Xs] , Ts, Ys ) :-                      clean(Xs,[X|Ts],Ys).

要保留最后一个，只需将 duplicate(X,Ts) 更改为重复（X，Xs）。前者检查累加器 Ts 中是否存在 X；后者检查源列表尾部是否存在 X (Xs)。

Something like this?

First, lets define a predicate to tell us if a list is duplicated within a list-of-lists. This counts a list as a duplicate if either it or its reverse exists in the target list-of-lists:

duplicated(X,Ls) :-               member(X,Ls).
duplicated(X,Ls) :- reverse(X,R), member(R,Ls).

Then we can say:

clean( []     ,    []  ) .
clean( [X|Xs] ,    Ys  ) :- duplicated(X,Xs), !, clean(Xs,Ys) .
clean( [X|Xs] , [X|Ys] ) :-                      clean(Xs,Ys) .

That keeps the last "duplicate" found and discard those preceding them in the source list. To keep the first such "duplicate" instead, just change where the recursion occurs:

clean( []     ,    []  ) .
clean( [X|Xs] ,    Ys  ) :- clean(Xs,Ys), duplicated(X,Xs), !.
clean( [X|Xs] , [X|Ys] ) :- clean(Xs,Ys).

Another approach uses a helper predicate:

This keeps the first:

clean( Xs, Ys ) :- clean(Xs,[],Y0), reverse(Y0,Ys).

clean( []     , Ys, Ys ) .
clean( [X|Xs] , Ts, Ys ) :- duplicated(X,Ts), !, clean(Xs,   Ts ,Ys).
clean( [X|Xs] , Ts, Ys ) :-                      clean(Xs,[X|Ts],Ys).

To keep the last, simply change duplicate(X,Ts) to duplicate(X,Xs). The former checks to see if X exists in the accumulator Ts; the latter checks to see if X exists in the tail of the source list (Xs).

回复收藏 0 原文

~没有更多了~