F#中未知长度的列表列表转置实现方法咨询

First, let's clarify your original function—right now, firstElements actually returns the first sublist of your input (or 0.00 if the input is empty), not a list of the first elements from each sublist. If you want to extract the first element from every sublist into a separate list, you'd use something like this:

let extractFirstElements list =
    list |> List.map (fun sublist ->
        match sublist with
        | head::_ -> head
        | [] -> 0.00) // Default value for empty sublists

That would take your biglist and return [1; 4; 7] (adjusting for integers instead of floats, since your example uses ints).

Now, for the main question: transposing the list so elements at the same index end up in the same sublist. This is a classic operation, and we can implement it efficiently and safely in F# with a few approaches depending on how you want to handle edge cases like sublists of varying lengths.

Basic Transpose (Assuming Uniform Sublist Lengths) #

If you know all your sublists are the same length, this recursive implementation works cleanly:

let rec transpose list =
    match list with
    | [] -> []
    | []::_ -> [] // All sublists are empty, stop recursion
    | rows ->
        // Extract the first element from each sublist
        let heads = List.map List.head rows
        // Get the remaining elements of each sublist
        let tails = List.map List.tail rows
        // Recursively transpose the tails and prepend the heads
        heads :: transpose tails

Testing this with your biglist:

let biglist = [[1;2;3];[4;5;6];[7;8;9]]
transpose biglist // Returns [[1;4;7];[2;5;8];[3;6;9]]

Safe Transpose (Handling Varying Sublist Lengths) #

If your sublists might be different lengths, the basic version will throw an error when it hits an empty sublist while others still have elements. To avoid this, we can stop transposing as soon as any sublist is empty (effectively truncating to the shortest sublist):

let safeTranspose list =
    let rec transposeHelper remaining =
        match remaining with
        | [] -> []
        | rows ->
            // Check if any sublist is empty
            if List.exists List.isEmpty rows then
                []
            else
                let heads = List.map List.head rows
                let tails = List.map List.tail rows
                heads :: transposeHelper tails
    transposeHelper list

Example with mixed lengths:

let mixedList = [[1;2];[3;4;5];[6]]
safeTranspose mixedList // Returns [[1;3;6]]

Transpose with Default Value Padding #

If you want to fill missing elements with a default value instead of truncating, you can first pad all sublists to the length of the longest one, then transpose:

let transposeWithDefault defaultValue list =
    // Find the longest sublist length
    let maxLength = list |> List.map List.length |> List.max
    // Pad each sublist to maxLength with the default value
    let paddedLists = list |> List.map (fun sublist ->
        sublist @ List.replicate (maxLength - List.length sublist) defaultValue)
    // Use the basic transpose on padded lists
    let rec transpose = function
        | [] -> []
        | []::_ -> []
        | rows -> List.map List.head rows :: transpose (List.map List.tail rows)
    transpose paddedLists

Example usage:

transposeWithDefault 0 mixedList // Returns [[1;3;6];[2;4;0];[0;5;0]]

Efficient Tail-Recursive Version #

For very large lists, a tail-recursive implementation avoids stack overflow by accumulating results as we go:

let transposeTailRec list =
    let rec transposeHelper acc remaining =
        match remaining with
        | [] -> List.rev acc // Reverse to restore original order
        | []::_ -> List.rev acc
        | rows ->
            let heads = List.map List.head rows
            let tails = List.map List.tail rows
            transposeHelper (heads :: acc) tails
    transposeHelper [] list

This works just like the basic transpose but is more efficient for large datasets.

内容的提问来源于stack exchange，提问作者Code Guy