在Prolog中展平列表

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了在Prolog中展平列表相关的知识,希望对你有一定的参考价值。

我只与Prolog合作了几天。我理解一些事情,但这真让我感到困惑。

我想要编写一个带有列表并将其展平的函数。

?- flatten([a,[b,c],[[d],[],[e]]],Xs).  
Xs = [a,b,c,d,e].                           % expected result

该函数取出列表的内部结构。

这是我到目前为止:

flatten2([],[]).
flatten2([Atom|ListTail],[Atom|RetList]) :-
      atom(Atom), flatten2(ListTail,RetList).
flatten2([List|ListTail],RetList) :-
      flatten2(List,RetList).

现在,这在我打电话时起作用:

?- flatten2([a,[b,c],[[d],[],[e]]], R).
R = [a,b,c,d,e].                         % works as expected!

但是当我打电话来查看我输入的列表是否已被展平时,返回false而不是true

?- flatten2([a,[b,c],[[d],[],[e]]], [a,b,c,d,e]).
false.                                   % BAD result!

为什么一方面工作,另一方面又不工作?我觉得我错过了很简单的事情。

答案

你给出的flatten2/2的定义被破坏了;它实际上表现得像这样:

?- flatten2([a, [b,c], [[d],[],[e]]], R).
R = [a, b, c] ;
false. 

所以,鉴于你已经将R绑定到[a,b,c,d,e]的情况,失败并不令人惊讶。

你的定义是抛弃第3个子句中的列表尾部(ListTail) - 这需要整理并连接回列表以通过RetList返回。这是一个建议:

flatten2([], []) :- !.
flatten2([L|Ls], FlatL) :-
    !,
    flatten2(L, NewL),
    flatten2(Ls, NewLs),
    append(NewL, NewLs, FlatL).
flatten2(L, [L]).

这个递归地将所有列表列表减少到单个项目列表[x],或者将它丢弃的空列表[]。然后,它累积并将它们全部附加到输出中的一个列表中。

请注意,在大多数Prolog实现中,空列表[]是一个原子和一个列表,因此对atom([])is_list([])的调用都评估为true;这不会帮助你抛弃空列表而不是字符原子。

另一答案

您可以使用指向其开头的指针和结尾处的“结束孔/自由指针”(即logvar)来保持列表的开放性,然后您可以在到达结束时实例化它:

flatten2( [], Z, Z):- !.                                        % ---> X
flatten2( [Atom|ListTail], [Atom|X], Z) :-                      %      .
    +is_list(Atom), !,                                         %      .
    flatten2( ListTail, X, Z).                                  %      Y
flatten2( [List|ListTail], X, Z) :-                             %      .
    flatten2( List,     X, Y),       % from X to Y, and then    %      .
    flatten2( ListTail, Y, Z).       % from Y to Z              %      Z --->

然后你把它称为

flatten2( A, B):- flatten2( A, B, []).

这样就没有必要在任何地方使用reverse。这种技术被称为“差异列表”,但将其视为“开放式列表”则更容易。


更新:使用语法更容易编码。由于它是单向的(第一个参数必须完全接地),为什么不使用切割:

flattn([]) --> [], !.
flattn([A|T]) --> {+is_list(A)}, [A], !, flattn(T).
flattn([A|T]) --> flattn(A), flattn(T).

测试:

16 ?- phrase(flattn([a,[b,c],[[d],[],[e]]]), [a, b, c, d, e]).
true.

17 ?- phrase(flattn([a,[b,c],[[d],[],[e]]]), R).
R = [a, b, c, d, e].

18 ?- phrase(flattn([a,[b,X],[[d],[],[e]]]), [a, b, c, d, e]).
X = c.

如果定义完全是声明性的,那么最后一个也应该用X=[c] ; X=[[],c] ; ... ; X=[[c]] ; ...成功;唉,事实并非如此。

(编辑2:简化了两个版本,感谢@ mat的评论!)

另一答案

Prolog的列表符号是非常简单的prolog术语之上的语法糖。 Prolog列表如下表示​​:

  1. 空列表由原子[]表示。为什么?因为这看起来像空列表的数学符号。他们可以使用像nil这样的原子来表示空列表,但他们没有。
  2. 非空列表由术语.2表示,其中第一个(最左边)参数是列表的头部,第二个(最右边)参数是列表的尾部,递归地,它本身是一个列表。

一些例子:

  • 一个空列表:[]表示为原子: []
  • 一个元素的列表,[a]在内部存储为 .(a,[])
  • [a,b]这两个元素的列表在内部存储为 .(a,.(b,[]))
  • [a,b,c]是三个元素的列表,内部存储为 .(a,.(b,.(c,[])))

检查列表的头部也是同样的符号的语法糖:

  • [X|Xs].(X,Xs)相同
  • [A,B|Xs].(A,.(B,Xs))相同
  • [A,B](见上文)与.(A,.(B,[]))相同

我自己,我会像这样写flatten/2

%------------------------
% public : flatten a list
%------------------------
flatten( X , R ) :-
  flatten( X , [] , T ) ,
  reverse( T , R )
  .

%--------------------------------------------
% private : flatten a list into reverse order
%--------------------------------------------
flatten( [] , R , R ) .        % the empty list signals the end of recursion
flatten( [X|Xs] , T , R ) :-   % anything else is flattened by
  flatten_head( X , T , T1 ) , % - flattening the head, and
  flatten( Xs , T1 , R )       % - flattening the tail
  .                            %

%-------------------------------------
% private : flatten the head of a list
%-------------------------------------
flatten_head( X , T , [X|T] ) :- % if the head is a not a list
  + list(X) ,                   % - simply prepend it to the accumulator.
  ! .                            %
flatten_head( X , T , R     ) :- % if the head is a list
  flatten( X , T , R )           % - recurse down and flatten it.
  .

%-----------------------
% what's a list, anyway?
%-----------------------
list( X ) :- var(X) , ! , fail .
list( []    ) .
list( [_|_] ) .
另一答案

if_//3list_truth/2的基础上,我们可以实现myflatten/2如下:

myflatten(Xs,Ys) :-
   phrase(myflatten_aux(Xs),Ys).

myflatten_aux([]) --> [].
myflatten_aux([T|Ts]) --> 
   if_(neither_nil_nor_cons_t(T), [T], myflatten_aux(T)),
   myflatten_aux(Ts).

:- use_module(library(dialect/sicstus/block)).

:- block neither_nil_nor_cons(-).
neither_nil_nor_cons(X) :-
   +nil_or_cons(X).

nil_or_cons([]).
nil_or_cons([_|_]).

neither_nil_nor_cons_t(X,Truth) :-
   (  nonvar(X)
   -> (  neither_nil_nor_cons(X) -> Truth = true
      ;                             Truth = false
      )
   ;  nonvar(Truth) 
   -> (  Truth == true -> neither_nil_nor_cons(X)
      ;  Truth == false,  nil_or_cons(X)
      )
   ;  Truth = true,  neither_nil_nor_cons(X)
   ;  Truth = false, nil_or_cons(X)
   ).

示例查询(取自其他答案,以及对答案的评论):

?- myflatten([[4],[[5,6],[7,[8],[9,[10,11]]]]], Xs).
Xs = [4, 5, 6, 7, 8, 9, 10, 11].

?- myflatten([1,[8,3],[3,[5,6],2],8], Xs).
Xs = [1, 8, 3, 3, 5, 6, 2, 8].

?- myflatten([a,[b,c],[],[[[d]]]], Xs).
Xs = [a, b, c, d].

?- myflatten([a,[b,c],[[d],[],[e]]], Xs).
Xs = [a, b, c, d, e].

neither_nil_nor_cons_tnot(nil_or_cons_t)描述有相同的解决方案,但解决方案顺序不同。考虑:

?- myflatten([A,B,C],Xs), A=a,B=b,C=c.
A = a,
B = b,
C = c,
Xs = [a, b, c] ;                       % does not terminate universally
另一答案

这是一个基于累加器的完整性版本:

% flatten/2
flatten(List, Result) :- flatten(List, [], Result).

% auxiliary predicate flatten/3
flatten([], Result, Result).
flatten([Head| Tail], Part, Result) :- 
    is_list(Head),
    !, 
    flatten(Head, HR),
    append(Part, HR, PR),
    flatten(Tail, PR, Result).
flatten([Head| Tail], Part, Result) :- 
    append(Part, [Head], PR),
    flatten(Tail, PR, Result).
flatten(X, Part, Result) :-
    fail.
另一答案

我没有找到使用findall的解决方案,所以我将添加它。 (如果列表是地面,它将起作用)

首先,我们定义如何测试列表:

list(X) :- var(X), !, fail.
list([]).
list([_|_]).

transitive closuremember,我们称之为member*

'member*'(X, Y) :- member(X, Y).
'member*'(X, Y) :- member(Z, Y), 'member*'(X, Z).

扁平列表是member*的所有解决方案,它们不是列表:

flatten(X, Y) :- findall(Z, ('member*'(Z, X), + list(Z)), Y).

例:

?- flatten([[4],[[5,6],[7,[8],[9,[10,11]]]]],Y).
Y = [4, 5, 6, 7, 8, 9, 10, 11].
另一答案

没有任何其他谓词,只有尾递归。

flatten([[X|S]|T], F) :- flatten([X|[S|T]], F).
flatten([[]|S], F) :- flatten(S, F).
flatten([X|S], [X|T]) :- +(X = []), +(X = [_|_]), flatten(S, T).
flatten([], []).

以上是关于在Prolog中展平列表的主要内容,如果未能解决你的问题,请参考以下文章

如何在 Kotlin 中展平列表列表?

python 在Python中展平列表。 #蟒蛇

python 在Python中展平列表列表

Prolog中的展平列表[重复]

我们如何在不使用 recyclerview 的情况下创建水平列表视图?

在垂直列表视图中添加水平列表视图时不正确使用 ParentDataWidget