Решение нечетных повторений в схеме

Question

Я пытаюсь решить проблему с выводом только не повторяющихся элементов n списка в схеме. например, '(a b a a a c c) даст (a b).

Я реализовал это решение:

(define (remove L) 
    (if (null? L) 
     L 
     (let ((firstL (car L)) (restL (cdr L)))   
     (if (null? restL) 
      (cons firstL()) 
      (if (equal? firstL (car restL)) 
       (remove (cdr restL))     
       (cons firstL (remove restL))))))) 

Однако это также выводит элементы с нечетным числом повторений. например: (a b a a a c c) даст (a b a).

Я пытаюсь это исправить, но я не мог. Примером одного из решений, которые я попытался это:

(define (remove L) 
    (if (null? L) 
     L  
     (let ((result()) (firstL (car L)) (restL (cdr L)))   
     (if (null? restL) 
      (result)    
      (if (equal? firstL (car restL)) 
       (remove2 firstL restL)     
       (append ((list firstL) result)) 
       (remove cdr restL))))) 

    (define (remove2 x y) 
    (cond ((null? y) (remove x) 
        ((equal? x (car y)) (remove2 ((car y) (cdr y))))      
        (else (remove x))))) 

Пожалуйста, если кто-то может понять решение, запишите его.

Answer 1

Ваша вторая попытка имеет множество синтаксических ошибок. Я думаю, что если вы посмотрите на первую попытку и исправите одну синтаксическую ошибку с отсутствующим цитатой '(), вы почти получите ее, если сможете удалить последовательные элементы вместо одного. например. сделать

(trim-first '(a b c))  ; ==> (b c) 
(trim-first '(a a b c)) ; ==> (b c) 
(trim-first '(a a a b c)) ; ==> (b c) 

Тогда вы могли бы просто использовать, что вместо cdr:

(define (remove L) 
    (if (null? L) 
     L 
     (let ((firstL (car L)) (restL (cdr L)))   
     (if (null? restL) 
      (cons firstL '()) 
      (if (equal? firstL (car restL)) 
       (remove (trim-first restL))     
       (cons firstL (remove restL))))))) 

Я написал бы с cond сделать это льстит, хотя и держать подальше от нетрадиционного camelCase в пользу lisp-case :

(define (remove-runs lst) 
    (cond ((null? lst) '()) 
     ((null? (cdr lst)) lst) 
     ((equal? (car lst) (cadr lst)) (remove-runs (trim-first (cdr lst)))) 
     (else (cons (car lst) (remove-runs (cdr lst)))))) 

Answer 2

следующее решение в Racket (Производной схемы), используя рекурсию «named let». Переданный список делится на компоненты, как '((a)(b)(a a a)(c c)), а затем только те подсписки принимаются, которые имеют только один пункт:

(define (f l) 
    (let loop ((l (rest l))    ; first item removed from sent list 
      (ol '())  ; store repeating sequences here as separate lists 
      (temp (list(first l)))) ; keep first item in temp 
    (cond 
     [(empty? l)      ; end reached 
     ; (println (cons temp ol))  ; here temp+ol is '((c c)(a a a)(b)(a)) 
     (reverse 
     (flatten 
     (filter 
      (λ (x) (= 1 (length x))) ; take only those which have only one item 
      (cons temp ol))))] 
     [(equal? (first l) (first temp)) ; if item repeats, store together 
     (loop (rest l) 
      ol 
      (cons (first l) temp))] 
     [else       ; else put temp in ol & start new temp 
     (loop (rest l) 
      (cons temp ol) 
      (list (first l)))]))) 

Testing:

(f '(a b a a a c c)) 

Выход:

'(a b)