將不同的函數映射到列表中的第一個元素和最後一個元素

Question

我有一個函數，我想將浮動列表轉換爲另一個元素，其中對於每個元素，我希望元素i的x％溢出到元素i + 1中

例如：

let p3 = [0.1; 0.2; 0.4; 0.2; 0.1] 

然後p3_s應該是：

[0.05; 0.15; 0.3; 0.3; 0.2] 

要做到這一點，我把每一個元素的一半，並把它添加到下一個元素。

• 0.1變成了0.05，因爲它給了0.05到下一個，沒有一個元素
• 0.2變成0.15，因爲它給了0.1到下一個，並從 第一
• 等
• 了0.05和終於0.1成爲0.2，因爲它從之前的 .01。沒有下一個元素。

現在我來到了這裏面，但僅適用於大小爲5的名單作品：

// create list 
let p3 = [0.1; 0.2; 0.4; 0.2; 0.1] 

let shiftList orgList shift =  

    // chop list up in tuples of what stays and what moves 
    let ms = orgList |> List.map (fun p-> (p * shift, p * (1.0-shift))) 

    // map new list 
    ms |> List.mapi (fun i (move, stay) -> 
     match i with 
     | 0 -> stay 
     | 4 -> stay + fst ms.[i-1] + move // note hardcoded 4 
     | _ -> stay + fst ms.[i-1]) 

// get shifted list 
shiftList p3 0.5 

現在的問題：

1）我如何使它匹配任何長度的列表？現在我在匹配表達式中對4進行了硬編碼，但我希望能夠接受任何長度列表。

我嘗試這樣做：

let shiftList orgList shift =  

    // chop list up in tuples of what stays and what moves 
    let ms = orgList |> List.map (fun p-> (p * shift, p * (1.0-shift))) 

    // find length 
    let last = orgList.Length - 1 

    // map new list 
    ms |> List.mapi (fun i (move, stay) -> 
     match i with 
     | 0  -> stay 
     | last -> stay + fst ms.[i-1] + move 
     | _  -> stay + fst ms.[i-1]) // now this one will never be matched 

但這不會把last爲4號，而是成爲i即使last上面已經聲明的變量。

那麼，我怎麼能匹配一個變量，以便我可以以不同的方式對待最後一個elmement？找到第一個很容易，因爲它在0.

2）你會如何做到這一點？我對F＃還是很新鮮，但還有許多事情我還不知道。猜測這裏的一般情況是：我如何將一個不同的函數映射到列表的第一個和最後一個元素，並且將其他函數映射到其他元素？

由於提前，

格特 - 揚

Answer 1

你想做的事：

let shiftList orgList shift =  

    // chop list up in tuples of what stays and what moves 
    let ms = orgList |> List.map (fun p-> (p * shift, p * (1.0-shift))) 

    // find length 
    let last = orgList.Length - 1 

    // map new list 
    ms |> List.mapi (fun i (move, stay) -> 
     match i with 
     | 0  -> stay 
     | last' when last' = last -> stay + fst ms.[i-1] + move 
     | _  -> stay + fst ms.[i-1]) // now this one will never be matched 

Answer 2

這裏是一個更實用的解決方案

let func (input:float list) = 
    let rec middle_end input_ = 
     match input_ with 
     |h::t::[] -> ((h/2.0)+t)::[] 
     |h::t::tt ->((h+t)/2.0)::(middle_end (t::tt)) 
     | _ -> [] //fix short lists 
    let fst = input.Head/2.0 
    fst::middle_end(input) 

而且，這個只需要一個單通過列表，而不是拉蒙的解決方案中的3個，以及較少的臨時存儲。

Answer 3

作爲編寫自己的遞歸函數的替代方法，您還可以使用內置函數。使用Seq.windowed可以很容易地解決問題。您還需要最後一個元素的特殊情況，但：

let p3 = [0.1; 0.2; 0.4; 0.2; 0.1] 

// Prefix zero before the list, pre-calculate the length 
let p3' = (0.0 :: p3) 
let l = p3.Length 

// Perform the transformation 
p3' 
|> Seq.windowed 2 
|> Seq.mapi (fun i ar -> 
    (if i = l - 1 then ar.[1] else ar.[1]/2.0) + ar.[0]/2.0) 
|> List.ofSeq 

Answer 4

使用List.scan：

let lst = [0.1; 0.2; 0.4; 0.2; 0.1] 
let len = (lst.Length-1) 

lst 
|> List.mapi (fun i e -> (i,e)) 
|> List.scan (fun (c,_) (i,e) -> if i = len then (0.0,e+c) else ((e/2.0),(e/2.0)+c)) (0.0,0.0) |> List.tail 
|> List.map snd 

Answer 5

又一個想法，

let bleh p3 = 
    match Seq.fold (fun (give,acc) i -> i*0.5,((i*0.5 + give) :: acc)) (0.0,[]) p3 with 
    |(give,h::t) -> give+h :: t |> List.rev 
    |(_,[]) -> []