f# 连接对象列表

Question

type Googol = {
    number : float
    power : float
    result : float
}

let generatePowers (n:float) : list<Googol> = 
    let rec powerInner (n:float) (p:float) (acc : list<Googol>) = 
        match n with
        | p when p <= 1.0 -> acc
        | p when p > 1.0 -> powerInner n (p-1.0) ([{ number=n; power=p; result=n**p}]@acc)
    let rec numberInner (n:float) (acc : list<Googol>) = 
        match n with 
        | n when n <=1.0 -> acc
        | n when n >1.0 -> numberInner (n-1.0) ((powerInner n [])@acc)
    numberInner n []

ProjectEuler.fsx(311,50): error FS0001: This expression was expected to have type
    'Googol list'
but here has type
    'Googol list -> Googol list'

I am trying to solve this problem -> https://projecteuler.net/problem=56 | but for this I need to generate powers below n < 100. When I try to concatenate [{ number=n; power=p; result=n**p}]@acc [{ number=n; power=p; result=n**p}]@acc [{ number=n; power=p; result=n**p}]@acc these lists I get the error above. Explain please why error says 'Googol list -> Googol list' is in the function, does I plug a function as a parameter to the function or I plug the actual list when just after concatenation. Is @ a function?

Answer 1

You're missing a parameter here:

| n when n >1.0 -> numberInner (n-1.0) ((powerInner n [])@acc)
                                         ^^^^^^^^^^^^^^^
                                               here

powerInner is defined with three parameters, but you're only passing two.

In F# it is not technically illegal to pass fewer parameters than defined. If you do that, the result will be a function that "expects" the remaining parameters. For example:

let f : int -> int -> string

let x = f 42
// Here, x : int -> string

let y = x 5
// Here, y : string

So in your case omitting the last parameter makes the resulting type Googol list -> Googol list , which then turns out to be incompatible with the type Googol list expected by operator @ . Which is what the compiler is telling you in the error message.

Answer 2

This looks like homework or practice, so first I'll give some hints to move on. Finally I'll show a version that seems to work, and then tell how I would approach the problem.

The task is to find the number a ** b , for a and b less than 100, that has the highest sum of its own digits.

The first problem is that float won't give us all the digits of a ** b , so that type is useless to solve the problem. To fix that, we turn to the BigInteger type, and the BigInteger.Pow function. Then we get a 1 followed by 200 zeroes if we run the following snippet, just like it says in the problem description.

let x: bigint = BigInteger.Pow (100I, 100)
let x: string = string x
printfn "s=%s" x

To get useful results, change the Googol type so that it uses bigint , except for power that should be an int .

Why are the functions powerInner and numberInner inside the function generatePowers ? This doesn't seem to have a specific purpose, so I suggest moving them out to make this clearer.

The function powerInner do a match on n , but then goes on to name the results p , which shadows the p parameter so that it is unused. Ok, the intention here is probably to match on p rather than n , so just fix that, and then the shadowing of the p parameter is perfectly fine.

The tests first on <= 1 and then on > 1 causes incomplete matches. If the first line checks that the number is less or equal to one, then it must the greater than one in the next line. So just use n -> without the when to fix that. I also suspect you want to test <= 0 instead of 1.

This

[{ number=n; power=p; result=n**p}]@acc

can be just

{ number=n; power=p; result=n**p } :: acc

and here

(powerInner n [])

I suspect you just need a starting value for the power, which would be 99

(powerInner n 99 [])

SPOILER WARNING

After a bit of tinkering, this is what I ended up with, and it seems to print out a useful list of numbers. Note that in order to not run through all 99 by 99 results with printouts, I've used low starting numbers 3 and 5 for the countdowns here, so we get some simple printout we can study for analysis.

type Googol = { number: bigint; power: int; result: bigint }

let rec powerInner (n: bigint) (p: int) (acc: Googol list) =
    match p with
    | p when p <= 0 -> acc
    | p ->
        let newNumber = { number = n; power = p; result = n ** p }
        printfn "newNumber=%0A" newNumber
        powerInner n (p - 1) (newNumber :: acc)

let rec numberInner (n: bigint) (acc: Googol list) =
    match n with
    | n when n <= 0I -> acc
    | n -> numberInner (n - 1I) ((powerInner n 5 []) @ acc)

let generatePowers (n: bigint) : Googol list =
    numberInner n []

let powers = generatePowers 3I

I'm not sure if this solution is correct. I'd do it differently anyway.

I would simply loop through a and b in two loops, one inside the other. For each a ** b I would convert the result to a string, and then sum the digits of the string. Then I'd simply use a mutable to hold on to whichever result is the highest. The same could be achieved in a more functional way with one of those fancy List functions.