Comment est le filtre de mise en œuvre?

Besoin d'aide sur celui-ci à l'aide de schéma de fonction
Retourne une liste contenant tous les éléments d'une liste donnée que répondre à un prédicat. Par exemple, (filter (lambda (x) (< x 5)) '(3 9 5 8 2 4 7)) doit retourner (3 2 4).

S'il vous plaît essayer d'expliquer ton problème plus clairement. Vous êtes à essayer de comprendre comment mettre en œuvre la fonction de filtre?
Est-ce devoirs? Aussi, qu'avez-vous déjà essayé?
Je suis obligé de downvote la question jusqu'à ce qu'il explique ce qu'est le problème. La question actuellement qu'a une description de la fonction de filtre. Je ne peux pas dire ce que l'affiche a de la difficulté avec encore.
C'est une implémentation du détail qui est sujet à changement et dépend de votre fournisseur ;D

OriginalL'auteur feichangh | 2012-02-27

  1. 6

    filterb - juste au cas où il y a déjà une fonction appelée filtre.

    (define filterb
    (lambda (pred lst)
      (cond ((null? lst) '())
            ((pred (car lst)) (cons (car lst) (filterb pred (cdr lst))))
            (else (filterb pred (cdr lst))))))

    Ici, il est, mais je suis sûr qu'il peut être fait pour regarder plus agréable.

    OriginalL'auteur wmercer

  2. 4

    Un moyen simple d'écrire le filter procédure:

    (define (my-filter pred lst)
  (cond ((null? lst) null)
        ((pred (first lst))
         (cons (first lst) (my-filter pred (rest lst))))
        (else (my-filter pred (rest lst)))))

    Avis que j'ai nommé la procédure my-filter, car intégré dans la procédure appelée filter existe déjà et ce n'est pas une bonne idée de remplacer sa définition.

    OriginalL'auteur Óscar López

  3. 1

    La définition classique de filtre est la (non-queue) récursive que d'autres affiches ont montré—et c'est important de comprendre que l'on. Toutefois, si vous êtes l'écrire comme une fonction de la bibliothèque, il est utile de comprendre comment le faire avec de la queue de récursivité, de sorte que vous ne faites pas sauter la pile ou le tas avec de longues listes:

    (define (filter pred? list)
  (define (filter-aux result current-pair xs)
    (cond ((null? xs)
           result)
          ((pred? (car xs))
           (set-cdr! current-pair
                     (cons (car xs)
                           '()))
           (filter-aux result
                       (cdr current-pair)
                       (cdr xs)))
          (else
           (filter-aux result
                       current-pair
                       (cdr xs)))))
  (let ((init (cons 'throw-me-out '())))
    (filter-aux (cdr init) init list)))

    Ou, à l'aide de la let loop syntaxe:

    (define (filter pred? xs)
  (let ((result (cons 'throw-me-out '()))
        (xs xs))
    (let loop ((current-pair result))
      (cond ((null? xs)
             (cdr result))
            ((pred? (car xs))
             (set-cdr! current-pair
                       (cons (car xs) '()))
             (loop (cdr current-pair) (cdr xs)))
            (else
             (loop current-pair (cdr xs)))))))

    OriginalL'auteur Luis Casillas

  4. 0

    Essayer de définir filter comme une instance de plier à droite:

    (define (my-filter op xs)
        (fold-right
           (lambda (next result) ...)
           '()
           xs))

    Astuce: utilisez if et cons

    OriginalL'auteur gcbenison

  5. 0

    Pour une autre queue-récursive filter qui ne nécessite pas mutable listes, vous pouvez utiliser quelque chose comme ceci:

    (define (my-filter f lst)
  (define (iter lst result)
    (cond
      ((null? lst) (reverse result))
      ((f (car lst)) (iter (cdr lst)
                           (cons (car lst) result)))
      (else (iter (cdr lst)
                  result))))
  (iter lst '()))

    Inverse vous oblige à marcher sur la liste une deuxième fois, mais il peut être mis en œuvre en O(n) avec la constante de temps d'espace de pile sur immuable listes, de sorte que le temps global est toujours en O(n).

    OriginalL'auteur Retief