एफ # में ग्रुप योग - अनुक्रमों के साथ आसान, क्या यह सूचियों के साथ संभव है?

Question

एक समूह आईडी/मूल्य tuples के एक दृश्य को देखते हुए यह समूह योग की गणना करने के लिए आसान (काफी उसी तरह मैं के साथ सी # और LINQ यह करना होगा) था:

let items = ["g1",5; "g2",10; "g1",20] 

let groupsums = 
    items 
    |> Seq.groupBy (fun x -> fst x) 
    |> Seq.map (fun (g, s) -> Seq.fold (fun acc x -> acc + snd x) 0 s) 

लेकिन एफ # करने के लिए नया किया जा रहा है, मैं सूचियों के साथ ऐसा करने का कोई तरीका नहीं देख सकता है। क्या मुझे म्यूटेबल वैरिएबल का उपयोग करना है, या सूचियों के साथ ऐसा करने का एक कार्यात्मक तरीका है?

Answer 1

List.groupBy में कोई निर्मित नहीं है। प्रकारों में निर्मित कई एफ # में फ़ंक्शन हैं जिन्हें कहा गया फ़ंक्शन का सीक संस्करण असाइन किया गया है। जैसे list.fs

let inline sumBy f (list : list<_>) = Seq.sumBy f list

से मैं बहुत यकीन है कि एफ # के डिजाइनर क्या स्थिरता की खातिर और क्या सूखी की खातिर के लिए छोड़ के लिए नकल करने के बारे में कई विचार विमर्श किया है। मैं व्यक्तिगत रूप से चाहता हूं कि वे DRY के साथ फंस जाएं।

यदि आप अपना खुद का "कार्यात्मक" बनाना चाहते हैं List.groupBy मैं मानचित्र और सूची का उपयोग करूंगा।

let groupBy list = 
    list 
    |> List.fold (fun group (g, x) -> 
     match group |> Map.tryFind g with 
     | Some(s) -> group |> Map.remove g |> Map.add g (x::s) 
     | None -> group |> Map.add g [x] 
     ) Map.empty 
    |> Map.toList 

let groupsums = groupBy >> List.map (snd >> List.sum) 

यदि आपको केवल योग की आवश्यकता है तो आप रखरखाव सूचियों को छोड़ सकते हैं।

let groupAndSumBy list = 
    list 
    |> List.fold (fun group (g, x) -> 
     match group |> Map.tryFind g with 
     | Some(s) -> group |> Map.remove g |> Map.add g (x + s) 
     | None -> group |> Map.add g x 
     ) Map.empty 
    |> Map.toList 
    |> List.map snd 

आउटपुट

> groupsums items;; 
val it : int list = [25; 10] 

> groupAndSumBy items;; 
val it : int list = [25; 10] 

Answer 2

gradbot समाधान के साथ कुछ भी गलत नहीं है, वहीं मैं सिर्फ यह सरल रखने के लिए और Seq.toList का उपयोग करते वांछित सूची में वापस दृश्यों कन्वर्ट करने के लिए चाहते हैं। तो आप के रूप में अपनी परिभाषा को फिर से लिखने सकता है:

let groupsums = 
    items 
    |> Seq.groupBy fst 
    |> Seq.toList 
    |> List.map (fun (_,s) -> Seq.sumBy snd s) 

Answer 3

हालांकि मैं, KVB के सुझाव का प्रयोग करेंगे आप अपने खुद के रोल करने जा रहे हैं, मैं Dictionary बजाय Map उपयोग करने का सुझाव। मेरे परीक्षण में यह कम से कम 400% तेज था।

let groupBy f (list:list<_>) = 
    let dict = Dictionary() 
    for v in list do 
    let k = f v 
    match dict.TryGetValue(k) with 
    | true, l -> dict.[k] <- v :: l 
    | _ -> dict.Add(k, [v]) 
    dict |> Seq.map (|KeyValue|) |> Seq.toList 

या:

let groupSumBy (list:list<_>) = 
    let dict = Dictionary() 
    for k, v in list do 
    match dict.TryGetValue(k) with 
    | true, n -> dict.[k] <- v + n 
    | _ -> dict.Add(k, v) 
    dict |> Seq.map (|KeyValue|) |> Seq.toList 

रेफरी संस्करण द्वारा:

let groupSumBy (list:list<_>) = 
    let dict = Dictionary() 
    let mutable n = 0 
    for k, v in list do 
    match dict.TryGetValue(k, &n) with 
    | true -> dict.[k] <- v + n 
    | false -> dict.Add(k, v) 
    dict |> Seq.map (|KeyValue|) |> Seq.toList