f # कुल रनिंग का अनुक्रम

Question

ठीक है, ऐसा लगता है कि यह आसान होना चाहिए, लेकिन मुझे बस यह नहीं मिल रहा है। यदि मेरे पास संख्याओं का अनुक्रम है, तो मैं चल रहे योगों से बना एक नया अनुक्रम कैसे उत्पन्न करूं? उदाहरण के लिए अनुक्रम [1; 2; 3; 4] के लिए, मैं इसे [1; 3; 6; 10] पर मैप करना चाहता हूं। एक उपयुक्त कार्यात्मक तरीके से।

Answer 1

उपयोग List.scan:

let runningTotal = List.scan (+) 0 >> List.tail 

[1; 2; 3; 4] 
|> runningTotal 
|> printfn "%A" 

Seq.scan आधारित कार्यान्वयन:

let runningTotal seq' = (Seq.head seq', Seq.skip 1 seq') ||> Seq.scan (+) 

{ 1..4 } 
|> runningTotal 
|> printfn "%A" 

Answer 2

> Seq.scan (fun acc n -> acc + n) 0 [1;2;3;4];; 
val it : seq<int> = seq [0; 1; 3; 6; ...] 

सूचियों के साथ

:

> [1;2;3;4] |> List.scan (fun acc n -> acc + n) 0 |> List.tail;; 
val it : int list = [1; 3; 6; 10] 

संपादित करें: दृश्यों के साथ एक और तरीका है:

let sum s = seq { 
    let x = ref 0 
    for i in s do 
     x := !x + i 
     yield !x 
} 

हाँ, वहाँ एक अस्थायी चर है, लेकिन मैं इसे और अधिक पठनीय लगता है (आप प्राप्त करना चाहते हैं, तो अग्रणी 0 से छुटकारा पाएं)।

Answer 3

सुनिश्चित नहीं हैं कि इस सबसे अच्छा तरीका है, लेकिन यह चाल

let input = [1; 2; 3; 4] 
    let runningTotal = 
    (input, 0) 
    |> Seq.unfold (fun (list, total) -> 
     match list with 
     | [] -> 
     None 
     | h::t -> 
     let total = total + h 
     total, (t, total) |> Some) 
    |> List.ofSeq 

Answer 4

एक और भिन्नता Seq.scan का उपयोग कर क्या करना चाहिए (Seq.skip 1 अग्रणी से छुटकारा पाता है शून्य):

> {1..4} |> Seq.scan (+) 0 |> Seq.skip 1;; 
val it : seq<int> = seq [1; 3; 6; 10]