Valeur du dernier élément d'une liste

StackOverflow https://stackoverflow.com/questions/1175056

  •  19-09-2019
  •  | 
  •  

Question

comment obtenir la valeur du dernier élément d'une liste? Je l'ai noté que List.hd (ou .HEAD) retourner un article, alors que List.tl (ou .Tail) retourne une liste.

Est rev la liste et obtenir le hd la seule façon de contourner? Merci.

Était-ce utile?

La solution

Essayez cette fonction. Il utilise la récursivité, mais il est optimisé de façon à l'itération de toute façon depuis sa récursion queue. Dans tous les cas, il est fort probable que d'inverser rapidement la liste entière (à l'aide List.rev). 

let rec last = function
    | hd :: [] -> hd
    | hd :: tl -> last tl
    | _ -> failwith "Empty list."

La réponse de Pavel Minaev vaut vraiment la peine de prendre en compte, cependant. Néanmoins, l'algorithme ne peut être utile dans certains cas rares, et est le moyen le plus efficace d'aller à la tâche.

Autres conseils

En général, si vous avez besoin de faire cela, vous faites quelque chose de mal. Étant donné que F # les listes sont uniques liés, l'accès au dernier élément est coûteux - O(N), où N est la taille de list. Essayez de réécrire votre algorithme de sorte que vous accédez toujours le premier élément , pas le dernier (qui est O(1)). Si vous ne pouvez pas le faire, les chances sont bonnes que votre choix de list pour une structure de données n'a pas été correcte en premier lieu.

Une façon rapide et sale de le faire est à l'aide List.reduce. En supposant que la liste est appelée ls, 

let lastElement ls = List.reduce (fun _ i -> i) ls

En ce qui concerne l'efficacité, je suis d'accord avec Pavel.

Une version plus concise basée sur la réponse de Mitch: 

let lastItem = myList |> List.rev |> List.head

La liste des myList est envoyé à List.rev fonction. Le résultat est ensuite traité par List.head

D'accord, pas si efficace pour obtenir le dernier élément de list, ou toute autre séquence « dénombrable ». Cela dit, cette fonction existe déjà dans le module Seq, Seq.last.

En tant que développeur novice F #, je ne vois pas ce que le mal est en procédant comme suit 

let mylist = [1;2;3;4;5]

let lastValue = mylist.[mylist.Length - 1]

Impératif dans la nature? Oui, mais pas besoin de récursion.

La façon régulière de travailler avec des listes en F # est d'utiliser la récursivité. Le premier élément de la liste est la tête (évidemment) et le reste de la liste est la queue (comme s'opposer au dernier élément). Ainsi, lorsqu'une fonction reçoit une liste, il traite les tête et traite de manière récursive le reste de la liste ( tail ). 

let reversedList = List.rev originalList
let tailItem = List.hd reversedList

Je pense que vous pouvez simplement écrire 

list.[0..list.Length-1]

Vous pouvez appeler List.Head pour obtenir le premier élément d'une liste, de telle sorte que l'expression ci-dessous évalue true: 

let lst = [1;2;3;4;5]
List.head lst = 1

Toutefois, l'appel List.Tail retournera tous les éléments dans la liste après le premier élément, de telle sorte que l'expression ci-dessous est vrai: 

let lst = [1;2;3;4;5]
List.tail lst = [2;3;4;5]

Comme d'autres personnes l'ont mentionné, il n'y a pas un moyen efficace de F # pour obtenir la fin de la queue d'une liste, des listes de base ne sont tout simplement pas construits avec cette fonctionnalité. Si vous voulez vraiment obtenir le dernier élément que vous allez avoir à revenir sur votre première liste, puis prendre la nouvelle tête (qui était la queue précédente). 

let lst = [1;2;3;4;5]
(List.head (List.rev lst) ) = 5

Ci-dessous le code a bien fonctionné avec moi, j'ai un tableau d'entiers, veulent commencer à partir du 5ème élément, puis prenez moins le numéro de l'article 

Sum of [Array(xi) - Array(xi-5)] where i start at 5

Le code utilisé est: 

series |> Array.windowed 5
       |> Array.fold (fun s x -> 
                            (x |> Array.rev |> Array.head) -  (x |> Array.head) + s) 0
       |> float
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top