F# 为什么这个幼稚的筛子实现如此缓慢

这是我的密码

let primes =
    let rec primesRec remain = 
        let prime = Seq.head remain
        seq { yield Seq.head remain; yield! primesRec (Seq.filter (fun n -> n % prime <> 0) remain)  }
    primesRec (Seq.initInfinite (fun i -> i + 2))

---

已经花费了相当长的时间（它没有记忆

保留

序列，因此对于每次迭代，它都会再次计算所有的素数，直到

素数

你关于有100万次迭代的理论可能是正确的，但请记住，它不仅仅是做一点模运算：它是创建序列和迭代器，分配内存，将内容推到堆栈上等等

我通过如下缓存

保留

序列来实现这一点。但您也可以使用

列表

而不是

序列

来解决它

let primes =
    let rec primesRec remain = 
        let prime = Seq.head remain
        seq { yield Seq.head remain; yield! primesRec (Seq.filter (fun n -> n % prime <> 0) (Seq.cache remain))  }
    primesRec (Seq.initInfinite (fun i -> i + 2))

let素数=
让rec primesRec保持=
让prime=Seq.head保持不变
seq{yield seq.head remain；yield！primesRec（seq.filter（fun->n%prime 0）（seq.cache remaine））}
primesRec（Seq.initInfinite（乐趣i->i+2））

它并没有记忆

保留

序列，因此对于每次迭代，它都会再次计算所有素数，直到

素数

你关于有100万次迭代的理论可能是正确的，但请记住，它不仅仅是做一点模运算：它是创建序列和迭代器，分配内存，将内容推到堆栈上等等

我通过如下缓存

保留

序列来实现这一点。但您也可以使用

列表

而不是

序列

来解决它

let primes =
    let rec primesRec remain = 
        let prime = Seq.head remain
        seq { yield Seq.head remain; yield! primesRec (Seq.filter (fun n -> n % prime <> 0) (Seq.cache remain))  }
    primesRec (Seq.initInfinite (fun i -> i + 2))

let素数=
让rec primesRec保持=
让prime=Seq.head保持不变
seq{yield seq.head remain；yield！primesRec（seq.filter（fun->n%prime 0）（seq.cache remaine））}
primesRec（Seq.initInfinite（乐趣i->i+2））

它并没有记忆

保留

序列，因此对于每次迭代，它都会再次计算所有素数，直到

素数

你关于有100万次迭代的理论可能是正确的，但请记住，它不仅仅是做一点模运算：它是创建序列和迭代器，分配内存，将内容推到堆栈上等等

我通过如下缓存

保留

序列来实现这一点。但您也可以使用

列表

而不是

序列

来解决它

let primes =
    let rec primesRec remain = 
        let prime = Seq.head remain
        seq { yield Seq.head remain; yield! primesRec (Seq.filter (fun n -> n % prime <> 0) (Seq.cache remain))  }
    primesRec (Seq.initInfinite (fun i -> i + 2))

let素数=
让rec primesRec保持=
让prime=Seq.head保持不变
seq{yield seq.head remain；yield！primesRec（seq.filter（fun->n%prime 0）（seq.cache remaine））}
primesRec（Seq.initInfinite（乐趣i->i+2））

它并没有记忆

保留

序列，因此对于每次迭代，它都会再次计算所有素数，直到

素数

你关于有100万次迭代的理论可能是正确的，但请记住，它不仅仅是做一点模运算：它是创建序列和迭代器，分配内存，将内容推到堆栈上等等

我通过如下缓存

保留

序列来实现这一点。但您也可以使用

列表

而不是

序列

来解决它

let primes =
    let rec primesRec remain = 
        let prime = Seq.head remain
        seq { yield Seq.head remain; yield! primesRec (Seq.filter (fun n -> n % prime <> 0) (Seq.cache remain))  }
    primesRec (Seq.initInfinite (fun i -> i + 2))

let素数=
让rec primesRec保持=
让prime=Seq.head保持不变
seq{yield seq.head remain；yield！primesRec（seq.filter（fun->n%prime 0）（seq.cache remaine））}
primesRec（Seq.initInfinite（乐趣i->i+2））

你可能会喜欢这个：-也看看这个-这里已经解释过了无论代码做什么100米迭代都很难压缩到一秒钟。你可能会喜欢这个：-也看看这个-这里已经解释过了无论代码做什么100米迭代都很难压缩到一秒钟。你可能会喜欢这个：-也看一看-这里已经解释过了无论代码做什么100M迭代都要挤在一秒钟内。你可能会喜欢这个：-也看一看-这里已经解释过了无论代码做什么100M迭代都要挤在一秒钟内。你能给出一些代码用F#中的列表来解决这个问题吗？（这是一个有点意思的想法-认为他们很懒..这里的列表有问题..你能给一些代码来解决F#中的列表吗？）（这是一个有点意思-认为他们很懒..这里的列表有问题..）你能给出一些代码来解决F#中列表的问题吗？（这有点意思-认为s的人是懒惰的..你对这里的列表有问题…）你能给出一些代码来解决F#中列表的问题吗？（这有点刻薄-人们认为他们很懒……这里的列表有问题……）