[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
  }

그렇게하는 것은 위의 값 n에 스칼라를 사용하여 피보나치 시퀀스를 생성하는 내 코드입니다. 스칼라에서이 작업을 수행하는 더 우아한 방법이 있는지 궁금?

해결법

1. ==============================

   1.이 피보나치 순서를 정의하는 방법에는 여러 가지가 있지만, 내가 좋아하는이 하나입니다 :

   이 피보나치 순서를 정의하는 방법에는 여러 가지가 있지만, 내가 좋아하는이 하나입니다 :

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

   이것은 당신이 특정 피보나치 수를 할 때 게으르게 평가되는 스트림을 생성한다.

   편집하다: 루이지 Plinge 지적 첫째, 처음에 "게으른"는 불필요했다. 둘째, 그의 대답에 가서 보면, 그는 거의에만 더 우아 같은 일을했다.

2. ==============================

   2.이것은 좀 더 우아한 :

   이것은 좀 더 우아한 :

   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)
   

   업데이트 :이 솔루션의 작동 방법에 대한 자세한 내용을가는 블로그 게시물을 작성했습니다, 왜 당신은 피보나치 시퀀스와 끝까지!

3. ==============================

   3.아니 우아한 같은 스트림, 게으른 아니지만, tailrecursive 및 핸들에서 BigInt (너무 Luigis scanLeft와 함께 할 쉽게,하지만 그렇게 탈의 지퍼 - 어쩌면 그냥 나를 위해) 등.

   아니 우아한 같은 스트림, 게으른 아니지만, 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) }
   

4. ==============================

   4.내가 제일 좋아하는 버전입니다 :

   내가 제일 좋아하는 버전입니다 :

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

   기본 값으로 당신은 FIB를 ()를 호출하고, 무한 스트림을 얻을 수 있습니다.

   나는 또한 한 라이너 임에도 불구하고 매우 읽을 생각합니다.

   그냥이 처음 n 다음 () FIB를 같은 테이크를 사용할 수 없음이 걸릴 원하고, 경우 목록의 FIB로 필요한 경우 () 걸릴 N toList.

5. ==============================

   5.여기서 다시 중간 튜플에 * 스트림 *의를 사용하는 또 다른 방법입니다 :

   여기서 다시 중간 튜플에 * 스트림 *의를 사용하는 또 다른 방법입니다 :

   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)
   

6. ==============================

   6.나는이 구현은 더 읽을 수 찾을 :

   나는이 구현은 더 읽을 수 찾을 :

   def fibonacci: Stream[Int] = {
       def loop(a: Int, b: Int): Stream[Int] = (a + b) #:: loop(b, b + a)
       loop(0, 1)
   }
   

7. ==============================

   7.

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

from https://stackoverflow.com/questions/9864497/generate-a-sequence-of-fibonacci-number-in-scala by cc-by-sa and MIT license