方案，检查两个列表中的任何内容是否相同

Question

如果两个列表中的任何内容相同，是否可以相互检查两个列表？

（清单'（嘿饼干猴子）'（苹果披萨饼干）==> #t

我试过类似的东西

(define (check-list list element)
  (let ((x list))
  (cond ((null? x) #f)
        ((eq? (car x) (car element)) #t)
        (else (check-list (cdr x) element))))
  (check-list list (cdr element)))

我知道这写得不正确，但不知道如何解决这个问题。

任何人都可以帮助我？

Answer 1

有时，用您的自然语言制定解决问题的过程会有所帮助。 让我们稍微简化一下问题。

如何检查一个元素是否包含在列表中？ 一种方法是将那个元素与列表中的每个元素进行比较，直到找到它为止——沿着你已经完成的路线的某处——但​​不完全是。 一个快速的草稿是：

(define (member? e lst)
  (cond ((null? lst) #f)       ; empty list doesn't contain e
        (or (eq? e <??>)       ; either the first element is e or
            (member? e <??>))) ; the rest of the list contains e

我们可以使用之前的知识来解决手头的实际问题。 我们知道如何在列表中搜索一个元素，现在我们需要在另一个列表中搜索列表中的每个元素。

(define (check-list lst1 lst2)
  (if (or (null? lst1) (null? lst2)) #f  ; empty list(s) share no elements
      (or (member? <??> <??>)            ; first element of lst1 in lst2?
          (member? <??> <??>))))         ; rest of lst1 in lst2?

<??>应该用适当的表达式替换以选择列表的部分。

Answer 2

类似于先前的答案，但利用逻辑原语：

(define (intersect? list1 list2)
  (and (not (null? list1))
       (or (member     (car list1) list2)
           (intersect? (cdr list1) list2))))

Answer 3

如果列表很长，您可能想要散列第一个列表，然后遍历第二个列表。 这将 R5RS 与 srfi-69 一起使用，对于小列表，您会得到一些开销，但是

(require srfi/69); alist->hash-table, hash-table-ref/default 
(define (intersect? list1 list2)
  (let ((hash (alist->hash-table (map (lambda (x) (cons x x)) list2) equal? )))
    (let loop ((list list1))
      (and (not (null? list))
           (or (hash-table-ref/default hash (car list) #f)
               (loop (cdr list)))))))

Answer 4

您可以使用memq检查第一个列表中的第一个元素是否在第二个列表中，如果不是，则递归检查第一个列表的其余部分是否在第二个列表中：

(define (check-list list1 list2)
  (cond ((null? list1) #f)
        ((memq (car list1) list2) #t)
        (else (check-list (cdr list1) list2))))

Answer 5

似乎有点混乱。 这里的“大”问题是如何确定两个列表是否至少共享一个元素，让我们为那个叫做element-in-common?编写一个过程element-in-common? . 解决这个问题之前，我们需要确定一个单一的元素在一个列表所属，那就是check-list应该做的（在你的代码的通知check-list接收作为第二个参数的元素，但你把它当作如果它是一个元素列表）。

您不必编写check-list过程，它已经存在并且称为member 。 掌握了这些知识，我们可以解决一个大问题——如何确定一个列表中的至少一个元素（我们称之为lst1 ）是否在另一个列表中（称为lst2 ）？

简单：我们使用递归遍历lst1每个元素，询问每个元素是否属于lst2 。 如果lst1只有一个元素是lst2的成员，我们返回#t 。 如果lst1中的元素lst1在lst2 ，我们返回#f 。 像这样的东西：

(define (element-in-common? lst1 lst2)
  (cond (<???>               ; is the first list empty?
         <???>)              ; then there are no elements in common
        ((member <???> lst2) ; is the current element of `lst1` in `lst2`?
         <???>)              ; then there IS an element in common
        (else                ; otherwise
         (element-in-common? <???> lst2)))) ; advance recursion

不要忘记测试您的代码：

(element-in-common? '(hey cookie monkey) '(apple pizza cookie))
=> #t

(element-in-common? '(hey cookie monkey) '(apple pizza pie))
=> #f

Answer 6

这是使用高阶函数的答案

在mit-schme

(define (check-list L1 L2)
 (apply boolean/or (map (lambda (x) (member? x L2)) L1)))

Answer 7

(define remove-item
  (lambda (lst ele)
    (if (null? lst)
        '()
        (if (equal? (car lst) ele)
            (remove-item (cdr lst) ele)
            (cons (car lst)
                  (remove-item (cdr lst) ele))))))