List 如何从scheme中的两个列表中获取对的交集？

我使用这个脚本从小阴谋家，得到两个集的交集。但我在“member”处遇到了未绑定标识符错误，请告诉我它有什么问题：

(define intersect
  (lambda (set1 set2)
    (cond ((null? set1) (quote ()))
          ((member? (car set1) set2)
           (cons (car setl)
                 (intersect (cdr set1) set2)))
          (else (intersect (cdr setl) set2)))))

我缺少上述功能：

(define member?
  (lambda (a lat)
    (cond ((null? lat) #f)
          (else (or (eq? (car lat) a)
                    (member? a (cdr lat)))))))

---

另外，我想把两个列表交叉，比如：“（（12）（27））”（（13）（45））=”（（15）），有什么建议吗？我正在从这篇文章中查找答案：

你在

intersect

中有一个输入错误，你将1改为小写L。如果你修复了

intersect

的问题，我认为如果你在比较符号，你的

intersect

就可以了。例如

(define intersect
  (lambda (set1 set2)
    (cond
      ((null? set1)(quote ()))
      ((member? (car set1) set2)
       (cons (car set1)
             (intersect (cdr set1) set2)))
      (else (intersect (cdr set1) set2)))))

(intersect '(a b c d) '(c d e f)) ; ==> (c d) 

要使其比较符号以外的其他内容，您需要更改

成员？

，使其使用

equal？

而不是

eq？

。它将是这样的：

(define member?
  (lambda (a lat)
    (cond
      ((null? lat) #f)
      (else (or (equal? (car lat) a) ; changed eq? to equal? 
                (member? a (cdr lat)))))))

(intersect '((1 2)(3 4)(5 6)) '((9 10) (7 8) (5 6))) ; ==> ((5 6))

即使在这之后。上面的符号版本仍然有效。 在任何LISP（至少公共LISP和Scheme）中，您都有

成员

。它使用

equal

并在未找到时计算为

false

（实现中为false的内容），如果找到了，则计算为参数列表的其余部分，从找到元素的位置开始计算（这被认为是true）：

使用标准成员而不是您自己的谓词：

(define intersect
  (lambda (set1 set2)
    (cond
      ((null? set1)(quote ()))
      ((member (car set1) set2)
       (cons (car set1)
             (intersect (cdr set1) set2)))
      (else (intersect (cdr set1) set2)))))

(intersect '((1 2)(3 4)(5 6)) '((9 10) (7 8) (5 6))) ; ==> ((5 6))
(intersect '(a b c d) '(c d e f)) ; ==> (c d) 

编辑1

您似乎不是在搜索

交叉点

，而是一个特殊的

列表

合并：

#!r6rs
(import (rnrs base)
        (rnrs lists))

;; if you dont have r6rs remove the above and
;; uncomment this rnrs/lists-6 memp
#;(define (memp predicate? lst)
  (cond ((null? lst) #f)
        ((predicate? lst) lst)
        (else (memp predicate? (cdr lst)))))


(define (alist-merge merge-proc alist-1 alist-2)
  (if (null? alist-1) 
      '()
      (let* ((name (caar alist-1))
             (found (memp (lambda (x) (equal? (car x) name)) alist-2)))
        (if found
            (cons (merge-proc (car alist-1) (car found))
                  (alist-merge merge-proc
                               (cdr alist-1)
                               alist-2))
            (alist-merge merge-proc
                         (cdr alist-1)
                         alist-2)))))

(define (alist-merge-add alist-1 alist-2)
  (alist-merge (lambda (x y)
                 (list (car x)
                       (+ (cadr x) (cadr y))))
               alist-1
               alist-2))

(alist-merge-add '((1 2)(2 7)) '((1 3)(4 5))) ; ==> ((1 5))

---

您在

intersect

中有一个输入错误，您已将1切换为小写L。如果您修复了

intersect

的问题，我会认为您在比较符号时没有问题。例如

(define intersect
  (lambda (set1 set2)
    (cond
      ((null? set1)(quote ()))
      ((member? (car set1) set2)
       (cons (car set1)
             (intersect (cdr set1) set2)))
      (else (intersect (cdr set1) set2)))))

(intersect '(a b c d) '(c d e f)) ; ==> (c d) 

要使其比较符号以外的其他内容，您需要更改

成员？

，使其使用

equal？

而不是

eq？

。它将是这样的：

(define member?
  (lambda (a lat)
    (cond
      ((null? lat) #f)
      (else (or (equal? (car lat) a) ; changed eq? to equal? 
                (member? a (cdr lat)))))))

(intersect '((1 2)(3 4)(5 6)) '((9 10) (7 8) (5 6))) ; ==> ((5 6))

即使在这之后。上面的符号版本仍然有效。 在任何LISP（至少公共LISP和Scheme）中，您都有

成员

。它使用

equal

并在未找到时计算为

false

（实现中为false的内容），如果找到了，则计算为参数列表的其余部分，从找到元素的位置开始计算（这被认为是true）：

使用标准成员而不是您自己的谓词：

(define intersect
  (lambda (set1 set2)
    (cond
      ((null? set1)(quote ()))
      ((member (car set1) set2)
       (cons (car set1)
             (intersect (cdr set1) set2)))
      (else (intersect (cdr set1) set2)))))

(intersect '((1 2)(3 4)(5 6)) '((9 10) (7 8) (5 6))) ; ==> ((5 6))
(intersect '(a b c d) '(c d e f)) ; ==> (c d) 

编辑1

您似乎不是在搜索

交叉点

，而是一个特殊的

列表

合并：

#!r6rs
(import (rnrs base)
        (rnrs lists))

;; if you dont have r6rs remove the above and
;; uncomment this rnrs/lists-6 memp
#;(define (memp predicate? lst)
  (cond ((null? lst) #f)
        ((predicate? lst) lst)
        (else (memp predicate? (cdr lst)))))


(define (alist-merge merge-proc alist-1 alist-2)
  (if (null? alist-1) 
      '()
      (let* ((name (caar alist-1))
             (found (memp (lambda (x) (equal? (car x) name)) alist-2)))
        (if found
            (cons (merge-proc (car alist-1) (car found))
                  (alist-merge merge-proc
                               (cdr alist-1)
                               alist-2))
            (alist-merge merge-proc
                         (cdr alist-1)
                         alist-2)))))

(define (alist-merge-add alist-1 alist-2)
  (alist-merge (lambda (x y)
                 (list (car x)
                       (+ (cadr x) (cadr y))))
               alist-1
               alist-2))

(alist-merge-add '((1 2)(2 7)) '((1 3)(4 5))) ; ==> ((1 5))

---

我的交叉点解决方案：

#lang racket
(define (intersect set1 set2)
  (cond [(empty? set1) '()]
        [(empty? set2) '()]

        [(= (caar set1) (caar set2)) (cons (list (caar set1)
                                                 (+ (cadar set1)
                                                    (cadar set2)))
                                           (intersect (cdr set1) (cdr set2)))]
        [(< (caar set1) (caar set2)) (intersect (cdr set1) set2)]
        [else (intersect set1 (cdr set2))]))

#朗球拍
（定义（相交集合1集合2）
（条件[（空？设置1）'（）]
[（空？设置2）'（）]
[（=（caar集合1）（caar集合2））（cons（列表（caar集合1）
（+（地籍集1）
（地籍数据集2）
（相交（cdr集合1）（cdr集合2））]
[（<（caar集合1）（caar集合2））（交叉（cdr集合1）集合2）]
[其他（交叉集1（cdr集2））]）

我的十字路口解决方案：

#lang racket
(define (intersect set1 set2)
  (cond [(empty? set1) '()]
        [(empty? set2) '()]

        [(= (caar set1) (caar set2)) (cons (list (caar set1)
                                                 (+ (cadar set1)
                                                    (cadar set2)))
                                           (intersect (cdr set1) (cdr set2)))]
        [(< (caar set1) (caar set2)) (intersect (cdr set1) set2)]
        [else (intersect set1 (cdr set2))]))

#朗球拍
（定义（相交集合1集合2）
（条件[（空？设置1）'（）]
[（空？设置2）'（）]
[（=（caar集合1）（caar集合2））（cons（列表（caar集合1）
（+（地籍集1）
（地籍数据集2）
（相交（cdr集合1）（cdr集合2））]
[（<（caar集合1）（caar集合2））（交叉（cdr集合1）集合2）]
[其他（交叉集1（cdr集2））]）

不清楚这两个列表如何“相交”生成

”（（15））

我想比较第一个列表中每一对的第一个元素与第二个列表中每一对的第一个元素，然后在匹配时添加第二个元素：/你肯定有这种行为。（15）既不在第一个列表中，也不在第二个列表中<代码>（（12）（34）（56））（（9 10）（7 8）（5 6））==>（（5 6））是对交叉点和程序行为的正确理解。您的

会员？

只需使用

equal？

而不是

eq？

即可。是的。我需要为列表中第一个元素相同的对添加sec元素，并相应地生成输出列表。注意：此函数存在于列表SRFI库中：。对于生产质量集交集，您可能希望使用专用的集合数据类型，而不是列表。不清楚这两个列表如何“相交”以生成

”（（15））

我想比较第一个列表中每一对的第一个元素与第二个列表中每一对的第一个元素，然后在匹配时添加第二个元素：/你肯定有这种行为。（15）既不在第一个列表中，也不在第二个列表中<代码>（（12）（34）（56））（（9 10）（7 8）（5 6））==>（（5 6））是对交叉点和程序行为的正确理解。您的

会员？

只需使用

equal？

而不是

eq？

即可。是的。我需要为列表中第一个元素相同的对添加sec元素，并相应地生成输出列表。注意：此函数存在于列表SRFI库中：。对于生产质量集交集，您可能希望使用专用的集合数据类型，而不是列表。这将检查正确的一对。：/我需要检查成对的第一个元素，如果为真，则添加第二个元素。谢谢。@user2662909那不是十字路口。我添加了一个通用的

列表合并

和一个

列表合并添加

，可以满足您的需要。这将检查精确的一对。：/我需要检查成对的第一个元素，如果为真，则添加第二个元素。谢谢。@user2662909那不是十字路口。我添加了一个通用的

alimerge

和一个

alimerge add

，可以满足您的需要。