Question

我发现的所有迭代实现似乎都必须使用制表方法。

动态编程是否只是递归的替代，而它是迭代的强制解决方案？

Answer 1

不使用制表，memoization或交换变量的斐波纳契的迭代实现 - 这个代码来自getting hung-up learning functional style上的答案。

const append = (xs, x) =>
  xs.concat ([x])

const fibseq = n => {
  let seq = []
  let a = 0
  let b = 1
  while (n >= 0) {
    n = n - 1
    seq = append (seq, a)
    a = a + b
    b = a - b
  }
  return seq
}

console.log (fibseq (500))
// [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...  ]

请记住，procedure differs from process - 即，递归过程可以产生迭代过程。下面，即使fibseq被定义递归，它产生的过程也是迭代 - 再次，没有制表，记忆或任何其他组成的术语上

const recur = (...values) =>
  ({ type: recur, values })

const loop = f =>
  {
    let acc = f ()
    while (acc && acc.type === recur)
      acc = f (...acc.values)
    return acc
  }
      
const fibseq = x =>
  loop ((n = x, seq = [], a = 0, b = 1) =>
    n === 0
      ? seq.concat ([a])
      : recur (n - 1, seq.concat ([a]), a + b, a))

console.time ('loop/recur')
console.log (fibseq (500))
console.timeEnd ('loop/recur')

// [ 0,
//   1,
//   1,
//   2,
//   3,
//   5,
//   8,
//   13,
//   21,
//   34,
//   ... 490 more items ]
// loop/recur: 5ms

Answer 2

有一个definition的斐波纳契数作为二项式系数的总和，它们本身可以迭代计算，作为(n-1)和1 2的所有成分的表示。 {1}}秒。

在Haskell中，我们可以写：

-- https://rosettacode.org/wiki/Evaluate_binomial_coefficients#Haskell
Prelude> choose n k = product [k+1..n] `div` product [1..n-k]

Prelude> fib n = sum [(n-k-1) `choose` k | k <- [0..(n-1) `div` 2]]

Prelude> fib 100
354224848179261915075

是否存在斐波纳契的迭代实现，而不是制表？

2 个答案: