Régime: Supprimer dupliqué numéros de la liste

J'ai écrit ce code pour créer une liste de fr nombre d'arguments donnés

(define (create-list . e)
   e)

Mais j'en ai besoin pour supprimer un duplicata de numéros de la liste à l'intérieur de ce bloc lui-même.

J'ai essayé et cherché pendant des heures et ne peut pas trouver une solution sans passer des dizaines de lignes de code sur d'autres blocs.

Par exemple, disons que mon entrée est

(create-list . 2 2 3 5 5 )

J'ai besoin de la liste créée, '(2 3 5) et de ne pas '(2 2 3 5 5 )...

L'ordre des nombres n'a pas d'importance.

Voir aussi stackoverflow.com/a/8651932/450148

OriginalL'auteur spacing | 2011-12-05

  1. 4

    Fondamentalement, vous avez besoin de faire quelque chose comme:

    (define (create-list . e) (dedupe e))

    Je ne peux penser à une, très simple, mais probablement inefficace façon de le faire:

    (define (dedupe e)
  (if (null? e) '()
      (cons (car e) (dedupe (filter (lambda (x) (not (equal? x (car e)))) 
                                    (cdr e))))))

    Si vous ne pouvez pas utiliser les fonctions comme filter, vous pouvez faire un vous-même:

    (define (my-filter pred ls) 
  (cond ((null? ls) '())
        ((pred (car ls)) (cons (car ls) (my-filter pred (cdr ls))))
        (else (my-filter pred (cdr ls)))))
    serait-il possible de créer le même code cdr/voiture/cons et les procédures? (Pas de filtre/tête/queue)
    Oui. En fait, head et tail sont déjà juste car et cdr respectivement (trop de Haskell sur mon esprit).
    Notez également que ma syntaxe peut être un peu hors-j'ai seulement été en utilisant des Haskell beaucoup récemment et je n'ai jamais utilisé stk, qui est une ancienne interpréteur scheme.
    Désolé, je n'étais pas habitué à cela. Viens de vérifier le fichier de réponse. Merci!!!!
    En général, filter prend une liste et d'un prédicat (une fonction qui renvoie true ou false), et renvoie une liste contenant uniquement les éléments pour lesquels le prédicat retourné véritable. Vous pouvez penser que c'est un select-where.

    OriginalL'auteur Tikhon Jelvis

  2. 2

    Celui-ci est plus rapide:

    (define (remove-duplicates l)
  (cond ((null? l)
         '())
        ((member (car l) (cdr l))
         (remove-duplicates (cdr l)))
        (else
         (cons (car l) (remove-duplicates (cdr l))))))

    Mais encore mieux,
    mit-un dispositif de supprimer les doublons, qui fait exactement ce que vous voulez.

    OriginalL'auteur abo-abo

  3. 0

    Le plus efficace (en parcourant la liste une fois) pour ce faire consiste à définir une fonction qui va par le biais de la liste élément par élément. La fonction stocke une liste dont les éléments sont déjà dans les de-dupe de la liste.

    Un avantage de cette solution sur @Tikhon Jelvis, c'est que les éléments de la liste n'ont pas besoin d'être dans l'ordre, pour être dédupliquées.

    Donné une fonction elem, qui dit que si a est un élément de l:

    (define (elem? a l)
      (cond ((null? l) #f)
            ((equal? a (car l)) #t)
            (else (elem? a (cdr l)))))

    Nous pouvons parcourir la liste, le stockage de chaque élément que nous n'avons pas vu avant: 

    (define (de_dupe l_remaining already_contains)
   (cond ((null? l_remaining) already_contains)
         ((elem? (car l_remaining) already_contains) (de_dupe (cdr l_remaining) already_contains))
         (else (de_dupe (cdr l_remaining) (cons (car l_remaining) already_contains)))))

    Remarque: pour plus d'efficacité, il renvoie les éléments dans l'ordre inverse

    Ma version besoin les éléments dans n'importe quel ordre? Autant que je sache, il n'a pas.
    Jelvis: Il a regardé comme ça; je ne peux pas le faire revenir valeurs propres, cependant. Exemple: "(créer une liste de 3 5 4 3 4 6) le terme" revenus "(3 3)"
    Ce n'était pas à cause de l'ordre, c'est parce que j'ai laissé par mégarde un pas dans le filtre du prédicat. J'ai corrigé maintenant.

    OriginalL'auteur amindfv

  4. 0
    (define (delete x)
(cond
((null? x) x)
((= (length x) 1) x) | ((null? (cdr x)) x)
((= (car x) (cadr x)) (delete (cdr x)))
(#t (cons (car x) (delete (cdr x))))
)
)

    OriginalL'auteur Icorisa