blocks|key|2616267|text|“状态切换”实际上是解决这个问题的一个很好的方法。逻辑应该遵循这些简单的规则：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2616268|2616269|blockquote|2616270|2616271|如果Xs.中的元素数量为奇数，则X中的X元素数量为偶数|offset|length|style|CODE|2616272|2616273|如果X和[Y%7CXs]不同，则X中的Y元素数量为偶数，而Xs.|ordered-list-item|2616274|中的X元素数量为偶数|2616275|如果Xs.中的元素数量为偶数，则X中的X元素数量为奇数|2616276|2616277|如果X和[Y%7CXs]不同，则X中的Y元素数量为奇数，而Xs.|2616278|中的X元素数量为奇数|2616279|然后你就有了基本的情况：|2616280|2616281|在[]中有偶数个任意元素。|2616282|2616283|[X]中有奇数个X。|2616284|2616285|您只需将这些规则编写为Prolog即可。但是，您的实现有一些问题。|2616286|在少数情况下，您将以[Head,+Tail]而不是[Head%7CTail]的形式编写列表。[Head,+Tail]是一个恰好包含两个元素的列表。此外，您对unevenCount/2的基本情况(我假设您指的是奇数计数)是不正确的。如果你有一个总是失败的基本情况，那么你的谓词也总是会失败。除了少数例外，您应该编写谓词子句才能成功，而不是失败。当不能成功时，会自动发生失败。|2616287|让我们试着写出上面的规则。ISO+Prolog已经有了\%2B，所以您不需要定义not/1。此外，编写equal([E%7C_],+E).也是不必要的。你可以直接在你的代码中简单地做到这一点。|2616288|evenCount(_,+[]).++++++++++%25+base+case+for+even
evenCount(X,+[X%7CXs])+:-++++%25+rule+#1
++++oddCount(X,+Xs).
evenCount(X,+[Y%7CXs])+:-++++%25+rule+#2
++++dif(X,+Y),
++++evenCount(X,+Xs).

oddCount(X,+[X]).++++++++++%25+base+case+for+odd
oddCount(X,+[X%7CXs])+:-+++++%25+rule+#3
++++evenCount(X,+Xs).
oddCount(X,+[Y%7CXs])+:-+++++%25+rule+#4
++++dif(X,+Y),
++++oddCount(X,+Xs).|code-block|syntax|javascript|2616289|SWI+Prolog定义了dif/2。您也可以使用\==，但它并不像dif/2那样被完全定义(因此其行为也不像一般的那样)。|2616290|entityMap^0|0|0|0|0|2|2|G|1|J|1|0|0|2|1|4|6|E|1|H|1|R|2|0|2|1|0|2|2|G|1|J|1|0|0|2|1|4|6|E|1|H|1|R|2|0|2|1|0|0|0|1|2|0|0|0|3|8|1|0|0|0|A|C|P|B|18|C|24|D|0|R|2|12|5|1D|G|0|0|D|5|P|3|Y|5|0^^$0|@$1|2|3|4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|C|3|-4|5|D|7|1O|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1Q|8|@$H|1R|I|1S|J|K]|$H|1T|I|1U|J|K]|$H|1V|I|1W|J|K]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1Y|8|@$H|1Z|I|20|J|K]|$H|21|I|22|J|K]|$H|23|I|24|J|K]|$H|25|I|26|J|K]|$H|27|I|28|J|K]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|29|8|@$H|2A|I|2B|J|K]]|9|@]|A|$]]|$1|R|3|S|5|6|7|2C|8|@$H|2D|I|2E|J|K]|$H|2F|I|2G|J|K]|$H|2H|I|2I|J|K]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|2J|8|@]|9|@]|A|$]]|$1|U|3|V|5|O|7|2K|8|@$H|2L|I|2M|J|K]|$H|2N|I|2O|J|K]|$H|2P|I|2Q|J|K]|$H|2R|I|2S|J|K]|$H|2T|I|2U|J|K]]|9|@]|A|$]]|$1|W|3|X|5|6|7|2V|8|@$H|2W|I|2X|J|K]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|30|8|@$H|31|I|32|J|K]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|33|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|34|8|@$H|35|I|36|J|K]|$H|37|I|38|J|K]]|9|@]|A|$]]|$1|16|3|-4|5|6|7|39|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|3A|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|3B|8|@$H|3C|I|3D|J|K]|$H|3E|I|3F|J|K]|$H|3G|I|3H|J|K]|$H|3I|I|3J|J|K]]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|3K|8|@$H|3L|I|3M|J|K]|$H|3N|I|3O|J|K]|$H|3P|I|3Q|J|K]]|9|@]|A|$]]|$1|1D|3|1E|5|1F|7|3R|8|@]|9|@]|A|$1G|1H]]|$1|1I|3|1J|5|6|7|3S|8|@$H|3T|I|3U|J|K]|$H|3V|I|3W|J|K]|$H|3X|I|3Y|J|K]]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|3Z|8|@]|9|@]|A|$]]]|1L|$]]

The &quot;switching between states&quot; is actually a good way to solve this problem. The logic should follow these simple rules:
<blockquote>
<ol>
<li>There are an even number of <code>X</code> elements in <code>[X|Xs]</code> if there are an odd number of <code>X</code> elements in <code>Xs</code>.
</li>
<li>There are an even number of <code>X</code> elements in <code>[Y|Xs]</code> if <code>X</code> and <code>Y</code> are different, and there are an even number of <code>X</code> elements in <code>Xs</code>.
</li>
<li>There are an odd number of <code>X</code> elements in <code>[X|Xs]</code> if there are an even number of <code>X</code> elements in <code>Xs</code>.
</li>
<li>There are an odd number of <code>X</code> elements in <code>[Y|Xs]</code> if <code>X</code> and <code>Y</code> are different, and there are an odd number of <code>X</code> elements in <code>Xs</code>.
</li>
</ol>
</blockquote>
Then you have the base cases:
<blockquote>
There are an even number of any element in <code>[]</code>.
There are an odd number of <code>X</code> in <code>[X]</code>.
</blockquote>
You just need to write these rules as Prolog. However, your implementation has a few issues.
In a few cases, you are writing a list as <code>[Head, Tail]</code> instead of <code>[Head|Tail]</code>. <code>[Head, Tail]</code> is a list of exactly two elements. Also, your base case for <code>unevenCount/2</code> (which I assume you mean odd count) is incorrect. If you have a base case that always fails, then your predicate will always fail. With few exceptions, you should write your predicate clauses to succeed, not fail. Failure will occur automatically when success cannot be achieved.
Let's try to write out the rules above. ISO Prologs already have <code>\+</code>, so you do not need to define <code>not/1</code>. Also, writing <code>equal([E|_], E).</code> is unnecessary. You can do this directly in your code with simplicity.
<pre><code>evenCount(_, []). % base case for even
evenCount(X, [X|Xs]) :- % rule #1
 oddCount(X, Xs).
evenCount(X, [Y|Xs]) :- % rule #2
 dif(X, Y),
 evenCount(X, Xs).

oddCount(X, [X]). % base case for odd
oddCount(X, [X|Xs]) :- % rule #3
 evenCount(X, Xs).
oddCount(X, [Y|Xs]) :- % rule #4
 dif(X, Y),
 oddCount(X, Xs).
</code></pre>
SWI Prolog defines <code>dif/2</code>. You could also use <code>\==</code> but it's not purely defined (and so doesn't behave as generally) as <code>dif/2</code>.

I have to check if a list contains an even number of an element without built-ins.

Example: 

<pre><code>containsEvenNumber([a,b,c,a,a], a).
</code></pre>

returns false

<pre><code>containsEvenNumber([a,b,c,a], a).
</code></pre>

returns true

Current state:

<pre><code>not(A) :-
 A, !,
 fail.
not(_).
equal([E|_], E).
containsEvenNumber([], _).
containsEvenNumber([E|Tail], E) :-
 unevenCount(Tail, E).

containsEvenNumber([Head|Tail], E) :-
 not(equal([Head|Tail], E)),
 evenCount(Tail, E).

evenCount([], _).
evenCount([E|Tail], E) :-
 unevenCount(Tail, E).

evenCount([Head, Tail], E) :-
 not(equal([Head|Tail], E)),
 unevenCount(Tail, E).

unevenCount([], _) :-
 fail.
unevenCount([E, Tail], E) :-
 evenCount(Tail, E).

unevenCount([Head, Tail], E) :-
 not(equal([Head|Tail], E)),
 unevenCount(Tail, E).
</code></pre>

I try to switch between states upon the occurrence of the element.
It doesn't work because I never go into the state, where the head is not the element or rather said, I also go into the state and return false when the head is the element.

How can I make it work/fix it?

Prolog check if list contains even number of an element

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我必须检查一个列表是否包含偶数个没有内置的元素。示例：containsEvenNumber([a,b,c,a,a], a).返回falsecontainsEvenNumber([a,b,c,a], a).返回true当前状态：not(A) :-    A, !,    fail.not(_).equal([E|_], ...

Prolog检查列表是否包含偶数个元素-腾讯云开发者社区-腾讯云

问Prolog检查列表是否包含偶数个元素
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Prolog检查列表是否包含偶数个元素EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Prolog检查列表是否包含偶数个元素
EN