免责声明
我知道人为基准是邪恶的。它们只能在非常特定的狭窄情况下显示结果。我不认为一种语言会比另一种语言更好，因为它有一些愚蠢的知识。但是我不知道为什么结果如此不同。请在底部查看我的问题。
数学基准说明
基准测试是一种简单的数学计算，可以找到相差6的素数对（所谓的性感素数），例如，低于100的性感素数为：(5 11) (7 13) (11 17) (13 19) (17 23) (23 29) (31 37) (37 43) (41 47) (47 53) (53 59) (61 67) (67 73) (73 79) (83 89) (97 103)
结果表
在表中：计算时间（以秒为单位） 运行：除Factor以外的所有其他组件都在VirtualBox中运行（Debian不稳定的amd64来宾，Windows 7 x64主机）CPU：AMD A4-3305M
Sexy primes up to: 10k 20k 30k 100k
Bash 58.00 200.00 [*1] [*1]
C 0.20 0.65 1.42 15.00
Clojure1.4 4.12 8.32 16.00 137.93
Clojure1.4 (optimized) 0.95 1.82 2.30 16.00
Factor n/a n/a 15.00 180.00
Python2.7 1.49 5.20 11.00 119
Ruby1.8 5.10 18.32 40.48 377.00
Ruby1.9.3 1.36 5.73 10.48 106.00
Scala2.9.2 0.93 1.41 2.73 20.84
Scala2.9.2 (optimized) 0.32 0.79 1.46 12.01[* 1]-恐怕要花多少时间
代码清单
C：
int isprime(int x) {
int i;
for (i = 2; i < x; ++i)
if (x%i == 0) return 0;
return 1;
}
void findprimes(int m) {
int i;
for ( i = 11; i < m; ++i)
if (isprime(i) && isprime(i-6))
printf("%d %d\n", i-6, i);
}
main() {
findprimes(10*1000);
}红宝石：
def is_prime?(n)
(2...n).all?{|m| n%m != 0 }
end
def sexy_primes(x)
(9..x).map do |i|
[i-6, i]
end.select do |j|
j.all?{|j| is_prime? j}
end
end
a = Time.now
p sexy_primes(10*1000)
b = Time.now
puts "#{(b-a)*1000} mils"Scala：
def isPrime(n: Int) =
(2 until n) forall { n % _ != 0 }
def sexyPrimes(n: Int) =
(11 to n) map { i => List(i-6, i) } filter { _ forall(isPrime(_)) }
val a = System.currentTimeMillis()
println(sexyPrimes(100*1000))
val b = System.currentTimeMillis()
println((b-a).toString + " mils")优化了Scala isPrime（与Clojure优化中的想法相同）：
import scala.annotation.tailrec
@tailrec // Not required, but will warn if optimization doesn't work
def isPrime(n: Int, i: Int = 2): Boolean =
if (i == n) true
else if (n % i != 0) isPrime(n, i + 1)
else falseClojure：
(defn is-prime? [n]
(every? #(> (mod n %) 0)
(range 2 n)))
(defn sexy-primes [m]
(for [x (range 11 (inc m))
:let [z (list (- x 6) x)]
:when (every? #(is-prime? %) z)]
z))
(let [a (System/currentTimeMillis)]
(println (sexy-primes (* 10 1000)))
(let [b (System/currentTimeMillis)]
(println (- b a) "mils")))Clojure优化is-prime?：
(defn ^:static is-prime? [^long n]
(loop [i (long 2)]
(if (= (rem n i) 0)
false
(if (>= (inc i) n) true (recur (inc i))))))蟒蛇
import time as time_
def is_prime(n):
return all((n%j > 0) for j in xrange(2, n))
def primes_below(x):
return [[j-6, j] for j in xrange(9, x+1) if is_prime(j) and is_prime(j-6)]
a = int(round(time_.time() * 1000))
print(primes_below(10*1000))
b = int(round(time_.time() * 1000))
print(str((b-a)) + " mils")因子
MEMO:: prime? ( n -- ? )
n 1 - 2 [a,b] [ n swap mod 0 > ] all? ;
MEMO: sexyprimes ( n n -- r r )
[a,b] [ prime? ] filter [ 6 + ] map [ prime? ] filter dup [ 6 - ] map ;
5 10 1000 * sexyprimes . .重击（zsh）：
#!/usr/bin/zsh
function prime {
for (( i = 2; i < $1; i++ )); do
if [[ $[$1%i] == 0 ]]; then
echo 1
exit
fi
done
echo 0
}
function sexy-primes {
for (( i = 9; i <= $1; i++ )); do
j=$[i-6]
if [[ $(prime $i) == 0 && $(prime $j) == 0 ]]; then
echo $j $i
fi
done
}
sexy-primes 10000问题
- 为什么Scala这么快？是因为静态类型化吗？还是只是非常有效地使用JVM？
为什么Ruby和Python之间会有如此巨大的差异？我认为这两者并没有完全不同。也许我的代码是错误的。请赐教！谢谢。UPD是的，那是我的代码中的错误。Python和Ruby 1.9相当。- Ruby版本之间的生产力确实有了惊人的提高。
- 我可以通过添加类型声明来优化Clojure代码吗？有帮助吗？
（当然还有Eratosthenes的筛 ..但是，这个微基准测试几乎是对迭代和数学运算的压力测试。但是，它们仍然不那么“公平”，因为有些更懒。）
我刚运行了Go版本和C版本（看起来很相似），但实际上两者的速度相同。我只尝试了100k版本：
—
塞巴斯蒂安·格里尼亚诺利
C: 2.723s Go: 2.743s。
您无需
—
ivant 2012年
sqrt为此检查进行计算。您可以计算iin 的平方for (i = 2; i * i <= x; ++i) ...
建议您使用注释Scala优化
—
Daniel C. Sobral
isPrime的@tailrec，以确保您使用的是尾递归。错误地执行阻止尾部递归的操作很容易，并且如果发生这种情况，此注释应该警告您。
sqrt(n)但是要花一些时间才能计算出来。同样，您的C代码在找到质数时会打印出质数，而其他语言会将它们计算为列表，然后将其打印出来。毫无疑问，C是最快的，但您也许可以更快地获得它。