blocks|key|566233|text|所以我修复了它，感谢你确认Barmer，这是我的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|566234|(defun+checkInner(A+L)
++++(cond+((and+(atom+L)+(eq+A+L))+t)
++++++++(t++(cond+((or+(atom+L)+(eq+A+L))+nil)
++++++++++++++++(t+(cond+((eq+A+(car+L))+t)
++++++++++++++++++++++++(t+(checkInner+A+(cdr+L))
++++++++++++++++++++++++)
++++++++++++++++++++)
++++++++++++++++)
++++++++++++)
++++++++)
++++)
)|code-block|syntax|javascript|566235|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

so I fixed it, thanks for confirming Barmer, this is my solution

<pre><code>(defun checkInner(A L)
 (cond ((and (atom L) (eq A L)) t)
 (t (cond ((or (atom L) (eq A L)) nil)
 (t (cond ((eq A (car L)) t)
 (t (checkInner A (cdr L))
 )
 )
 )
 )
 )
 )
)
</code></pre>

blocks|key|4070694|text|除非使用显式(return-from+checkInner+value)表达式，否则函数将返回其上一个表达式的值。因此，函数返回的惟一值是最后一个cond表达式；前两个测试被忽略。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4070695|您需要将所有案例组合到一个COND表达式中。|4070696|另外，第二个测试不应该使用or。如果L是一个原子，它将不等于L，因为我们在前面的例子中测试了它。|4070697|(defun+checkInner(A+L)
++++(cond+((and+(atom+L)+(eq+A+L))+t)
++++++++++((atom+L)+nil)
++++++++++((eq+A+(car+L))+t)
++++++++++(t+(checkInner+A+(cdr+L)))))|code-block|syntax|javascript|4070698|entityMap^0|6|U|21|4|0|D|4|0|D|2|I|1|U|1|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|15|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

Unless you use an explicit <code>(return-from checkInner value)</code> expression, a function returns the value of its last expression. So the only value that's returned by your function is the last <code>cond</code> expression; the first two tests are ignored.

You need to combine all the cases into a single <code>COND</code> expression.

Also, the second test should not use <code>or</code>. If <code>L</code> is an atom, it won't be equal to <code>L</code> because we tested that in the previous case.

<pre><code>(defun checkInner(A L)
 (cond ((and (atom L) (eq A L)) t)
 ((atom L) nil)
 ((eq A (car L)) t)
 (t (checkInner A (cdr L)))))
</code></pre>

blocks|key|4014956|text|@Barmar你基本上检查了两次L是一个原子，第一次可以写成((+atom+L)+(eq+A+L))+(eq+A+L)返回一个布尔值，所以你不需要显式地从那个子句返回T，这总体上与你的第二个子句((atom+L)+nil)相矛盾。还要注意，这种解决方案不适用于嵌套的元素列表(这将是唯一愿意编写自己的递归函数的参数，而不仅仅是使用Lisp函数来测试成员资格，如member、find等)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4014957|(checkInner+'b+'(a+(c+(d+(b)))))+;+=>+NIL|code-block|syntax|javascript|4014958|下面是一个适用于嵌套列表的递归定义。请注意，您还可以提供一个相等测试函数，以允许您的X具有不同的类型。|4014959|(defun+check-inner+(x+coll+&key+(test+#'eq))
+++"Check+if+X+is+in+the+collection.+Works+on+nested+lists+
and+uses+the+test+keyword+argument+for+equality+checking."
+++(cond
++++((null+coll)+nil)
++++((listp+(car+coll))+(or+(check-inner+x+(car+coll)+:test+test)
++++++++++++++++++++++++++++(check-inner+x+(cdr+coll)+:test+test)))
++++((atom+(car+coll))+(or+(funcall+test+x+(car+coll))
+++++++++++++++++++++++++++(check-inner+x+(cdr+coll)+:test+test)))
++++(t+(check-inner+x+(cdr+coll+:test+test)))))|4014960|现在你正在寻找的东西也可以隐藏在列表的嵌套层中：|4014961|(check-inner+'b+'(a+(c+(d+(b)))))+;+=>+T|4014962|检查其他类型也没有问题：|4014963|(check-inner+"b"+'(a+(c+(d+("b"))))+:test+#'string=)+;+=>+T|4014964|entityMap^0|X|4|1F|8|2B|1|2P|E|50|6|57|4|0|0|16|1|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1I|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|X|$]]

@Barmar You are basicaly checking the L being an <code>atom</code> twice, the first time could be written just as
((atom L) (eq A L))
<code>(eq A L)</code> is returning a boolean, so you don't need to explicitely return <code>T</code> from that clause, which overall contradicts with your second clause <code>((atom L) nil)</code>. Also note that this solution will not work on nested lists of elements (which would be the only argument willing to write your own recursive function and not just using the Lisp functions for testing memberships like <code>member</code>, <code>find</code> etc.)

<pre><code>(checkInner 'b '(a (c (d (b))))) ; =&gt; NIL
</code></pre>

Following is a recursive definition that works on nested lists as well. Note that you can also supply an equality testing function for allowing your <code>X</code> being of different types.

<pre><code>(defun check-inner (x coll &amp;key (test #'eq))
 "Check if X is in the collection. Works on nested lists 
and uses the test keyword argument for equality checking."
 (cond
 ((null coll) nil)
 ((listp (car coll)) (or (check-inner x (car coll) :test test)
 (check-inner x (cdr coll) :test test)))
 ((atom (car coll)) (or (funcall test x (car coll))
 (check-inner x (cdr coll) :test test)))
 (t (check-inner x (cdr coll :test test)))))
</code></pre>

Now the thing you are looking for can be also hidden in nested layers in your list:

<pre><code>(check-inner 'b '(a (c (d (b))))) ; =&gt; T
</code></pre>

Checking for other types is also no problem:

<pre><code>(check-inner "b" '(a (c (d ("b")))) :test #'string=) ; =&gt; T
</code></pre>

I am working on a recursive function that takes a list and a value ex: 'b '(a. b), and returns nil if not found and t if found. my issue is in the line (cond ((eq A (car L)) t), it seems to be checking that condition even after (cond ((and (atom L (eq A L)) t) returns. I am under the impression that if that condition is met, execution stop and the function returns. Any way to fix this? Also, im only able to use primitive functions 
defun
cond
cons
car
cdr
operators +, -, &lt;, and >
null
eq
listp
atom
symbolp

<pre><code>;test cases 
(checkInner 'b '(a . b))
(checkInner 'f '(c e f))
(checkInner 'b '(b))

;function 
(defun checkInner(A L)
 (cond ((and (atom L) (eq A L)) t)
 )
 (cond ((or (atom L) (eq A L)) nil)
 )
 (cond ((eq A (car L)) t)
 (t (checkInner A (cdr L))
 )
 )
)
</code></pre>

Lisp recursive function to check for value in list not working

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在做一个递归函数，它接受一个列表和一个值ex：'b‘(a.b)，如果没有找到，则返回nil，如果找到，则返回t。我的问题是在行(cond ((eq A (car L)) t)中，它似乎在(cond ((and (atom L (eq A L)) t)返回之后检查那个条件。我的印象是，如果满足该条件，执行将停止，函数...

问用于检查列表中的值是否不起作用的Lisp递归函数
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用于检查列表中的值是否不起作用的Lisp递归函数EN