Сгенерировать последовательность чисел Фибоначчи в Scala [дубликат]

этот вопрос уже есть ответ здесь:


  def fibSeq(n: Int): List[Int] = {
    var ret = scala.collection.mutable.ListBuffer[Int](1, 2)
    while (ret(ret.length - 1) < n) {
      val temp = ret(ret.length - 1) + ret(ret.length - 2)
      if (temp >= n) {
        return ret.toList
      }
      ret += temp
    }
    ret.toList
  }

таким образом, выше мой код для генерации последовательности Фибоначчи с использованием Scala до значения n. Я интересно, если есть более элегантный способ сделать это в Scala?

19
fibonacci list-comprehension scala sequence

7 ответов

есть много способов определить последовательность Фибоначчи, но мой любимый это:

val fibs:Stream[Int] = 0 #:: 1 #:: (fibs zip fibs.tail).map{ t => t._1 + t._2 }

это создает поток, который оценивается лениво, когда вы хотите определенное число Фибоначчи.

изменить: Во-первых, как Луиджи "Плинж" указывается, "ленивый" в начале было лишнее. Во-вторых, посмотрите на его ответ, он в значительной степени сделал то же самое, только более элегантно.

24

Это немного более элегантно:

val fibs: Stream[Int] = 0 #:: fibs.scanLeft(1)(_ + _)

С потоками вы "берете" несколько значений, которые затем можете превратить в список:

scala> fibs take 10 toList
res42: List[Int] = List(0, 1, 1, 2, 3, 5, 8, 13, 21, 34)

Update: я написал блоге который идет более подробно о том, как это решение работает, и почему вы в конечном итоге с последовательностью Фибоначчи!

69

не так элегантно, как потоки, не ленивый, но tailrecursive и обрабатывает BigInt (что легко сделать с Luigis scanLeft тоже, но не так с молнией Тала - может быть, только для меня).

@tailrec 
def fib (cnt: Int, low: BigInt=0, high: BigInt=1, sofar: List[BigInt]=Nil): List[BigInt] = {
  if (cnt == 0) (low :: sofar).reverse else fib (cnt - 1, high, low + high, low :: sofar) }

scala> fib (75)
res135: List[BigInt] = список(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853, 72723460248141, 117669030460994, 190392490709135, 308061521170129, 498454011879264, 806515533049393, 1304969544928657, 2111485077978050)

5

моя любимая версия:

def fibs(a: Int = 0, b: Int = 1): Stream[Int] = Stream.cons(a, fibs(b, a+b))

по умолчанию вы можете просто позвонить fibs() и получить бесконечное Stream.

Я также думаю, что это очень читаемо, несмотря на то, что один лайнер.

если вы просто хотите первый n затем вы можете использовать take как fibs() take n, и если вам нужно это как список fibs() take n toList.

2

вот еще один подход снова с использованием *поток * s на промежуточных кортежах:

scala> val fibs = Stream.iterate( (0,1) ) { case (a,b)=>(b,a+b)  }.map(_._1) 
fibs: scala.collection.immutable.Stream[Int] = Stream(0, ?)

scala> fibs take 10 toList
res68: List[Int] = List(0, 1, 1, 2, 3, 5, 8, 13, 21, 34)
1

Я нахожу эту реализацию более разборчивой:

def fibonacci: Stream[Int] = {
    def loop(a: Int, b: Int): Stream[Int] = (a + b) #:: loop(b, b + a)
    loop(0, 1)
}
0
def fib:Stream[Int] ={
  def go(f0: Int, f1:Int): Stream[Int] = {
    Stream.cons(f0,go(f1,f0+f1))
  }
  go(0,1)
}
0