Wert des letzten Elements einer Liste

Question

, wie der Wert des letzten Elements einer Liste zu bekommen? Ich habe festgestellt, dass List.hd (oder .head) einen Artikel zurückgeben, während List.tl (oder .Tail) gibt eine Liste.

Die folgende Liste rev und die HD der einzige Weg, um bekommen? Danke.

Answer 1

Versuchen Sie, diese Funktion. Es verwendet Rekursion, obwohl es seit seiner Endrekursion ohnehin Iteration optimiert wird. Auf jeden Fall ist es sehr wahrscheinlich schneller als die gesamte Liste Umkehren (mit List.rev).

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

Die Antwort von Pavel Minaev ist auf jeden Fall zu berücksichtigen, jedoch. Dennoch ist der Algorithmus anzubieten in einigen seltenen Fällen nützlich sein kann und ist der effizienteste Weg, um die Aufgabe zu gehen.

Answer 2

In der Regel, wenn Sie dies tun müssen, sind Sie etwas falsch zu machen. Da F # Listen Einzelvernetzt sind, ist das letzte Element Zugriff auf teure - O(N), wobei N eine Größe von list ist. Versuchen Sie Ihren Algorithmus neu zu schreiben, so dass Sie immer den Zugriff auf zuerst -Element, nicht die letzte (das ist O(1)). Wenn Sie nicht so tun können, stehen die Chancen gut, dass Ihre Wahl list für eine Datenstruktur in erster Linie nicht korrekt war.

Answer 3

Eine schnelle und schmutzige Art und Weise, es zu tun ist durch List.reduce verwenden. Unter der Annahme der Liste heißt ls,

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

Wie für Effizienz, stimme ich mit Pavel.

Answer 4

Eine kurze Version basiert auf Mitch Antwort:

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

Die myList Liste gesendet Funktion List.rev. Das Ergebnis wird dann durch List.head verarbeitet

Answer 5

Zugegeben, nicht so effizient, das letzte Element list, oder jeden anderen „zählbaren“ -Sequenz zu erhalten. Das heißt, diese Funktion ist bereits in der Seq Modul, Seq.last.

Answer 6

Als Anfänger F # Entwickler, ich sehe nicht, was der Schaden ist die folgende

dabei

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

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

Imperative in der Natur? Ja, aber keine Notwendigkeit für Rekursion.

Answer 7

Die regelmäßige Art und Weise mit Listen in F # zu arbeiten, ist die Rekursion zu verwenden. Das erste Element in einer Liste ist der Kopf (offensichtlich) und der Rest der Liste ist der Schwanz (im Gegensatz zu dem letzten Punkt widersprechen). Wenn also eine Funktion, um eine Liste recieves es verarbeitet den Kopf und verarbeitet dann rekursiv den Rest der Liste (den Schwanz ).

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

Answer 8

Ich denke, man kann einfach schreiben

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

Answer 9

Sie können List.Head rufen Sie das erste Element einer Liste zu bekommen, so dass der folgende Ausdruck ergibt true:

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

Allerdings rufe List.Tail jedes Element in der Liste zurück nach dem ersten Elemente, so dass der folgende Ausdruck wahr ist:

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

Wie einige andere Leute schon erwähnt haben, es in F # keine effiziente Art und Weise ist das hintere Ende einer Liste, Grundlisten werden nicht mit dieser Funktionalität im Auge, nur um gebaut. Wenn Sie wirklich das letzte Element erhalten wollen Sie gehen, um Ihre Liste zuerst rückgängig zu machen, und dann den neuen Kopf nehmen (die der vorherige Schwanz war).

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

Answer 10

Im Folgenden Code arbeitete mit mir in Ordnung, ich habe eine Reihe von ganzen Zahlen, will aus dem 5. Elemente gestartet wird, dann nehmen Sie es minus die Artikelnummer

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

Der verwendete Code ist:

series |> Array.windowed 5
       |> Array.fold (fun s x -> 
                            (x |> Array.rev |> Array.head) -  (x |> Array.head) + s) 0
       |> float