blocks|key|1873306|text|正如@SQB所指出的，由于否定而缺乏回溯实际上并不是您的代码的唯一问题。如果你稍微尝试一下地面查询，你会发现非列表和@false指出的空列表也不是唯一的问题。考虑以下查询：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1873307|+++?-+intersection([2,3],[1,2,3],[2,3,4]).
yes
+++?-+intersection([2],[1,2,3],[2,3,4]).
yes
+++?-+intersection([3],[1,2,3],[2,3,4]).
yes
+++?-+intersection([],[1,2,3],[2,3,4]).
yes|code-block|syntax|javascript|1873308|第一个通常被理解为交集。其他三个都是交集的子列表，包括平凡的子列表[]。这是由于谓词描述交集的方式:在交集中，不是元素在第一个列表中而不是第二个列表中，并且所述元素在第一个列表中而不是第三个列表中。这一描述显然符合上述三个查询，因此它们成功了。考虑到这个描述，还有一些其他值得注意的地面查询成功了：|offset|length|style|CODE|1873309|+++?-+intersection([2,2,3],[1,2,3],[2,3,4]).
yes|1873310|解决方案中存在重复项是否可以接受的问题，实际上是一个相当有争议的问题。列表[2,2,3]和[2,3]虽然不同，但表示相同的集合{2,3}。有一个关于Prolog联合的问题的this+recent+answer，它详细阐述了答案的这些方面。当然，上面提到的交叉点的子列表也可以包含重复项或多个项：|1873311|+++?-+intersection([2,2,2],[1,2,3],[2,3,4]).
yes|1873312|但是为什么会这样呢？对于空列表，这是很容易看到的。查询|1873313|+++?-+element(A,[]).
no|1873314|失败，因此L1=[]的联合element(A,L1),+not(element(A,L2))也会失败。因此，围绕它的否定是成功的。对于第二个否定也是如此，因此可以将[]导出为交集。要了解[2]和[3]作为交集成功的原因，将谓词写成逻辑公式并显式地写下通用量词是很有帮助的：|1873315|∀L1∀L2∀R∀A+(intersection(L1,L2,R)+element(A,R)))、∀L1∀L2∀R∀A∧、element(A,R)))←、∧∧、#en0#∧|1873316|如果您查阅逻辑或逻辑编程的教科书，其中也将Prolog代码显示为逻辑公式，您会发现，没有出现在规则头部的变量的通用量词可以作为存在量词移动到正文中。在本例中，对于A|1873317|∀L1∀L2∀R+(intersection(L1,L2,R)+A+(，(element(A,L1)+element(A,L2))，(element(A,L1)+element(A,R))))，←∃∧，(element(A,L1)∧，element(A,R))))←∃∧，(element(A,L1)，←∃∧，(element(A,L1)，∃|1873318|因此，对于所有的论点，L1,L2,R都有一些A可以满足这些目标。这解释了交叉点的子列表的导出和元素的多次出现。|1873319|然而，更令人讨厌的是查询|1873320|+++?-+intersection(L1,[1,2,3],[2,3,4]).|1873321|循环，而不是产生解决方案。如果您认为L1未实例化，请查看以下查询的结果|1873322|+++?-+element(A,L1).
L1+=+[A%7C_A]+?+;
L1+=+[_A,A%7C_B]+?+;
L1+=+[_A,_B,A%7C_C]+?+;
...|1873323|很明显，查询|1873324|+++?-+element(A,L1),not(element(A,[1,2,3])).|1873325|由于包含第一个目标所描述的A的无限多个列表L1，所以必须循环。因此，谓词中相应的连接词也必须循环。此外，为了产生结果，如果这样的谓词反映了Prolog的关系性质，并以另一种方式工作(第二个或第三个参数变量)，那就更好了。让我们将您的代码与这样的解决方案进行比较。(为了便于比较，下面的谓词描述交叉点的子列表，就像您的代码所做的那样，对于不同的定义，请参见下面的进一步定义。)|1873326|为了反映其声明性质，让我们将其命名为list_list_intersection/3：|1873327|list_list_intersection(_,_,[]).
list_list_intersection(L1,L2,[A%7CAs])+:-
+++list_element_removed(L1,A,L1noA),
+++list_element_removed(L2,A,L2noA),
+++list_list_intersection(L1noA,L2noA,As).

list_element_removed([X%7CXs],X,Xs).
list_element_removed([X%7CXs],Y,[X%7CYs])+:-
+++dif(X,Y),
+++list_element_removed(Xs,Y,Ys).|1873328|与您的谓词一样，此版本也使用交集的元素来描述关系。因此，它生成相同的子列表(包括[])：|1873329|+++?-+list_list_intersection([1,2,3],[2,3,4],I).
I+=+[]+?+;
I+=+[2]+?+;
I+=+[2,3]+?+;
I+=+[3]+?+;
I+=+[3,2]+?+;
no|1873330|但是没有循环。但是，不再生成多个匹配项，因为list_element_+removed+/3删除了已经匹配的元素。但是，第一个列表中的多个匹配项都正确匹配：|1873331|+++?-+list_list_intersection([1,2,2,3],[2,2,3,4],[2,2,3]).
yes|1873332|这个谓词也适用于其他方向：|1873333|+++?-+list_list_intersection([1,2,3],L,[2,3]).
L+=+[2,3%7C_A]+?+;
L+=+[2,_A,3%7C_B],
dif(_A,3)+?+;
L+=+[2,_A,_B,3%7C_C],
dif(_A,3),
dif(_B,3)+?+;
...

+++?-+list_list_intersection(L,[2,3,4],[2,3]).
L+=+[2,3%7C_A]+?+;
L+=+[2,_A,3%7C_B],
dif(_A,3)+?+;
L+=+[2,_A,_B,3%7C_C],
dif(_A,3),
dif(_B,3)+?+;
...|1873334|所以这个版本对应于你的代码，没有重复的代码。注意交叉点的元素A如何显式地出现在规则的头部，其中交叉点的所有元素都是递归遍历的。我相信这就是您试图通过在Prolog规则前面使用隐含的通用量词来实现的。|1873335|回到我答案开头的一点，这不是通常被理解为交叉点的地方。在为参数[1,2,3]和[2,3,4]描述的所有结果list_list_+intersection+/3中，只有[2,3]是交集。代码的另一个问题出现了:如果使用交叉点的元素来描述关系，如何确保覆盖所有相交的元素？毕竟，[2]的所有元素都出现在[1,2,3]和[2,3,4]中。一个显而易见的想法是遍历其他列表中的一个元素，并将出现在这两个列表中的元素描述为也在交叉点中。下面是一个使用if_/3和memberd_t/3的变体|1873336|list_list_intersection([],_L2,[]).
list_list_intersection([X%7CXs],L2,I)+:-
+++if_(memberd_t(X,L2),
+++++++(I=[X%7CIs],list_element_removed(L2,X,L2noX)),
+++++++(I=Is,L2noX=L2)),
+++list_list_intersection(Xs,L2noX,Is).|1873337|注意，也可以遍历第二个列表的参数，而不是第一个列表的参数。谓词memberd_t/3是谓词元素/2的具体化变体，在描述中再次使用list_element_removed/3，以避免解决方案中的重复。现在解决方案是独一无二的|1873338|+++?-+list_list_intersection([1,2,3],[2,3,4],L).
L+=+[2,3]+?+;
no|1873339|并且上面的“问题查询”如预期的那样失败：|1873340|+++?-+list_list_intersection([1,2,3],[2,3,4],[]).
no
+++?-+list_list_intersection([1,2,3],[2,3,4],[2]).
no
+++?-+list_list_intersection([1,2,3],[2,3,4],[3]).
no
+++?-+list_list_intersection([1,2,3],[2,3,4],[2,2,3]).
no
+++?-+list_list_intersection([1,2,3],[2,3,4],[2,2,2]).
no|1873341|当然，您也可以在其他方向上使用谓词：|1873342|+++?-+list_list_intersection([1,2,3],L,[2,3]).
L+=+[2,3]+?+;
L+=+[3,2]+?+;
L+=+[2,3,_A],
dif(_A,1)+?+;
...

+++?-+list_list_intersection(L,[2,3,4],[2,3]).
L+=+[2,3]+?+;
L+=+[2,3,_A],
dif(4,_A)+?+;
...|1873343|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/36824211/6101159|1|https://stackoverflow.com/a/27358600/6101159|2|3^0|0|0|X|2|0|0|11|7|19|5|2E|I|0|0|0|0|0|5|5|D|X|2A|2|2L|3|2P|3|0|1|2|4|2|7|1|9|1|B|M|Y|E|1E|2|1H|2|1K|1|1M|1|1P|E|0|29|1|0|1|2|4|2|7|1|9|M|W|3|10|E|1F|E|1U|E|29|F|2T|E|39|F|3S|E|4B|E|0|B|7|M|1|0|0|0|I|2|0|0|0|0|D|1|L|2|0|0|0|14|2|0|0|0|0|0|0|U|1|0|V|7|13|7|2B|5|3T|3|45|7|4D|7|64|5|1|6A|B|2|0|0|V|B|3|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|2V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|2W|8|@$I|2X|J|2Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|2Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|30|8|@$I|31|J|32|K|L]|$I|33|J|34|K|L]]|9|@$I|35|J|36|1|37]]|A|$]]|$1|Q|3|R|5|D|7|38|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|39|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|3A|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|3B|8|@$I|3C|J|3D|K|L]|$I|3E|J|3F|K|L]|$I|3G|J|3H|K|L]|$I|3I|J|3J|K|L]|$I|3K|J|3L|K|L]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|3M|8|@$I|3N|J|3O|K|L]|$I|3P|J|3Q|K|L]|$I|3R|J|3S|K|L]|$I|3T|J|3U|K|L]|$I|3V|J|3W|K|L]|$I|3X|J|3Y|K|L]|$I|3Z|J|40|K|L]|$I|41|J|42|K|L]|$I|43|J|44|K|L]|$I|45|J|46|K|L]|$I|47|J|48|K|L]]|9|@]|A|$]]|$1|10|3|11|5|6|7|49|8|@$I|4A|J|4B|K|L]]|9|@]|A|$]]|$1|12|3|13|5|6|7|4C|8|@$I|4D|J|4E|K|L]|$I|4F|J|4G|K|L]|$I|4H|J|4I|K|L]|$I|4J|J|4K|K|L]|$I|4L|J|4M|K|L]|$I|4N|J|4O|K|L]|$I|4P|J|4Q|K|L]|$I|4R|J|4S|K|L]|$I|4T|J|4U|K|L]|$I|4V|J|4W|K|L]|$I|4X|J|4Y|K|L]|$I|4Z|J|50|K|L]|$I|51|J|52|K|L]]|9|@]|A|$]]|$1|14|3|15|5|6|7|53|8|@$I|54|J|55|K|L]|$I|56|J|57|K|L]]|9|@]|A|$]]|$1|16|3|17|5|6|7|58|8|@]|9|@]|A|$]]|$1|18|3|19|5|D|7|59|8|@]|9|@]|A|$E|F]]|$1|1A|3|1B|5|6|7|5A|8|@$I|5B|J|5C|K|L]]|9|@]|A|$]]|$1|1C|3|1D|5|D|7|5D|8|@]|9|@]|A|$E|F]]|$1|1E|3|1F|5|6|7|5E|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|D|7|5F|8|@]|9|@]|A|$E|F]]|$1|1I|3|1J|5|6|7|5G|8|@$I|5H|J|5I|K|L]|$I|5J|J|5K|K|L]]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|5L|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|D|7|5M|8|@]|9|@]|A|$E|F]]|$1|1O|3|1P|5|6|7|5N|8|@$I|5O|J|5P|K|L]]|9|@]|A|$]]|$1|1Q|3|1R|5|D|7|5Q|8|@]|9|@]|A|$E|F]]|$1|1S|3|1T|5|6|7|5R|8|@]|9|@]|A|$]]|$1|1U|3|1V|5|D|7|5S|8|@]|9|@]|A|$E|F]]|$1|1W|3|1X|5|6|7|5T|8|@]|9|@]|A|$]]|$1|1Y|3|1Z|5|D|7|5U|8|@]|9|@]|A|$E|F]]|$1|20|3|21|5|6|7|5V|8|@$I|5W|J|5X|K|L]]|9|@]|A|$]]|$1|22|3|23|5|6|7|5Y|8|@$I|5Z|J|60|K|L]|$I|61|J|62|K|L]|$I|63|J|64|K|L]|$I|65|J|66|K|L]|$I|67|J|68|K|L]|$I|69|J|6A|K|L]]|9|@$I|6B|J|6C|1|6D]|$I|6E|J|6F|1|6G]]|A|$]]|$1|24|3|25|5|D|7|6H|8|@]|9|@]|A|$E|F]]|$1|26|3|27|5|6|7|6I|8|@]|9|@$I|6J|J|6K|1|6L]]|A|$]]|$1|28|3|29|5|D|7|6M|8|@]|9|@]|A|$E|F]]|$1|2A|3|2B|5|6|7|6N|8|@]|9|@]|A|$]]|$1|2C|3|2D|5|D|7|6O|8|@]|9|@]|A|$E|F]]|$1|2E|3|2F|5|6|7|6P|8|@]|9|@]|A|$]]|$1|2G|3|2H|5|D|7|6Q|8|@]|9|@]|A|$E|F]]|$1|2I|3|-4|5|6|7|6R|8|@]|9|@]|A|$]]]|2J|$2K|$5|2L|2M|2N|A|$2O|2P]]|2Q|$5|2L|2M|2N|A|$2O|2R]]|2S|$5|2L|2M|2N|A|$2O|2R]]|2T|$5|2L|2M|2N|A|$2O|2R]]]]

The lack of backtracking due to negation as pointed out by @SQB is actually not the only problem with your code. If you play around a little with ground queries you find that non-lists and the empty list as pointed out by @false are also not the only issue. Consider the following queries:

<pre><code> ?- intersection([2,3],[1,2,3],[2,3,4]).
yes
 ?- intersection([2],[1,2,3],[2,3,4]).
yes
 ?- intersection([3],[1,2,3],[2,3,4]).
yes
 ?- intersection([],[1,2,3],[2,3,4]).
yes
</code></pre>

The first is what usually is understood as intersection. The other three are all sublists of the intersection including the trivial sublist <code>[]</code>. This is due to the way the predicate describes what an intersection is: In an intersection is not the case that an element is in the first but not the second list AND that said element is in the first but not the third list. This description clearly fits the three above queries hence they succeed. Fooling around a little more with this description in mind there are some other noteworthy ground queries that succeed:

<pre><code> ?- intersection([2,2,3],[1,2,3],[2,3,4]).
yes
</code></pre>

The question whether the presence of duplicates in the solution is acceptable or not is in fact quite a matter of debate. The lists <code>[2,2,3]</code> and <code>[2,3]</code> although different represent the same set {2,3}. There is <a href="https://stackoverflow.com/a/36824211/6101159">this recent answer</a> to a question on Prolog union that is elaborating on such aspects of answers. And of course the sublists of the intersection mentioned above can also contain duplicates or multiples:

<pre><code> ?- intersection([2,2,2],[1,2,3],[2,3,4]).
yes
</code></pre>

But why is this? For the empty list this is quite easy to see. The query

<pre><code> ?- element(A,[]).
no
</code></pre>

fails hence the conjunction <code>element(A,L1), not(element(A,L2))</code> also fails for <code>L1=[]</code>. Therefore the negation wrapped around it succeeds. The same is true for the second negation, consequently <code>[]</code> can be derived as intersection. To see why <code>[2]</code> and <code>[3]</code> succeed as intersection it is helpful to write your predicate as logic formula with the universal quantifiers written down explicitly:

&#8704;<code>L1</code>&#8704;<code>L2</code>&#8704;<code>R</code>&#8704;<code>A</code> <code>(intersection(L1,L2,R)</code> &#8592; &#172; <code>(element(A,L1)</code> &#8743; &#172; <code>element(A,L2))</code> &#8743; &#172; <code>(element(A,L1)</code> &#8743; &#172; <code>element(A,R)))</code>

If you consult a textbook on logic or one on logic programming that also shows Prolog code as logic formulas you'll find that the universal quantifiers for variables that do not occur in the head of the rule can be moved into the body as existential quantifiers. In this case for <code>A</code>:

&#8704;<code>L1</code>&#8704;<code>L2</code>&#8704;<code>R</code> <code>(intersection(L1,L2,R)</code> &#8592; &#8707;<code>A (</code> &#172; <code>(element(A,L1)</code> &#8743; &#172; <code>element(A,L2))</code> &#8743; &#172; <code>(element(A,L1)</code> &#8743; &#172; <code>element(A,R))))</code>

So for all arguments <code>L1,L2,R</code> there is some <code>A</code> that satisfies the goals. Which explains the derivation of the sublists of the intersection and the multiple occurrences of elements.

However, it is much more annoying that the query

<pre><code> ?- intersection(L1,[1,2,3],[2,3,4]).
</code></pre>

loops instead of producing solutions. If you consider that <code>L1</code> is not instantiated and look at the results for the following query

<pre><code> ?- element(A,L1).
L1 = [A|_A] ? ;
L1 = [_A,A|_B] ? ;
L1 = [_A,_B,A|_C] ? ;
...
</code></pre>

it becomes clear that the query

<pre><code> ?- element(A,L1),not(element(A,[1,2,3])).
</code></pre>

has to loop due to the infinitely many lists <code>L1</code>, that contain <code>A</code>, described by the first goal. Hence the corresponding conjunction in your predicate has to loop as well. Additionally to producing results it would also be nice if such a predicate mirrored the relational nature of Prolog and worked the other way around too (2nd or 3rd arguments variable). Let's compare your code with such a solution. (For the sake of comparison the following predicate describes sublists of the intersection just as your code does, for a different definition see further below.)

To reflect its declarative nature lets call it list_list_intersection/3:

<pre><code>list_list_intersection(_,_,[]).
list_list_intersection(L1,L2,[A|As]) :-
 list_element_removed(L1,A,L1noA),
 list_element_removed(L2,A,L2noA),
 list_list_intersection(L1noA,L2noA,As).

list_element_removed([X|Xs],X,Xs).
list_element_removed([X|Xs],Y,[X|Ys]) :-
 dif(X,Y),
 list_element_removed(Xs,Y,Ys).
</code></pre>

Like your predicate this version is also using the elements of the intersection to describe the relation. Hence it's producing the same sublists (including <code>[]</code>):

<pre><code> ?- list_list_intersection([1,2,3],[2,3,4],I).
I = [] ? ;
I = [2] ? ;
I = [2,3] ? ;
I = [3] ? ;
I = [3,2] ? ;
no
</code></pre>

but without looping. However, multiple occurrences are not produced anymore as already matched elements are removed by list_element_removed/3. But multiple occurrences in both of the first lists are matched correctly:

<pre><code> ?- list_list_intersection([1,2,2,3],[2,2,3,4],[2,2,3]).
yes
</code></pre>

This predicate also works in the other directions:

<pre><code> ?- list_list_intersection([1,2,3],L,[2,3]).
L = [2,3|_A] ? ;
L = [2,_A,3|_B],
dif(_A,3) ? ;
L = [2,_A,_B,3|_C],
dif(_A,3),
dif(_B,3) ? ;
...

 ?- list_list_intersection(L,[2,3,4],[2,3]).
L = [2,3|_A] ? ;
L = [2,_A,3|_B],
dif(_A,3) ? ;
L = [2,_A,_B,3|_C],
dif(_A,3),
dif(_B,3) ? ;
...
</code></pre>

So this version corresponds to your code without the duplicates. Note how the element <code>A</code> of the intersection explicitly appears in the head of the rule where all elements of the intersection are walked through recursively. Which I believe is what you tried to achieve by utilizing the implicit universal quantifiers in front of Prolog rules.

To come back to a point in the beginning of my answer, this is not what is commonly understood as the intersection. Among all the results list_list_intersection/3 describes for the arguments <code>[1,2,3]</code> and <code>[2,3,4]</code> only <code>[2,3]</code> is the intersection. Here another issue with your code comes to light: If you use the elements of the intersection to describe the relation, how do you make sure you cover all intersecting elements? After all, all elements of <code>[2]</code> occur in <code>[1,2,3]</code> and <code>[2,3,4]</code>. An obvious idea would be to walk through the elements of one of the other lists and describe those occurring in both as also being in the intersection. Here is a variant using <a href="https://stackoverflow.com/a/27358600/6101159">if_/3</a> and <a href="https://stackoverflow.com/a/27358600/6101159">memberd_t/3</a>:

<pre><code>list_list_intersection([],_L2,[]).
list_list_intersection([X|Xs],L2,I) :-
 if_(memberd_t(X,L2),
 (I=[X|Is],list_element_removed(L2,X,L2noX)),
 (I=Is,L2noX=L2)),
 list_list_intersection(Xs,L2noX,Is).
</code></pre>

Note that it is also possible to walk through the arguments of the second list instead of the first one. The predicate <a href="https://stackoverflow.com/a/27358600/6101159">memberd_t/3</a> is a reified variant of your predicate element/2 and list_element_removed/3 is again used in the description to avoid duplicates in the solution. Now the solution is unique

<pre><code> ?- list_list_intersection([1,2,3],[2,3,4],L).
L = [2,3] ? ;
no
</code></pre>

and the "problem queries" from above fail as expected:

<pre><code> ?- list_list_intersection([1,2,3],[2,3,4],[]).
no
 ?- list_list_intersection([1,2,3],[2,3,4],[2]).
no
 ?- list_list_intersection([1,2,3],[2,3,4],[3]).
no
 ?- list_list_intersection([1,2,3],[2,3,4],[2,2,3]).
no
 ?- list_list_intersection([1,2,3],[2,3,4],[2,2,2]).
no
</code></pre>

And of course you can also use the predicate in the other directions:

<pre><code> ?- list_list_intersection([1,2,3],L,[2,3]).
L = [2,3] ? ;
L = [3,2] ? ;
L = [2,3,_A],
dif(_A,1) ? ;
...

 ?- list_list_intersection(L,[2,3,4],[2,3]).
L = [2,3] ? ;
L = [2,3,_A],
dif(4,_A) ? ;
...
</code></pre>

I am trying to build a simple predicate which get as inputs two lists and the results is a third one consisting of the intersection of the first two.
I have decided to do using logical statement. I am pretty sure my logic is correct but my predicate is not working. Any ideas?:

<pre><code>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))
 )).
</code></pre>

Please do not post alternative methods I am wondering why this one returns FALSE every time.

Set Intersection predicate Prolog using not

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在尝试构建一个简单的谓词，它以两个列表作为输入，结果是由前两个列表的交集组成的第三个列表。我决定使用逻辑语句。我非常确定我的逻辑是正确的，但我的谓词不起作用。有什么想法吗？element(X,[H|T]) :-       X=H   ;      element(X,T).intersection(L1,L2,R...

使用not设置相交谓词Prolog-腾讯云开发者社区-腾讯云

问使用not设置相交谓词Prolog
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用not设置相交谓词PrologEN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用not设置相交谓词Prolog
EN