Java 8中带有Memoized的无限Fibonacci序列

时间:2014-10-09 22:15:13

标签: java javascript lambda java-8 java-stream

首先,我是一名JavaScript程序员,对Java8很新,并尝试新的功能。

由于我专注于JS编码,我实现了自己的JS懒惰功能库来进行概念验证。

https://github.com/kenokabe/spacetime

使用该库,我可以编写自然数无限序列和Fibonacci ,如下所示:

的JavaScript

var spacetime = require('./spacetime');
var _ = spacetime.lazy(); 

var natural = _(function(n)   //memoized automatically
{
  return n;    // Natural numbers is defined as the `n`th number becomes `n`
});

var natural10 = _(natural)
  .take(10)
  .compute(function(x)
  {
    console.log(x);
  });


//wrap a recursive function to memoize
// must be at the definition in the same scope
var fib = _(function(n)
{
  if (n <= 1)
    return 1; // as the Fib definition in Math
  else
    return fib(n - 2) + fib(n - 1); // as the Fib definition in Math
});

var fib10 = _(fib)
  .take(10)
  .compute(function(x)
  {
    console.log(x);
  });

足够清楚。关键是我可以将Natural / Fibonacci无限序列定义为数学定义,然后使用延迟求值来计算无限序列的必需部分。

所以,现在我想知道我是否可以用Java8做同样的方式。

对于自然序列,我在这里发布了另一个问题。

Infinite sequence of Natural numbers with Java8 generator

定义Natural序列的方法之一是使用Java8的iterator

Java8

IntStream natural = IntStream.iterate(0, i -> i + 1);

natural
 .limit(10)
 .forEach(System.out::println);

我观察IntStream natural = IntStream.iterate(0, i -> i + 1);是数学意义上自然数的公平定义。

但是,我想知道是否可以像以前那样定义它,也就是说,

的JavaScript

var natural = _(function(n)   //memoized automatically
    {
      return n;    // Natural numbers is defined as the `n`th number becomes `n`
    });

因为这看起来更简洁。不幸的是,答案表明,即使我们使用generate,也可能无法实现。

此外,IntStream.iterate不适合Fibonacci序列。

我在网上寻找generate不确定的Fibonacci序列,我发现最好的结果是

http://blog.informatech.cr/2013/05/08/memoized-fibonacci-numbers-with-java-8/

Java8

private static Map<Integer,Long> memo = new HashMap<>();
static {
   memo.put(0,0L); //fibonacci(0)
   memo.put(1,1L); //fibonacci(1)
}

//And for the inductive step all we have to do is redefine our Fibonacci function as follows:

public static long fibonacci(int x) {
   return memo.computeIfAbsent(x, n -> fibonacci(n-1) + fibonacci(n-2));
}

这不是一个无限序列(Java8中的惰性Stream)。

Providing Limit condition on Stream generation

Java8

Stream.generate(new Supplier<Long>() {
    private long n1 = 1;
    private long n2 = 2;

    @Override
    public Long get() {
        long fibonacci = n1;
        long n3 = n2 + n1;
        n1 = n2;
        n2 = n3;
        return fibonacci;
    }
}).limit(50).forEach(System.out::println);

这是一个无限序列(Java8中的惰性Stream),您可以说它被定义为Math。 但是我不喜欢这种实现,因为正如您所看到的,有许多内部有用的信息可以获得n1 n2 n3然后fibonacci等序列,因此代码结构很复杂,你需要控制反函数方式的可变状态 - 与数学定义不同,可能这不是记忆。

所以,这是我的问题。使用Java8 Stream,有没有办法编写代码以简明的数学方式定义fibonacci的无限序列,并使用memoization,如

的JavaScript

 var fib = _(function(n)
    {
      if (n <= 1)
        return 1; // as the Fib definition in Math
      else
        return fib(n - 2) + fib(n - 1); // as the Fib definition in Math
    });

谢谢你的想法。

1 个答案:

答案 0 :(得分:15)

你可以拍摄基于地图的memoized fibonacci(x),然后像这样制作一个无限的流:

LongStream fibs = IntStream.iterate(1, i->i+1).mapToLong(i -> fibonacci(i));

但是,制作无限数量斐波那契数的最简单方法是:

LongStream fibs = Stream.iterate(
        new long[]{1, 1},
        f -> new long[]{f[1], f[0] + f[1]}
).mapToLong(f -> f[0]);

正如你所链接的文章指出的那样,&#34;无限&#34;真的意味着&#34;直到长时间溢出&#34;这很快发生。如果你想生成数百个斐波纳契数,请用BigInteger代替long:

    Stream<BigInteger> bigFibs = Stream.iterate(
            new BigInteger[]{BigInteger.ONE, BigInteger.ONE},
            f -> new BigInteger[]{f[1], f[0].add(f[1])}
    ).map(f -> f[0]);