[java] 스칼라에서 이해력과 루프를 최적화하는 방법은 무엇입니까?

후속 조치로 -optimize 플래그를 시도하여 실행 시간을 103 초에서 76 초로 줄 였지만 Java 또는 while 루프보다 여전히 107 배 느립니다.

그런 다음 “기능”버전을보고있었습니다.

object P005 extends App{
  def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}
  def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
  println (find (2))
}

간결한 방식으로 “전망”을 제거하는 방법을 알아 내려고 노력했습니다. 비참하게 실패했고

object P005_V2 extends App {
  def isDivis(x:Int):Boolean = {
    var i = 1
    while(i <= 20) {
      if (x % i != 0) return false
      i += 1
    }
    return true
  }
  def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
  println (find (2))
}

교활한 5 라인 솔루션이 12 라인으로 줄었습니다. 그러나이 버전은 원래 Java 버전과 동일한 속도로 0.71 초 동안 실행되며 “forall”(40.2s)을 사용하는 위 버전보다 56 배 더 빠릅니다! (이것이 Java보다 빠른 이유는 아래 편집을 참조하십시오)

분명히 다음 단계는 위의 내용을 Java로 다시 변환하는 것이었지만 Java는 처리 할 수 ​​없으며 22000 마크 주위에 n을 가진 StackOverflowError를 발생시킵니다.

그런 다음 머리를 조금 긁으면 서 “while”을 약간 더 많은 꼬리 재귀로 대체하여 몇 줄을 저장하고 빨리 실행하지만 얼굴을 마주 보았습니다.

object P005_V3 extends App {
  def isDivis(x:Int, i:Int):Boolean =
    if(i > 20) true
    else if(x % i != 0) false
    else isDivis(x, i+1)

  def find(n:Int):Int = if (isDivis(n, 2)) n else find (n+2)
  println (find (2))
}

스칼라의 꼬리 재귀가 하루에이기는 것이지만 “for”루프 (및 “forall”방법)와 같은 단순한 것이 본질적으로 깨져서 우아하고 장황한 “whiles”또는 꼬리 재귀로 대체되어야한다는 사실에 놀랐습니다. . 스칼라를 시도하는 많은 이유는 간결한 구문 때문이지만 코드가 100 배 느리게 실행되면 좋지 않습니다!

편집 : (삭제)

편집 편집 : 실행 시간 2.5와 0.7 사이의 불일치는 전적으로 32 비트 또는 64 비트 JVM 중 어느 것이 사용 되었는가에 기인합니다. 명령 행의 스칼라는 JAVA_HOME에서 설정 한 것을 사용하지만 Java는 사용 가능한 경우 64 비트를 사용합니다. IDE에는 자체 설정이 있습니다. 여기에 일부 측정 : Eclipse에서 스칼라 실행 시간

답변

def loop[T](times: Int, default: T)(body: ()=>T) : T = {
    var count = 0
    var result: T = default
    while(count < times) {
        result = body()
        count += 1
    }
    result
}

def foo() : Int= {
    loop(5, 0) {
        println("Hi")
        return 5
    }
}

foo()

def isEvenlyDivisible(a:Int, b:Int):Boolean = {
  for (i <- 2 to b)
    if (a % i != 0) return false
  return true
}

def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}

val r = (1 to 20)
def isDivis(x:Int) = r forall {x % _ == 0}

val rl = (1 to 20).toList
def isDivis(x:Int) = rl forall {x % _ == 0}

  val ra = (1 to 20).toArray
  def isDivis(x:Int) = ra forall2 {x % _ == 0}

  case class PimpedSeq[A](s: IndexedSeq[A]) {
    def forall2 (p: A => Boolean): Boolean = {
      var i = 0
      while (i < s.length) {
        if (!p(s(i))) return false
        i += 1
      }
      true
    }
  }
  implicit def arrayToPimpedSeq[A](in: Array[A]): PimpedSeq[A] = PimpedSeq(in)  

def gcd(a: Int, b: Int): Int = {
    if (a == 0)
        b
    else
        gcd(b % a, a)
}
print (1 to 20 reduce ((a, b) => {
  a / gcd(a, b) * b
}))