Löschen-element aus der Liste in Scheme

Ich habe die Liste in dieser form

( (1 3) (2 2) (3 1) (4 5) (5 1)))

und ich möchte ein Element löschen lassen sagen (3 1)

So wird das Ergebnis

( (1 3) (2 2) (4 5) (5 1)))

Ich geschrieben habe, so etwas wie dieses, und ich weiß nicht, warum es nicht richtig läuft.

(define (deleteItem list item)
  (cond
    ((equal? item (car  list)) (cdr list))
    (cons (car  list)(deleteItem(cdr list) item))))

Beachten Sie, dass die Schläger integrierten remove (was einige der Antworten, die sich darauf beziehen) entfernt nur die erste vorkommen des Elements. Wenn Sie entfernen wollte alle von Ihnen, Sie müssten remove*. Ihre aktuelle code näher an remove als remove*, aber es ist nicht klar, ob Sie sich entfernen wollte, nur das erste vorkommen, oder alle von Ihnen.

InformationsquelleAutor dionysosz | 2013-11-11

3

Gibt es eine eingebaute Funktion dafür, es nennt sich entfernen:
```
(define lst
  '((1 3) (2 2) (3 1) (4 5) (5 1)))

(remove '(3 1) lst)
=> '((1 3) (2 2) (4 5) (5 1))
```
... Aber ich denke, Sie implementieren müssen, um es von Grund auf. Einige Vorschläge für Ihren code:
- Sollten Sie nicht verwenden list als parameter den Namen, das werde Zusammenstoß mit einem built-in-Funktion. Nennen wir es lst statt
- Ihnen fehlt die base-case-notwendige form, die am meisten Liste Prozeduren: was passiert, wenn die Liste leer ist?
- Du bist auch fehlt die else Teil in die Letzte Bedingung
Mit allen oben genannten fixes statt, die Prozedur funktioniert:
```
(define (deleteItem lst item)
  (cond ((null? lst)
         '())
        ((equal? item (car lst))
         (cdr lst))
        (else
         (cons (car lst) 
               (deleteItem (cdr lst) item)))))

(deleteItem lst '(3 1))
=> '((1 3) (2 2) (4 5) (5 1))
```
InformationsquelleAutor Óscar López
1

Das Verfahren ist bereits vorhanden:
```
(remove '(3 1) '((1 3) (2 2) (3 1) (4 5) (5 1))))
```
Sonst deine Vorgehensweise sollte wie folgt Aussehen:
```
(define (deleteItem item list) 
  (cond 
    ((empty? list) '())
    ((equal? item (car list)) (cdr list))
    (else (cons (car list) (deleteItem item (cdr list))))))
```
Die Sie verpasst haben:
- basisfall (leere? Liste)
- die "else" in der letzten Klausel
solltest du auch nicht verwenden Liste als variable Namen, weil es die Schatten der build-in-Verfahren list (aber es funktioniert).

InformationsquelleAutor uselpa

1) wenn betrachten Sie die input-Liste können Sie eine einfache Liste, oder Sie wollen einfach nur zu löschen das Element in der obersten Ebene einer verschachtelten Liste
zum Beispiel:

delete 2 from (1 2 3 4) will return (1 2 3)
delete 2 from (1 2 3 (2 3) 3 2 4) will return (1 3 (2 3) 3 4)

wie wir sehen können, das 2. Beispiel von oben, es einfach zu löschen das Element in der obersten Ebene der verschachtelten Liste, innerhalb der inneren Liste haben, nehmen wir nicht ändern.

dieser code sollte sein:

(define (deleteitem list1 item) 
( cond
    ((null? list1) ’())
    ((equal? (car list1) item) (deleteItem (cdr list1) item)) 
    (else (cons (car list1) (deleteitem (cdr list1) item)))
))

2) wenn betrachten Sie die input-Liste kann eine verschachtelte Liste

Beispiel:

input list: (1 2 3 (3 2 (2 4 (2 5 6) 2 5 6) 2 4) 2 3 (2 3 4))

löschen und das element 2 in der input-Liste

the output list should be: (1 3 (3 (3 (5 6) 5 6) 4) 3 (3 4))

und der code sollte sein:

(define (delete2 list1 item) 
    ( cond
    ((null? list1) '())
    ((pair? (car list1)) (con (delete2 (car list1) item) (delete2 (cdr list1) item)))
    ((equal? (car list1) item) (delete2 (cdr list1) item)) 
    (else (cons (car list1) (delete2 (cdr list1) item)))
))

InformationsquelleAutor Jie

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.