F #

Question

में अधिकतम, न्यूनतम और औसत खोजें I FET में .NET के बिना अधिकतम, न्यूनतम और औसत सरणी में खोजना चाहते हैं। मैं इस कोड का इस्तेमाल किया, लेकिन यह काम नहीं कर रहा:

let mutable max = 0 
let arrX = [|9; 11; 3; 4; 5; 6; 7; 8|] 

for i in 0 .. arrX.Length - 2 do 
    if (arrX.[i]) < (arrX.[i+1]) then 
     max <- arrX.[i] 
     printfn "%i" max 

Answer 1

मैं अपने कोड अधिकतम

के लिए

let mutable max = 0 
let arrX= [|9; 11; 3; 4; 5; 6; 7; 8|] 

for i in 0 .. arrX.Length - 1 do 
    if max < (arrX.[i]) then 
     max <- arrX.[i] 
     printfn "%i" max 

, अपने दृष्टिकोण का उपयोग कर तय अधिकतम, न्यूनतम और औसत ढूंढने के लिए:

let mutable max = System.Int32.MinValue 
let mutable min = System.Int32.MaxValue 
let mutable sum = 0 
let arrX= [|9; 11; 3; 4; 5; 6; 7; 8|] 

for i in 0 .. arrX.Length - 1 do 
    if max < (arrX.[i]) then 
     max <- arrX.[i] 
     printfn "max %i" max 
    if min > (arrX.[i]) then 
     min <- arrX.[i] 
     printfn "min %i" min 
    sum <- sum + arrX.[i] 
printfn "-> max is %i" max 
printfn "-> min is %i" min 
printfn "-> avg is %f" (float sum/float arrX.Length) 

लेकिन ध्यान दें तुम सिर्फ कर सकते हैं :

let max = Seq.max arrX 
let min = Seq.min arrX 
let avg = Seq.averageBy float arrX 

Answer 2

कुछ तार्किक समस्या यहां अधिकतम गणना करने के लिए कर रहे हैं। और printfn की नियुक्ति प्रत्येक बार जब यह बदलती है तो अधिकतम प्रिंट करेगा। निम्नलिखित कोड काम करता है:

let mutable max = 0 
let arrX= [|9; 11; 3; 4; 5; 6; 7; 8|] 

for i in 0 .. arrX.Length-1 do 
    if max < arrX.[i] then 
     max <- arrX.[i] 
printfn "%i" max 

Answer 3

जबकि पहले से पोस्ट किए गए उत्तर हैं p आपके पोस्ट कोड क्यों काम नहीं करते हैं, इस बारे में गलत तरीके से मान्य है, मैं तर्क दूंगा कि एक लूप और एक परिवर्तनीय चर का उपयोग करना बहुत नहीं है ... कार्यात्मक। तो मैंने सोचा कि मैं इसे और अधिक एफ # - इसे सुलझाने का मूर्ख तरीका पोस्ट करूंगा।

आप बताते हैं कि ".NET का उपयोग नहीं कर सकता"। मैं अनुमान लगा रहा हूं कि आप किसी अंतर्निहित कार्यों या .NET पुस्तकालयों का उपयोग नहीं कर सकते हैं। बेशक, इसका मतलब यह भी है कि आप F # primitives का उपयोग करके स्वयं को लागू कर सकते हैं।

कार्यात्मक दुनिया में एक आम कार्य fold है, जो एक अनुक्रम के सभी तत्वों के लिए एक फ़ंक्शन लागू करता है, जबकि उस फ़ंक्शन को एक संचयक में वापस रखने के दौरान। निर्मित संस्करण Seq.fold है, लेकिन चूंकि हम चाहते हैं कि उपयोग नहीं कर सकते हैं, तो हम एक अपने आप को परिभाषित करेंगे:

let rec fold accFn arr acc = 
    match arr with 
    | [||] -> acc 
    | _ -> fold accFn arr.[1..] (accFn arr.[0] acc) 

इस के साथ ही बुला प्रत्येक तत्व को accFn समारोह लागू होता है जो एक पुनरावर्ती समारोह है, और उसके बाद सरणी का शेष। जब यह एक खाली सरणी पारित हो जाती है, तो रिकर्सन समाप्त हो जाता है।

जब हम कि है, के fold में पारित करने के लिए कुछ सरल कार्यों को परिभाषित करते हैं:

let min x y = 
    if x < y then x 
    else y 

let max x y = 
    if x > y then x 
    else y 

let sum x y = 
    x + y 

एक बार जब हम कि, ने कहा समस्या का समाधान सरल है:

let arrX= [|9; 11; 3; 4; 5; 6; 7; 8|] 
let head = arrX.[0] 
let avg = (fold sum arrX 0)/arrX.Length 
let minValue = fold min arrX head 
let maxValue = fold max arrX head 

Answer 4

let ofArray f (a : 'T array) = 
    let len = a.Length 
    let rec aux index ret = 
    if index >= len then 
     ret 
    else 
     aux (index+1) (f a.[index] ret) 
    aux 1 a.[0] 

let maxOfArray (a : 'T array) = ofArray max a 
let minOfArray (a : 'T array) = ofArray min a 
let inline sumOfArray (a : 'T array) = ofArray (+) a 

let main() = 
    printfn "max: %d" <| maxOfArray arrX 
    printfn "min: %d" <| minOfArray arrX 
    printfn "ave: %f" <| (sumOfArray arrX |> float)/(arrX.Length |> float) 

do main()