Scheme 交替列表

我需要做一个函数来检测列表是否在原子和子列表之间交替。例如，如果列表是（a（bc）d（ef）），它将返回true；如果列表是（ab），它将返回false

这就是我到目前为止所做的：

(define (altlist? lis)
(cond
((null? lis)#t)
((null? (cdr lis))#t)
((list? (car lis))
 (not(list? (cadr lis)
            (altlist? cdr lis)
           '() )
     (list? (cadr lis)
            (altlist? cdr lis)
           '())
     ))))

---

函数

list？

和

not

只接受一个参数（请参阅），这是不可理解的。您所说的第三个

cond

子句是什么意思

同时，解决方案甚至更短：

(define (altlist? lis)
  (cond
   ((null? lis) #f)
   ((null? (cdr lis)) #f)
   ((not
     (eq? (list? (cadr lis))
          (list? (car lis))))
    #t)
   (#t (altlist? (cdr lis)))))

其思想是逐个检查给定列表的后续对。对于每一个，比较两者是列表还是原子。如果列表包含列表和原子，则将有一对（列表原子）或（原子列表），反之亦然

编辑： 正如@molbdnilo所指出的，原始函数实际上试图检查列表是否是交替的

编辑：

---

现在我明白了，交替列表不仅仅是一个列表，包含列表和原子，所以看看GoZoner的解决方案。当前的实现只是检查给定列表中是否存在一个atom和一个cons。

给您：

(define (alt-list? l)
  (or (null? l)
      (and (not (null? (cdr  l)))
           (not (list? (car  l)))  ; atom
           (list? (cadr l))        ; list
           (alt-list? (cddr l)))))

具体代码取决于以下是否为“交替列表”：

“（a（b）c）d）

“（（a b）c）

---

我提供的代码需要（atom列表）*=>#t

这是您的代码，其中移动了一些括号，添加了一些注释和缩进（以使其可读），并进行了一些更正：

(define (altlist? lis)
  (cond
    ((null? lis) #t)                  ; end-of-list successfully reached
    ((null? (cdr lis)) #t)            ; ditto
    ((list? (car lis))                ; first elt is a list
      (and (not (list? (cadr lis)))   ; fixed: use AND
           (altlist? (cdr lis))))
    (else                             ; fixed: ELSE clause
      (and (list? (cadr lis))         ; fixed: use AND
           (altlist? (cdr lis))))))

所以你很接近。写代码时要小心

---

这里有一个微妙之处<代码>（列表？'（））返回true。如果你喜欢把空列表看作是一个原子，而不是一个列表，那么，而不是<代码>列表> <代码>，你可以使用<代码>对？< /代码>。 不幸的是，

（altlist？'（12））

-->

#t

。你错过了一个

而不是
。你是对的，molbdnilo。我被史蒂文的密码弄糊涂了。更正。不幸的是，现在
（altlist？）（1（23）（45））
-->
#t
。现在我明白了，交替列表不仅仅是一个列表，包含列表和原子，所以看看GoZoner解决方案。（1（23）（45））是交替列表，但您的实现：
（altlist？）（1（23）（45））
给出的
；f
是“（1）（23）（45））交替列表？我想“（1（23）4（56））应该是“原子和子列表之间的交替”我不理解交替列表的概念，现在我明白了，你的解决方案是正确的，不像我的。谢谢。
（（12）3（45）6）
是原子和子列表之间交替的列表吗？