0
votes

Comment créer une nouvelle liste dans une fonction F # récursive?

Je crée une fonction récursive qui examinera une liste existante et créera une nouvelle liste mais sans doublons. Je retire la tête de la liste existante et je vérifie la nouvelle liste pour voir s'il contient cet élément. Si ce n'est pas le cas, alors je l'ajoute parce que je sais que ce n'est pas un duplicata.

Jusqu'à présent, j'ai ce code. P>

let newList = []
let rec filtered inputList = 
  match inputList with
    | [] -> []
    | h::t -> if List.contains h newList then filtered t else h::(filtered t)


1 commentaires

Si vous faites cela pour un but éducatif, continuez s'il vous plaît continuer, mais soyez conscient que list.distinct existe.


3 Réponses :


1
votes

Dans la programmation de style fonctionnel Normalement, vous n'appeleriez-vous pas à une liste, mais le transmettez-le plutôt dans la fonction récursive et de le renvoyer à la fin comme celui-ci.

let distinct list =
    let rec filtered inputList outputList = 
      match inputList with
        | [] -> outputList
        | h::t when List.contains h outputList -> filtered t outputList
        | h::t -> filtered t (h::outputList)

    filtered list []

printf "%A" (distinct [1; 2; 2; 3]) // [3; 2; 1]


0 commentaires

1
votes

La solution de Dee-See a une belle propriété qui est qu'elle est récursive de la queue. Cela signifie qu'il peut facilement gérer de très grandes listes.

Toutefois, si vous êtes nouveau à la programmation fonctionnelle, il peut être plus facile de démarrer avec une version plus simple, qui prend une liste d'entrée et renvoie la liste de sortie directement comme résultat.

Ceci est en fait très proche de ce que vous avez. La logique que vous devez implémenter est que:

  • S'il y a un élément dans le reste de la liste, alors nous le sautons
  • Si l'élément n'est pas dans le reste de la liste, nous l'appendons

    Pour cela, vous n'avez pas besoin de vous NewList . Vous pouvez simplement vérifier list.contains ht , car cela vous assure que vous ne renvoyez que la dernière occurrence de chaque élément dupliqué: xxx

    la seule différence de Votre fonction est à l'état. La solution de Dee-See est plus sophistiquée, mais elle atteint le même résultat. Comme dans l'autre réponse, vous pouvez le faire plus élégamment à l'aide de quand : xxx


0 commentaires

0
votes

Autre moyen:

let rec distinct = function
    | []   -> []
    | h::t -> h :: distinct (List.filter ((<>) h) t)


0 commentaires