【发布时间】：2013-01-18 01:29:55
【问题描述】：
我正在尝试学习 Java、Scala 和 Clojure。
我正在用三种语言解决 Project Euler 问题。下面列出了问题 #5 (http://projecteuler.net/problem=5) 的代码以及到目前为止前五个问题的运行时间（以秒为单位）。令我吃惊的是，对于问题 #5，Java 和 Clojure 版本比 Scala 版本慢得多。它们在同一台机器、同一 jvm 上运行，并且多次试验的结果是一致的。我能做些什么来加快这两个速度（尤其是 Clojure 版本）？为什么 Scala 版本的速度这么快？
运行时间（以秒为单位）
|---------|--------|--------|----------|
| problem | Java | Scala | Clojure |
|=========|========|========|==========|
| 1 | .0010 | .1570 | .0116 |
| 2 | .0120 | .0030 | .0003 |
| 3 | .0530 | .0200 | .1511 |
| 4 | .2120 | .2600 | .8387 |
| 5 | 3.9680 | .3020 | 33.8574 |
问题 #5 的 Java 版本
public class Problem005 {
private static ArrayList<Integer> divisors;
private static void initializeDivisors(int ceiling) {
divisors = new ArrayList<Integer>();
for (Integer i = 1; i <= ceiling; i++)
divisors.add(i);
}
private static boolean isDivisibleByAll(int n) {
for (int divisor : divisors)
if (n % divisor != 0)
return false;
return true;
}
public static int findSmallestMultiple (int ceiling) {
initializeDivisors(ceiling);
int number = 1;
while (!isDivisibleByAll(number))
number++;
return number;
}
}
问题 #5 的 Scala 版本
object Problem005 {
private def isDivisibleByAll(n: Int, top: Int): Boolean =
(1 to top).forall(n % _ == 0)
def findSmallestMultiple(ceiling: Int): Int = {
def iter(n: Int): Int = if (isDivisibleByAll(n, ceiling)) n else iter(n+1)
iter(1)
}
}
问题 #5 的 Clojure 版本
(defn smallest-multiple-of-1-to-n
[n]
(loop [divisors (range 2 (inc n))
i n]
(if (every? #(= 0 (mod i %)) divisors)
i
(recur divisors (inc i)))))
编辑
有人建议我将各种答案编译成我自己的答案。但是，我想在应得的地方给予赞扬（我自己真的没有回答这个问题）。
关于第一个问题，所有三个版本都可以通过使用更好的算法来加速。具体来说，创建一个数字 1-20 的最大公因数列表（2^4、3^2、5^1、7^1、11^1、13^1、17^1、19^1）和将它们相乘。
更有趣的方面是使用基本相同的算法来理解三种语言之间的差异。在某些情况下，诸如此类的蛮力算法可能会有所帮助。那么，为什么会有性能差异呢？
对于 Java，一个建议是将 ArrayList 更改为原始整数数组。这确实减少了运行时间，减少了大约 0.5 - 1 秒（我今天早上才运行它，它把运行时间从 4.386 秒减少到 3.577 秒。这减少了一点，但没有人能想出一个将其降低到半秒以下（类似于 Scala 版本）的方法。考虑到所有三个都编译为 java 字节码，这令人惊讶。@didierc 建议使用不可变迭代器；我测试了这个建议，并将运行时间增加到刚刚超过 5 秒。
对于 Clojure，@mikera 和 @Webb 提供了一些加快速度的建议。他们建议使用 loop/recur 进行带有两个循环变量的快速迭代，使用 unchecked-math 进行稍快的数学运算（因为我们知道这里没有溢出的危险），使用原始 long 而不是装箱数，并避免使用更高阶的函数，例如每个？
运行@mikera的代码，我最终得到了2.453秒的运行时间，不如scala代码，但比我原来的版本好很多，也比Java版本好：
(set! *unchecked-math* true)
(defn euler5
[]
(loop [n 1
d 2]
(if (== 0 (unchecked-remainder-int n d))
(if (>= d 20) n (recur n (inc d)))
(recur (inc n) 2))))
(defn is-divisible-by-all?
[number divisors]
(= 0 (reduce + (map #(mod 2 %) divisors))))
对于 Scala，@didierc 声明范围对象 1 到 20 实际上不是对象列表，而是一个对象。很酷。因此，Scala 的性能差异在于我们迭代单个对象而不是整数 1-20 的列表/数组。
实际上，如果我将 scala 方法中的 helper 函数从范围对象更改为列表（见下文），那么 scala 版本的运行时间从 0.302 秒增加到 226.59 秒。
private def isDivisibleByAll2(n: Int, top: Int): Boolean = {
def divisors: List[Int] = List(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)
divisors.forall(n % _ == 0)
}
因此，@didierc 似乎正确识别了 scala 在这种情况下的优势。知道如何在 java 和 clojure 中实现这种类型的对象会很有趣。
@didierc 建议通过创建一个 ImmutableRange 类来改进代码，如下：
import java.util.Iterator;
import java.lang.Iterable;
public class ImmutableRange implements Iterable<Integer> {
class ImmutableRangeIterator implements Iterator<Integer> {
private int counter, end, step;
public ImmutableRangeIterator(int start_, int end_, int step_) {
end = end_;
step = step_;
counter = start_;
}
public boolean hasNext(){
if (step>0) return counter <= end;
else return counter >= end;
}
public Integer next(){
int r = counter;
counter+=step;
return r;
}
public void remove(){
throw new UnsupportedOperationException();
}
}
private int start, end, step;
public ImmutableRange(int start_, int end_, int step_){
// fix-me: properly check for parameters consistency
start = start_;
end = end_;
step = step_;
}
public Iterator<Integer> iterator(){
return new ImmutableRangeIterator(start,end,step);
}
}
没有提高运行时间。 java 版本在我的机器上运行了 5.097 秒。因此，最后，对于为什么 Scala 版本性能更好，我们有一个令人满意的答案，我们了解如何提高 Clojure 版本的性能，但缺少的是了解如何在 Java 中实现 Scala 的不可变范围对象.
最后的想法
正如一些人所评论的，提高此代码运行时间的最有效方法是使用更好的算法。例如，以下 java 代码使用 Sieve of Eratosthenes 和 Trial Division 在不到 1 毫秒的时间内计算出答案：
/**
* Smallest Multiple
*
* 2520 is the smallest number that can be divided by each of the numbers
* from 1 to 10 without any remainder. What is the smallest positive number
* that is evenly divisible by all of the numbers from 1 to 20?
*
* User: Alexandros Bantis
* Date: 1/29/13
* Time: 7:06 PM
*/
public class Problem005 {
final private static int CROSSED_OUT = 0;
final private static int NOT_CROSSED_OUT = 1;
private static int intPow(int base, int exponent) {
int value = 1;
for (int i = 0; i < exponent; i++)
value *= base;
return value;
}
/**
* primesTo computes all primes numbers up to n using trial by
* division algorithm
*
* @param n designates primes should be in the range 2 ... n
* @return int[] a sieve of all prime factors
* (0=CROSSED_OUT, 1=NOT_CROSSED_OUT)
*/
private static int[] primesTo(int n) {
int ceiling = (int) Math.sqrt(n * 1.0) + 1;
int[] sieve = new int[n+1];
// set default values
for (int i = 2; i <= n; i++)
sieve[i] = NOT_CROSSED_OUT;
// cross out sieve values
for (int i = 2; i <= ceiling; i++)
for (int j = 2; i*j <= n; j++)
sieve[i*j] = CROSSED_OUT;
return sieve;
}
/**
* getPrimeExp computes a prime factorization of n
*
* @param n the number subject to prime factorization
* @return int[] an array of exponents for prime factors of n
* thus 8 => (0^0, 1^0, 2^3, 3^0, 4^0, 5^0, 6^0, 7^0, 8^0)
*/
public static int[] getPrimeExp(int n) {
int[] factor = primesTo(n);
int[] primePowAll = new int[n+1];
// set prime_factor_exponent for all factor/exponent pairs
for (int i = 2; i <= n; i++) {
if (factor[i] != CROSSED_OUT) {
while (true) {
if (n % i == 0) {
n /= i;
primePowAll[i] += 1;
} else {
break;
}
}
}
}
return primePowAll;
}
/**
* findSmallestMultiple computes the smallest number evenly divisible
* by all numbers 1 to n
*
* @param n the top of the range
* @return int evenly divisible by all numbers 1 to n
*/
public static int findSmallestMultiple(int n) {
int[] gcfAll = new int[n+1];
// populate greatest common factor arrays
int[] gcfThis = null;
for (int i = 2; i <= n; i++) {
gcfThis = getPrimeExp(i);
for (int j = 2; j <= i; j++) {
if (gcfThis[j] > 0 && gcfThis[j] > gcfAll[j]) {
gcfAll[j] = gcfThis[j];
}
}
}
// multiply out gcf arrays
int value = 1;
for (int i = 2; i <= n; i++) {
if (gcfAll[i] > 0)
value *= intPow(i, gcfAll[i]);
}
return value;
}
}
【问题讨论】：
-
您可以通过将 ArrayList
除数更改为 int[] 来获得小幅加速 - 您知道一开始的大小并且不需要自动装箱。 -
你能提供你用来做基准测试的代码吗？
-
@didierc github.com/ambantis?tab=repositories
-
尝试用
isDivisibleByAll中的循环替换 Java 版本中的divisors。这更像是 Scala 版本中发生的情况。此外，通过将isDivisibleByAll重写为 while 循环或尾递归函数，Scala 版本可能仍然更快。 -
@Alex 我想你已经有了所有的解释，但散布着每种语言的各种答案（例如，mikera 本着幼稚版本的精神拥有最快的 Clojure）。也许您可以自己创建一个摘要答案并接受它。