एफ #

Question

साथ नंबरों की सूची मैं #

च

मैं नंबरों की सूची की कार्तीय उत्पादों की गणना करने की कोशिश कर रहा हूँ करने के लिए नया हूँ की कार्तीय उत्पाद गिना जा रहा है। मैंने इसे "उधार लिया"।

let xs = [1..99] 
let ys = [1..99] 
seq {for x in xs do for y in ys do yield x * y} 

क्या कोई बेहतर या अधिक सुरुचिपूर्ण तरीका है?

गैरी

Answer 1

एक और possibiltiy सूची मॉड्यूल द्वारा प्रदान किया जाएगा कार्यक्षमता के आधार पर समस्या से निपटने के लिए:

let xs = [1..99] 
let ys = [1..99] 
let zs = xs |> List.collect (fun x -> ys |> List.map (fun y -> x*y)) 

जो .concat करने के लिए अतिरिक्त कॉल से बचा जाता है और यह भी काम करना चाहिए।

लेकिन मैं आपके समाधान के साथ रहना चाहता हूं। यह सबसे पठनीय होना चाहिए जो असली मैच विजेता है। (बस कोड को ज़ोर से पढ़ने की कोशिश करें। आपका पूरी तरह समझ में आता है और नोडोरिन या मेरा नहीं हैं।)

Answer 2

वहाँ वास्तव में है एक थोड़ा और अधिक सुरुचिपूर्ण तरीका (कम से कम कार्यात्मक अर्थ में) जो कार्यों कि List वर्ग के भीतर मौजूद उपयोग करता है, कार्तीय उत्पादों की गणना करने के। (वहाँ दृश्यों को शामिल करने की कोई जरूरत कम से कम सीधे नहीं है या यहाँ लूप होता है,।)

इस प्रयास करें:

let xs = [1..99] 
let ys = [1..99] 
xs |> List.map(fun x -> ys |> List.map(fun y -> x * y)) |> List.concat 

थोड़ा लंबा बेशक, हालांकि अधिक शैली में कार्यात्मक, यह प्रतीत होता है।

Answer 3

अस्वीकरण: मेरे पास वर्तमान F # स्थापित मशीन नहीं है, इसलिए मैं अपने कोड का परीक्षण नहीं कर सकता। असल में, हालांकि, अगर आप हास्केल से sequence चोरी, आप अपने कार्यक्रम के रूप में

let cartesian = sequence >> List.map product 

लिखने और

cartesian [[1..99]; [1..99]] 

यहाँ sequence लिखने का तरीका बताया गया के रूप में यह चला सकते हैं। यह आपके द्वारा लिखे अनुक्रम अभिव्यक्ति का एक सामान्य संस्करण है। यह सिर्फ असीमित संख्या में सूचियों को संभालता है: { for x in xs do for y in ys do for z in zs ... yield [x;y;z;...] }।

let rec sequence = function 
    | [] -> Seq.singleton [] 
    | (l::ls) -> seq { for x in l do for xs in sequence ls do yield (x::xs) } 
// also you'll need product to do the multiplication 
let product = Seq.fold_left1 (*) 

तो फिर आप अपने प्रोग्राम लिख सकते हैं के रूप में

let cartesian xs ys = [xs; ys] |> sequence |> List.map product 
// ... or one-argument, point-free style: 
let cartesian' = sequence >> Seq.map product 

आप List रों करने के लिए कुछ Seq रों बदलने के लिए हो सकता है।

हालांकि, आपकी गैर-सामान्य सूची समझ का अर्थ अनुमान लगाने वाले लोगों की संख्या शायद sequence नाम पहचानने से कहीं अधिक है, इसलिए आप सूची समझ के साथ शायद बेहतर हो सकते हैं। sequence किसी भी समय आप गणना गणनाओं की एक पूरी सूची चलाने के लिए काम में आता है, हालांकि।