Question

我有一个列表，其开头有一个未知数量的零，例如[0,0,0,1,2,0,3]。我需要将这个列表去掉前导零，以便它看起来像[1,2,0,3]。

以下是我所拥有的：

lead([Head | _], _) :- Head =\= 0.
lead([0 | Tail], _) :- 
  lead(Tail, Tail).

其输出只是True。读取跟踪显示它正在运行，直到它有一个没有前导零的列表，但是答案不会传播回堆栈。我对Prolog很新，所以我无法弄清楚如何做到这一点。

Answer 1

这是一个适用于所有方向的解决方案：

lead([],[]).
lead([H|T],[H|T]) :-
    dif(H,0).
lead([0|T],T2) :-
    lead(T,T2).

一些疑问：

?- lead([0,0,0,1,2,0,3], L).
L = [1, 2, 0, 3] ;
false.


?- lead(L, []).
L = [] ;
L = [0] ;
L = [0, 0] ;
L = [0, 0, 0] ;
...


?- lead(L0, L).
L0 = L, L = [] ;
L0 = L, L = [_G489|_G490],
dif(_G489, 0) ;
L0 = [0],
L = [] ;
L0 = [0, _G495|_G496],
L = [_G495|_G496],
dif(_G495, 0) ;
L0 = [0, 0],
L = [] ;
L0 = [0, 0, _G501|_G502],
L = [_G501|_G502],
dif(_G501, 0) ;
L0 = [0, 0, 0],
L = [] ;
...

编辑此谓词实际上不适用于例如lead(L0, [0,1,2])。

Answer 2

使用library(reif)：

:- use_module(reif).

remove_leading_zeros([], []).
remove_leading_zeros([H|T], Rest) :-
        if_(    H = 0,
                remove_leading_zeros(T, Rest),
                Rest = [H|T]).

然后：

?- remove_leading_zeros([0,0,0,1,2,0,3], R).
R = [1, 2, 0, 3].

?- remove_leading_zeros([2,0,3], R).
R = [2, 0, 3].

?- remove_leading_zeros(L, R).
L = R, R = [] ;
L = [0],
R = [] ;
L = [0, 0],
R = [] ;
L = [0, 0, 0],
R = [] . % and so on

Answer 3

这是一个不产生任何选择点的解决方案。它的使用freeze / 2，以dif / 2预期的方式。但是使用冻结/ 2在这里是非常合适的，因为一个经验法则是冻结/ 2 如下：

冻结/ 2的经验法则：使用谓词所在的冻结/ 2 生成未实例化的解决方案和许多选择点。希望是后续目标将更多地指定解决方案，并且冻结/ 2将被唤醒。不幸的是不适用于CLP（FD）或 dif / 2，因为冻结/ 2不会对CLP（FD）暗示的细化作出反应或者是dif / 2，只有统一才能唤醒它。

因此代码是：

lead(X, Y) :- var(X), !, freeze(X, lead(X,Y)).
lead([X|Y], Z) :- var(X), !, freeze(X, lead([X|Y],Z)).
lead([0|X], Y) :- !, lead(X, Y).
lead(X, X).

以下是一些示例运行（SWI-Prolog没有导入，Jekejeke Prolog使用Minlog Extension和？ - use_module（库（term / suspend）））：

?- lead([0,0,0,1,2,3], X).
X = [1, 2, 3].

?- lead([0,0|X], Y).
freeze(X, lead(X, Y)).

?- lead([0,0|X], Y), X = [0,1,2,3].
X = [0, 1, 2, 3],
Y = [1, 2, 3].

?- lead([Z,0|X], Y), X = [0,1,2,3].
X = [0, 1, 2, 3],
freeze(Z, lead([Z, 0, 0, 1, 2, 3], Y)).

?- lead([Z,0|X], Y), X = [0,1,2,3], Z = 0.
Z = 0,
X = [0, 1, 2, 3],
Y = [1, 2, 3].

在上面的lead / 2实现中，只处理第一个参数。要同时处理多个参数，可以使用/ 2时的谓词。但为简单起见，此处未显示。

同样在使用暂停目标时，最终可能需要像谓词这样的标签，因为暂停的目标无法检测到它们之间的不一致。

Answer 4

这是一个实际适用于所有可能输入的解决方案，并且不会留下不必要的选择点：

lead(L0, L) :-
    (   nonvar(L),
        L = [H|_] ->
        dif(H,0)
        ;
        true
    ),
    lead_(L0, L).

lead_([], []).
lead_([H|T], L) :-
    if_(H \= 0,
        L = [H|T],
        lead_(T,L)).

nonvar(L)的初步检查是我能够提出的唯一可以解决问题的解决方案。 lead(L0, [0,1,2,3])，同时在所有其他情况下保留谓词的行为。

这使用if_/3，library(reif)

的一部分

if_(If_1, Then_0, Else_0) :-
    call(If_1, T),
    (  T == true -> Then_0
    ;  T == false -> Else_0
    ;  nonvar(T) -> throw(error(type_error(boolean,T),
                                type_error(call(If_1,T),2,boolean,T)))
    ;  throw(error(instantiation_error,instantiation_error(call(If_1,T),2)))
    ).

这也使用了(\=)/3，我在(=)/3中通过简单修改library(reif)来提出这一点。

\=(X, Y, T) :-
    (   X \= Y -> T = true
    ;   X == Y -> T = false
    ;   T = true, dif(X, Y)
    ;   T = false,
        X = Y
    ).

一些查询

?- lead([0,0,0,1,2,0,3],L).              % No choice point
L = [1, 2, 0, 3].


?- lead([1,2,0,3],L).
L = [1, 2, 0, 3].


?- lead([0,0,0,0],L).
L = [].


?- lead([],L).
L = [].


?- lead(L0,[0,1,2,0,3]).                 % Correctly fails
false.


?- lead(L0,[1,2,0,3]).
L0 = [1, 2, 0, 3] ;
L0 = [0, 1, 2, 0, 3] ;
L0 = [0, 0, 1, 2, 0, 3] ;
…


?- lead(L0,L).                           % Exhaustively enumerates all cases:  
L0 = L, L = [] ;                         %   - LO empty
L0 = L, L = [_G2611|_G2612],             %   - L0 contains no leading 0
dif(_G2611, 0) ;
L0 = [0],                                %   - L0 = [0]
L = [] ;
L0 = [0, _G2629|_G2630],                 %   - L0 contains one leading 0
L = [_G2629|_G2630],
dif(_G2629, 0) ;
L0 = [0, 0],                             %   - L0 = [0, 0]
L = [] ;
L0 = [0, 0, _G2647|_G2648],              %   - L0 contains two leading 0s
L = [_G2647|_G2648],
dif(_G2647, 0) ;
…                                        %   etc.

Answer 5

代码中的问题是第二个参数（输出）被指定为_，因此您的谓词对于任何输出都是正确的。你想要的是一个谓词，当且仅当它是输入减去前导零时才是真的。

lead([], []).
lead([0 | Tail], Tail2) :- !, lead(Tail, Tail2).
lead([Head | Tail], [Head | Tail]) :- Head =\= 0.

第一行中的!是可选的。它修剪搜索树，因此如果第一行匹配，Prolog不会考虑第二行（这会失败）。

Answer 6

这是我怎么说的。首先，建立约束：X或Y必须绑定到列表。其他任何事情都失败了。

如果绑定X，我们不关心Y：它可以绑定或不绑定。我们只是从X中去掉任何前导零，并用Y统一结果。这条路径有一个可能的解决方案。
如果X未绑定且Y绑定，我们将转入生成模式。这条路径有无数可能的解决方案。

代码：

strip_leading_zeros(X,Y) :- listish(X), !, rmv0( X , Y ) .
strip_leading_zeros(X,Y) :- listish(Y), !, add0( Y , X ) .

rmv0( []     , [] ) .
rmv0( [D|Ds] , R  ) :- D \= 0 -> R = [D|Ds] ; rmv0(Ds,R) .

add0( X , X ) .
add0( X , Y ) :- add0([0|X],Y ) .

listish/1是一个简单的浅层测试。如果你想对事情嗤之以鼻，请使用is_list/1。

listish( L     ) :- var(L), !, fail.
listish( []    ) .
listish( [_|_] ) .

编辑注意：is_list/1遍历整个列表以确保它正在测试是一个正确构建的列表，即./2术语，其右侧child本身是另一个./2项或原子[]（表示空列表）。如果列表很长，这可能是一项昂贵的操作。

因此，类似[a,b,c]的内容是一个正确的列表，实际上就是这个术语：.(a,.(b,.(c,[])))。 [a,b|32]之类的内容不是正确的列表：它是术语.(a,.(b,32))。

删除Prolog中列表中的前导零

6 个答案:

一些查询