友好列表序言

Question

I am given 2 lists for example K=[a,b,c,d,e,f,g] and L=[a,b,1,d,e,2,g] . When these 2 lists have 2 different elements, then they are friendly.

This is what I've tried:

friendly(K,L):-
    append(L1,[Z],A1),
    append(A1,L2,A2),
    append(A2,[Q],A3),
    append(A3,L3,K),
    append(L1,[Y],B1),
    append(B1,L2,B2),
    append(B2,[W],B3),
    append(B3,L3,L),
    Z\=Y,
    Q\=W.

Thank you all so much, at last I found the correct code:

friend(L1,L2):-
append(A,Y,L1),
append([Z|T],[F|TT],Y),
append(A,Q,L2),
append([R|T],[O|TT],Q),
Z\=R,
F\=O.

Answer 1

Wouldn't it be better to do something like the following?

diff([], [], []).
diff([], K, K).
diff(L, [], L).
diff([H | TL], [H | TK], D) :- diff(TL, TK, D),!.
diff([HL | TL], [HK | TK], [HL, HK | D]) :- diff(TL, TK, D),!.

friendly(K, L) :- diff(K, L, D), length(D, Length), Length < 3.

But your problem really is underspecified. For example my program really cares about order so [a,x,b] and [a,b] are not friendly by my definition.

Answer 2

You can use append/3 in this way to locate the first different elements.

first_different(L1,L2, R1,R2) :-
  append(H, [E1|R1], L1),
  append(H, [E2|R2], L2),
  E1 \= E2.

H is the common part, R1,R2 are the 'remainders'. This code is more in line with your second comment above.

Now you must apply two times this helper predicate, and the second time also 'remainders' must be equal, or one of them must be empty. That is

friendly(L1,L2) :-
  first_different(L1,L2,R1,R2),
  first_different(R1,R2,T1,T2),
  once((T1=T2;T1=[];T2=[])).

Alternatively, using some builtin can be rewarding. This should work

friendly(L1,L2) :- findall(_,(nth1(I,L1,E1),nth1(I,L2,E2),E1\=E2),[_,_]).

Answer 3

I'm still a little uncertain about the total definition of "friendly" list, but I think this might answer it:

friendly(A, B) :-
    friendly(A, B, 2).
friendly([H|TA], [H|TB], C) :-
    C > 0,
    friendly(TA, TB, C).
friendly([HA|TA], [HB|TB], C) :-
    HA \= HB,
    C > 0,
    C1 is C-1,
    friendly(TA, TB, C1).
friendly(A, [], C) :-
    length(A, L),
    L =< C.
friendly([], B, C) :-
    length(B, L),
    L =< C.
friendly(A, A, 0).

I'm assuming that the definition of friendly means the lists are in "lock step" outside of the maximum of two differences.

Answer 4

Does order matter? Are the lists sets (each element is unique) or bags (duplicates allowed)?

Assuming that

• Order doesn't matter ([1,2,3] and [1,3,2]) are treated as identical), and
• Duplicates don't matter ([1,2,3,1] and [1,2,3]) are treated as identical

Something like this might be along the lines of what you're looking for:

friendly(Xs,Ys) :-
  set_of(
    E ,
    (
      (      member(E,Xs)   ,
        not( member(E,Ys) )
      )
    ;
      (
             member(E,Ys)   ,
        not( member(E,Xs) )
    ) ,
    Zs
    ) ,
    length( Zs , L ) ,
    L =< 2
    .

Find the set of all elements of each list that aren't in the other and succeed if the resulting list is of length 0, 1 or 2.

Answer 5

I came up with something similar to others.. I just keep a list of '_' items (final param of diff_list) - one for each difference, be that a value difference at the same index, or a difference in the length, then finally in friendly/2, check that has 2 items.

% recursion base
diff_list([], [], []).

% the head of both lists are the same, don't add to diff list
diff_list([HK|TK], [HK|TL], Diff) :-
    diff_list(TK, TL, Diff).

% the above rule failed, so must be a difference, add a '_'
diff_list([_|TK], [_|TL], [_|Diff]) :-
    diff_list(TK, TL, Diff).

% 1st list is empty, but the 2nd isn't. That's a diff again.
diff_list([], [_|TL], [_|Diff]) :-
     diff_list([], TL, Diff).

% 2nd list is empty, but the 1st isn't. Another diff.
diff_list([_|TK], [], [_|Diff]) :-
     diff_list(TK, [], Diff).

% friendly is true if the diff list length unifies with 2 item length list [_,_]
friendly(K, L) :-
     diff_list(K, L, [_,_]).