домашнее задание по схеме

Question

как разработать содержание функции, которая вводит один список атомов лат и который возвращает содержание лат. Таким образом, содержание «(a b c a b c d d) есть» (a b c d).

Answer 1

Процедура content ниже должна дать вам то, что вам нужно.

(define (work x y)
  (if (null? (cdr x))
      (if (in? (car x) y)
          y 
          (cons (car x) y))
      (if (in? (car x) y)
          (work (cdr x) y)
          (work (cdr x) (cons (car x) y)))))

(define (in? x y)
  (if (null? y)
      #f
      (if (equal? x (car y))
          #t
          (in? x (cdr y)))))

(define (content x) (work x (list)))

Процедура content принимает список в качестве параметра. Он отправляет список в другую процедуру с именем work. Эта процедура обрабатывает список и добавляет элементы в списке в новый список (если их еще нет в новом списке). Процедура work использует еще одну процедуру под названием in, которая проверяет, является ли элемент членом списка.

Мое решение по сути делит вашу проблему на две подзадачи и использует процедуры, которые работают на более низком уровне абстракции, чем ваша первоначальная проблема.

Надеюсь, это поможет.

Answer 2

Как насчет маленького интриганского стиля,

(define (rember-all a lat)
  (cond
    ((null? lat) '())
    ((eq? a (car lat)) (rember-all a (cdr lat)))
    (else (cons (car lat) (rember-all a (cdr lat))))))

(define (content lat)
  (cond
    ((null? lat) '())
    (else (cons (car lat)
                (content (rember-all (car lat) (cdr lat)))))))

Answer 3

Это PLT Схема решения:

(define (is_exists list element)
 (cond
   [(empty? list) false]
   [else
     (cond 
       [(= (first list) element) true]
       [else (is_exists (rest list) element)])]))

(define (unique list target)
  (cond 
    [(empty? list) target]
    [else
     (cond 
       [(is_exists target (first list)) (unique (rest list) target)]
       [else (unique (rest list) (cons (first list) target))])]))

(define (create_unique list)
        (unique list empty))

Проверьте это:

> (define my_list (cons '1 (cons '2 (cons '3 (cons '2 (cons '1 empty))))))
> my_list
(list 1 2 3 2 1)
> (create_unique my_list)
(list 3 2 1)

Answer 4

(define (remove-duplicates aloc)
  (cond
    ((empty? aloc) '())
    (else (cons (first aloc)
                (remove-duplicates
                 (filter (lambda (x)
                           (cond
                             ((eq? x (first aloc)) #f)
                             (else #t)))
                         (rest aloc)))))))

Answer 5

Следующая функция берет список и возвращает новый список, содержащий только уникальные входные данные своего аргумента с использованием рекурсии:

(defun uniq (list)
    (labels ((next (lst new)
                (if (null lst)
                    new
                    (if (member (car lst) new)
                        (next   (cdr lst) new)
                        (next   (cdr lst) (cons (car lst) new))))))
        (next list ())))

Как уже упоминалось в комментариях, обычный lisp уже имеет эту функцию:

(defun uniq (list)
    (remove-duplicates list))

Answer 6

Начните с процедуры, которая просто создает копию переданного списка (очень легко сделать):

(define (unique-elements seq)
  (define (loop ans rest)
    (cond ((null? rest) ans)
          (else
           (loop (cons (car rest) ans)
                 (cdr rest)))))
  (loop '() seq))

Чтобы гарантировать, что элементы выходного списка уникальны, мы должны пропустить CONS, если глава REST уже является членом ANS. Поэтому мы добавляем еще одно условие, чтобы сделать это:

;;; Create list containing elements of SEQ, discarding duplicates.
(define (unique-elements seq)
  (define (loop ans rest)
    (cond ((null? rest) ans)
          ((member (car rest) ans)  ; *new*
           (loop ans (cdr rest)))   ; *new*
          (else
           (loop (cons (car rest) ans)
                 (cdr rest)))))
  (loop '() seq))