Buscar máximo, mínimo y promedio en F #

Question

Quiero encontrar el máximo, mínimo y promedio en una matriz sin .NET en F #. He utilizado este código, pero no está funcionando:

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

que fija el código para max

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 

Para encontrar máximo, mínimo y promedio, la utilización de su enfoque:

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) 

Pero tenga en cuenta que puede hacer solo :

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

Answer 2

hay algunos problemas lógicos para calcular max aquí. Y la ubicación de printfn imprimirá un máximo cada vez que cambie. El siguiente código funciona:

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

Mientras que las respuestas ya publicadas son p erróneamente válido en cuanto a por qué su código publicado no funciona, yo diría que usar un bucle y una variable mutable no es muy ... funcional. Así que pensé en publicar una forma más F # - idiomática de resolverlo.

Usted declara que "no puede usar .NET". Supongo que quiere decir que no puede usar ninguna de las funciones integradas o las bibliotecas .NET. Por supuesto, eso también significa que puede implementarlo usted mismo usando primitivas F #.

Una función común en el mundo funcional es fold, que simplemente aplica una función a todos los elementos de una secuencia, mientras mantiene el retorno de esa función en un acumulador. La versión integrada es Seq.fold, pero ya que no podemos usar eso, vamos a definir uno de nosotros mismos:

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

Esta es una función recursiva que se aplica la función accFn a cada elemento, y luego se hace llamar con el resto de la matriz. Cuando se pasa una matriz vacía, la recursión finaliza.

Cuando tenemos que, vamos a definir algunas funciones sencillas para pasar a 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 

Una vez que tengamos eso, la solución al problema planteado es simple:

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()