Question

我试图找到列表中每个元素的深度，同时创建一个输出，其中平铺输出以其深度级别写入，到目前为止，我想出了以下逻辑 -

(define nestingDepth
 (lambda (lst1)
    (cond ((null? lst1) 1) 
          ((list? (car lst1)) 
          (cons(+ 1(nestingDepth (car lst1)))) (nestingDepth (cdr lst1)))          
          ((null? (cdr lst1)) (cons (1 (cdr lst1))) (nestingDepth (cdr lst1))))))

但是这不会在输出中打印任何东西。请更新我错的地方。预期结果将如下 - 输入 - '（a（b）c）输出 - （1 a 2 b 1 c）

Answer 1

这是一个可能的解决方案（我已经稍微更改了输出格式以使解决方案更容易编码）。 append-map中定义了(define (depths x) (cond ((list? x) (append-map (lambda (y) (map (lambda (z) (cons (car z) (+ (cdr z) 1))) (depths y))) x)) (else `((,x . 0)))))。

{{1}}

（我编写代码作为一个经验丰富的Schemer会编写它，而不是因为有人会写一个家庭作业。如果这是你的情况，试着去理解我的代码做什么，然后将其改编成一些作业 - 可接受的。）

Answer 2

正如其他一些答案所提到的那样，确保每个案例都能恢复正确的类型是非常重要的。如果输入是空列表，则输出应为空列表。如果输入是一对，那么你需要处理汽车和该对的cdr并连接它们。如果输入既不是空列表也不是一对，则结果是深度和输入的列表。

现在，逐步构建结果可能很方便。您可以从右向左构建，并使用如下方法添加每个元素及其深度：

(define (depths tree)
  (let depths ((tree tree)
               (depth 0)
               (results '()))
    (cond
      ((null? tree) results)
      ((pair? tree) (depths (car tree)
                            (+ 1 depth)
                            (depths (cdr tree)
                                    depth
                                    results)))
      (else (cons depth (cons tree results))))))

> (depths '(a ((b) c ((d))) e))
(1 a 3 b 2 c 4 d 1 e)

Answer 3

所有以前的解决方案都适用于正确的（嵌套）列表，对于那些为不正确的列表工作的人我不确定它们是否正确。

例如，(depths '(a . b))为Joshua提供(1 a 0 b)，为Chris提供(((a . b) . 0))，但我认为它应为(1 a 1 b)。

因此我会去

(define (depths sxp)
  (let loop ((sxp sxp) (res null) (level (if (cons? sxp) 1 0)))
    (cond
      ((null? sxp) res)
      ((pair? sxp) (let ((ca (car sxp)))
                     (loop ca
                           (loop (cdr sxp) res level)
                           (if (pair? ca) (add1 level) level))))
      (else        (cons level (cons sxp res))))))

我的测试用例是：

(check-equal? (depths '(a . b)) '(1 a 1 b))
(check-equal? (depths 'a) '(0 a)) ; 0
(check-equal? (depths '(a)) '(1 a))
(check-equal? (depths '(a a)) '(1 a 1 a))
(check-equal? (depths '(a (b . c) d (e (f (g h . i) . j)))) '(1 a 2 b 2 c 1 d 2 e 3 f 4 g 4 h 4 i 3 j))

(check-equal? (depths '(a (b) c)) '(1 a 2 b 1 c))
(check-equal? (depths '(a ((b) c ((d))) e)) '(1 a 3 b 2 c 4 d 1 e))
(check-equal? (depths '(a (b (c (d e))) f g)) '(1 a 2 b 3 c 4 d 4 e 1 f 1 g))

Answer 4

基本情况是错误的（如果您打算输出列表作为结果，则无法返回1），递归递归的方式不会将列表构建为输出......需要完全重写;以下解决方案是可移植的，应该适用于任何Scheme解释器，仅使用基本过程：

(define (nestingDepth lst)
  (let depth ((lst lst) (n 1))
    (cond ((null? lst) '())
          ((not (pair? (car lst)))
           (cons n
                 (cons (car lst)
                       (depth (cdr lst) n))))
          (else
           (append (depth (car lst) (+ 1 n))
                   (depth (cdr lst) n))))))

输出符合预期：

(nestingDepth '(a (b (c (d e))) f g))
=> '(1 a 2 b 3 c 4 d 4 e 1 f 1 g)

列表中的原子深度

4 个答案: