Ramanujan primes/twins: Difference between revisions
Added FreeBASIC
m (Trying to reformat the page.) |
(Added FreeBASIC) |
||
| (4 intermediate revisions by 4 users not shown) | |||
Line 117:
The 1_000_000th Ramanujan prime is 34072993
There are 74973 twins in the first 1000000 Ramanujan primes.
</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
global cnt[] .
proc primcnt limit . .
cnt[] = [ 0 1 1 ]
for i = 4 step 2 to limit
cnt[] &= 0
cnt[] &= 1
.
p = 3
sq = 9
while sq <= limit
if cnt[p] <> 0
for q = sq step p * 2 to limit
cnt[q] = 0
.
.
sq += (p + 1) * 4
p += 2
.
for i = 2 to limit
sum += cnt[i]
cnt[i] = sum
.
.
func log n .
e = 2.7182818284590452354
return log10 n / log10 e
.
func ramamax n .
return floor (4 * n * log (4 * n))
.
func ramaprim_twins n .
i = ramamax n
i -= i mod 2
while i >= 2
if cnt[i] - cnt[i / 2] < n
p1 = p
p = i + 1
if p1 - p = 2
cnt += 1
.
n -= 1
.
i -= 2
.
return cnt
.
primcnt ramamax 1000000
print ramaprim_twins 1000000
</syntaxhighlight>
{{out}}
<pre>
74973
</pre>
Line 129 ⟶ 185:
There are 74973 twins in the first million Ramanujan primes
</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="vbnet">#define floor(x) ((x*2.0-0.5) Shr 1)
Dim Shared pi() As Integer
Sub primeCounter(limit As Integer)
Dim As Integer i, q, p, sq, total
Redim pi(limit)
pi(0) = 0
pi(1) = 0
For i = 2 To limit
pi(i) = 1
Next
If limit > 2 Then
For i = 4 To limit Step 2
pi(i) = 0
Next i
p = 3
sq = 9
While sq <= limit
If pi(p) <> 0 Then
For q = sq To limit Step p*2
pi(q) = 0
Next q
End If
sq += (p + 1) * 4
p += 2
Wend
total = 0
For i = 2 To limit
total += pi(i)
pi(i) = total
Next i
End If
End Sub
Function ramanujanMax(n As Integer) As Integer
Return floor(4 * n * Log(4*n))
End Function
Function ramanujanPrimeTwins(n As Integer) As Integer
Dim As Integer maxposs, p1, p, cnt
maxposs = ramanujanMax(n)
maxposs -= maxposs Mod 2
While maxposs >= 2
If pi(maxposs) - pi(maxposs \ 2) < n Then
p1 = p
p = maxposs + 1
If p1 - p = 2 Then cnt += 1
n -= 1
End If
maxposs -= 2
Wend
Return cnt
End Function
Dim As Integer limit = 1e6
Dim As Double t0 = Timer
primeCounter ramanujanMax(limit)
Print Using "There are & twins in the first & Ramanujan primes"; ramanujanPrimeTwins(limit); limit
Print Using "##.##sec."; Timer - t0
Sleep</syntaxhighlight>
{{out}}
<pre>There are 74973 twins in the first 1000000 Ramanujan primes
1.53sec.</pre>
=={{header|Go}}==
Line 250 ⟶ 373:
Took 699.967994ms
</pre>
=={{header|J}}==
<syntaxhighlight lang="j"> _2 +/@:= 2 -/\ (((] - _1&(33 b.)@:>:@[ { ]) _1&p:) i. 35e6) i: i. 1e6
74973</syntaxhighlight>
=={{header|Java}}==
Line 618 ⟶ 745:
There are 74,973 twins in the first 1,000,000 Ramanujan primes.
2.529 seconds</pre>
=={{header|Scala}}==
{{trans|Java}}
<syntaxhighlight lang="Scala">
import java.util.{ArrayList, Arrays, List}
object RamanujanPrimesTwins {
def main(args: Array[String]): Unit = {
val limit = 1_000_000
val primePi = initialisePrimePi(ramanujanMaximum(limit) + 1)
val millionthRamanujanPrime = ramanujanPrime(primePi, limit)
println(s"The 1_000_000th Ramanujan prime is $millionthRamanujanPrime")
val primes = listPrimesLessThan(millionthRamanujanPrime)
val ramanujanPrimeIndexes = new Array[Int](primes.size)
for (i <- 0 until primes.size by 1) {
ramanujanPrimeIndexes(i) = primePi(primes.get(i)) - primePi(primes.get(i) / 2)
}
var lowerLimit = ramanujanPrimeIndexes(ramanujanPrimeIndexes.length - 1)
for (i <- ramanujanPrimeIndexes.length - 2 to 0 by -1) {
if (ramanujanPrimeIndexes(i) < lowerLimit) {
lowerLimit = ramanujanPrimeIndexes(i)
} else {
ramanujanPrimeIndexes(i) = 0
}
}
val ramanujanPrimes = new ArrayList[Integer]()
for (i <- 0 until ramanujanPrimeIndexes.size by 1) {
if (ramanujanPrimeIndexes(i) != 0) {
ramanujanPrimes.add(primes.get(i))
}
}
var twinsCount = 0
for (i <- 0 until ramanujanPrimes.size - 1) {
if (ramanujanPrimes.get(i) + 2 == ramanujanPrimes.get(i + 1)) {
twinsCount += 1
}
}
println(s"There are $twinsCount twins in the first $limit Ramanujan primes.")
}
private def listPrimesLessThan(limit: Int): List[Integer] = {
val composite = new Array[Boolean](limit + 1)
var n = 3
var nSquared = 9
while (nSquared <= limit) {
if (!composite(n)) {
for (k <- nSquared until limit by (2*n) ) {
composite(k) = true
}
}
nSquared += (n + 1) << 2
n += 2
}
var result = new ArrayList[Integer]()
result.add(2)
for (i <- 3 until limit by 2) {
if (!composite(i)) {
result.add(i)
}
}
result
}
private def ramanujanPrime(primePi: Array[Int], number: Int): Int = {
var maximum = ramanujanMaximum(number)
if ((maximum & 1) == 1) {
maximum -= 1
}
var index = maximum
while (primePi(index) - primePi(index / 2) >= number) {
index -= 1
}
index + 1
}
private def initialisePrimePi(aLimit : Int): Array[Int] = {
val result = new Array[Int](aLimit )
Arrays.fill(result, 1)
result(0) = 0
result(1) = 0
for (i <- 4 until aLimit by 2) {
result(i) = 0
}
var p = 3;var square = 9;
while(square < aLimit) {
if ( result(p) != 0 ) {
for ( q <- square until aLimit by (p << 1) ) {
result(q) = 0;
}
}
square += ( p + 1 ) << 2;
p += 2
}
for (i <- 1 until result.length) {
result(i) += result(i - 1)
}
result
}
private def ramanujanMaximum(number: Int): Int = {
Math.ceil(4 * number * Math.log(4 * number)).toInt
}
}
</syntaxhighlight>
{{out}}
<pre>
The 1_000_000th Ramanujan prime is 34072993
There are 74973 twins in the first 1000000 Ramanujan primes.
</pre>
=={{header|Sidef}}==
Line 643 ⟶ 888:
<br>
As calculating the first 1 million Ramanujan primes individually is out of the question, we follow the Phix entry's clever strategy here which brings this task comfortably within our ambit.
<syntaxhighlight lang="
import "./math" for Int, Math
import "./fmt" for Fmt
var count
Line 710 ⟶ 955:
}
Fmt.print("There are $,d twins in the first $,d Ramanujan primes.", twins, limit)
System.print("Took %(Math.toPlaces(System.clock - start, 2, 0)) seconds.\n")
}</syntaxhighlight>
| |||