相关疑难解决方法(0)

我参加了一门课程,学习了一些序言.我无法弄清楚如何/何时使用削减.即使我得到了切割的一般概念,我也似乎无法正确使用它们.任何人都可以简单地解释一下,或者给出一个他们可以推荐的"削减"的好教程(那不是learnprolognow.org)吗？

我最近开始学习Prolog,我无法解决如何组合三个列表的问题.

我能够组合2个列表:

%element
element(X,[X|_]).
element(X,[_|Y]):-
               element(X,Y).

%union

union([],M,M).
union([X|Y],L,S) :- element(X,L),union(Y,L,S).
union([X|Y],L,[X|S]) :- (not(element(X,L))),union(Y,L,S).

有人可以帮我吗？

lcs([ H|L1],[ H|L2],[H|Lcs]) :-
    !,
    lcs(L1,L2,Lcs).
lcs([H1|L1],[H2|L2],Lcs):-
    lcs(    L1 ,[H2|L2],Lcs1),
    lcs([H1|L1],    L2 ,Lcs2),
    longest(Lcs1,Lcs2,Lcs),
    !.
lcs(_,_,[]).

longest(L1,L2,Longest) :-
    length(L1,Length1),
    length(L2,Length2),
    (  Length1 > Length2
    -> Longest = L1
    ;  Longest = L2
    ).

到目前为止这是我的代码.我怎样才能优化它以便打印前缀,例如:

["interview", "interrupt", "integrate", "intermediate"]

应该回来 "inte"

Prolog有点生疏,有一段时间没做过:)

我正在尝试构建一个简单的谓词,它将两个列表作为输入,结果是由前两个列表的交集组成的第三个.我决定使用逻辑陈述.我很确定我的逻辑是正确的,但我的谓词不起作用.有任何想法吗？:

element(X,[H|T]) :- 
      X=H
   ;
      element(X,T).

intersection(L1,L2,R) :-
    not((
        element(A,L1),
        not(element(A,L2))
    )),
    not((
        element(A,L1),
        not(element(A,R))
    )).

请不要发布替代方法我想知道为什么每次都返回FALSE.

我想编写一个Prolog程序来查找两个列表的相等性,其中元素的顺序
无关紧要.所以我写了以下内容:

del(_, [], []) .
del(X, [X|T], T).  
del(X, [H|T], [H|T1]) :-
   X \= H,
   del(X, T, T1).

member(X, [X|_]).  
member(X, [_|T]) :- 
   member(X, T).

equal([], []).  
equal([X], [X]).  
equal([H1|T], L2) :-
   member(H1, L2),
   del(H1, L2, L3),
   equal(T, L3).  

但是当我提供输入时equal([1,2,3],X).,它并没有显示所有可能的值X.相反,程序挂在中间.可能是什么原因？

我需要编写一个Prolog谓词take(L, N, L1),如果list L1包含list 的第一个N元素,则以L相同的顺序成功.例如:

?- take([5,1,2,7], 3, L1).
L1 = [5,1,2]
?- take([5,1,2,7], 10, L1).
L1 = [5,1,2,7] 

Prolog到目前为止对我来说没什么意义,而且我很难将其分解.这是我到目前为止:

take([H|T], 0, []).
take([H|T], N, L1) :-
   take(T, X, L2),
   X is N-1.

你能解释一下我在这里做错了吗？

所以我刚刚开始学习Prolog这个学期,并且做了一个基本的工作来实现一个非常基本的d(function, variable, derivative),我这样做:

d(X,X,1) :- !.
d(C,X,0) :- atomic(C). %, (C \= X).
d(X**E,X,E*X**(E-1)).
d(U+V,X,A+B) :- d(U,X,A), d(V,X,B).
d(U-V,X,A-B) :- d(U,X,A), d(V,X,B).
d(U*V,X,DU*V+U*DV) :- d(U,X,DU), d(V,X,DV).
d(U/V,X,(DU*V-U*DV)/(V*V)) :- d(U,X,DU), d(V,X,DV).

我知道这不完整,但它涵盖了练习中所需的所有任务.

但是, ?- d((x*x+2*x+3)/(3*x),x,R). 导致

R = ((1*x+x*1+ (0*x+2*1)+0)* (3*x)- (x*x+2*x+3)* (0*x+3*1))/ (3*x* (3*x)). 这看起来并不漂亮.是/ 2不幸的是不喜欢我的x,因为它不是一个数字...

是否有一个简单的解决方案来实现更清洁的结果？

我把这个解决方案发布到一个问题,但是我留下了评论说:

用于检查"变量"是否空闲或已经绑定的谓词应该改变用于获得其他"变量"的正确统一的策略(即加速,或者可以导出它们).对于动态谓词也是如此 - 它们可以用来加速某些事情,但它们不应该被用作改变某事物行为的触发器.

我想知道为什么会这样.为什么检查是否已将某些内容定义为其他内容是不好的做法？你认为这是不好的做法吗？还有其他选择可以"更好地练习".

这是我的解决方案:

% ================================
% Ensures that all variables are unique.  
% ================================

% Base case: Assigned variables unique values
used([], Nin, Nin).

% Have already assigned a value to this variable
used([A|B], Nin, Nout) :-
        integer(A), % <----------------- THIS IS THE LINE IN QUESTION
        helper(B,Nin,Nout).

% Have not assigned a value to this variable yet
% Assign it and remove it from the list.  
used( [A|B] , Nin, Nout) :-
        member(A,Nin), …

考虑以下Prolog程序:

transform([], []).
transform([X | Xs],[Y | Ys]):-
    isSpecial(X),
    isSpecial(Y),
    transformSpecial(X,Y),
    transform(Xs,Ys).
transform([X | Xs],[ X | Ys]):-
    transform(Xs,Ys).

isSpecial(foo).
isSpecial(bar).
isSpecial(foobar).

transformSpecial(X,Y):-
    isSpecial(X),
    isSpecial(Y),
    not(X = Y).

有些情况下我会打电话tranform([foo, 1, 2], X)和我想打电话的情况transform(X, [foo, 1, 2]).

在这两种情况下,我都希望X与之[bar, 1, 2]结合[foobar, 1, 2],但不与之结合[foo, 1, 2].也就是说,我希望一旦谓词正确识别出第二个子句适用,它就应该只使用第二个子句来回溯.

我应该在哪里插入切口以实现此行为？

我有一个元素列表,其中包含一个人的朋友数量.

[friends(mike, 4), friends(joe, 3), friends(mike, 1), friends(mike, 2)]

我想压缩此列表并获取以下内容

[friends(mike, 7), friend(joe, 3)]

我创建了成员,并删除了第一个外观.

member(E, [E|_]).
member(E, [_|Y]) :- 
    member(E, Y).

delete_first([], _, []).
delete_first([X|Y], X, Y).
delete_first([X|Y], E, [X|L]) :- 
    X \= E, 
    delete_first(Y, E, L).

compress([], []).
compress([friends(P, C)|R], S) :- 
    member(friends(P, X), R), 
    delete_first(R, friends(P, X), E), 
    N is C + X, 
    compress([friends(P, N)|E], S).
compress([friends(P, C)|R], [friends(P, C)|S]) :- 
    not(member(friends(P, _), R)), 
    compress(R, S).

我的答案是正确的,但Prolog会多次回答相同的答案.为什么会这样？

例:

?- compress([friends(mike, 4), friends(joe, 3), friends(mike, 1), 
             friends(mike, 2), …

1. 编写一个谓词,allDistinct/1其参数是符号列表,如果列表中的所有符号都不同,则成功.

   notin(A,[]).
   notin(A,[B|C]) :-
      A\=B,
      notin(A,C).
   
   allDistinct([]).
   allDistinct([_]).
   allDistinct([A|B]) :-
      notin(A,B), 
      allDistinct(B).
   

   Run Code Online (Sandbox Code Playgroud)