Ultra useful primes: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Wren}}: Changed to Wren S/H) |
|||
| (14 intermediate revisions by 9 users not shown) | |||
Line 79:
9 | 569
10 | 105</pre>
=={{header|C}}==
{{trans|Wren}}
{{libheader|GMP}}
<syntaxhighlight lang="c">#include <stdio.h>
#include <gmp.h>
int a(unsigned int n) {
int k;
mpz_t p;
mpz_init_set_ui(p, 1);
mpz_mul_2exp(p, p, 1 << n);
mpz_sub_ui(p, p, 1);
for (k = 1; ; k += 2) {
if (mpz_probab_prime_p(p, 15) > 0) return k;
mpz_sub_ui(p, p, 2);
}
}
int main() {
unsigned int n;
printf(" n k\n");
printf("----------\n");
for (n = 1; n < 15; ++n) printf("%2d %d\n", n, a(n));
return 0;
}</syntaxhighlight>
{{out}}
<pre>
n k
----------
1 1
2 3
3 5
4 15
5 5
6 59
7 159
8 189
9 569
10 105
11 1557
12 2549
13 2439
14 13797
</pre>
=={{header|Craft Basic}}==
<syntaxhighlight lang="basic">for n = 1 to 10
let k = -1
do
let k = k + 2
wait
loop prime(2 ^ (2 ^ n) - k) = 0
print "n = ", n, " k = ", k
next n</syntaxhighlight>
=={{header|Factor}}==
Line 93 ⟶ 155:
1 3 5 15 5 59 159 189 569 105
</pre>
=={{header|FreeBASIC}}==
{{trans|Ring}}
<syntaxhighlight lang="vb">#include "isprime.bas"
Dim As Longint n, k, limit = 10
Dim As ulongint num
For n = 1 To limit
k = -1
Do
k += 2
num = (2 ^ (2 ^ n)) - k
If isPrime(num) Then
Print "n = "; n; " k = "; k
Exit Do
End If
Loop
Next
Sleep</syntaxhighlight>
=={{header|Go}}==
Line 149 ⟶ 231:
<syntaxhighlight lang="j">uup=: {{
ref=.
k=. 1
while. -. 1 p: ref-k do. k=. k+2 end.
Line 156 ⟶ 238:
I don't have the patience to get this little laptop to compute the first 10 such elements, so here I only show the first five:
<syntaxhighlight lang="j"> uup i.
1 3 5 15 5 59 159 189 569 105</syntaxhighlight>
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.math.BigInteger;
public final class UltraUsefulPrimes {
public static void main(String[] args) {
for ( int n = 1; n <= 10; n++ ) {
showUltraUsefulPrime(n);
}
}
private static void showUltraUsefulPrime(int n) {
BigInteger prime = BigInteger.ONE.shiftLeft(1 << n);
BigInteger k = BigInteger.ONE;
while ( ! prime.subtract(k).isProbablePrime(20) ) {
k = k.add(BigInteger.TWO);
}
System.out.print(k + " ");
}
}
</syntaxhighlight>
{{ out }}
<pre>
1 3 5 15 5 59 159 189 569 105
</pre>
=={{header|Julia}}==
Line 199 ⟶ 312:
10 105
11 1557</pre>
=={{header|Nim}}==
{{libheader|Nim-Integers}}
<syntaxhighlight lang="Nim">import std/strformat
import integers
let One = newInteger(1)
echo " n k"
var count = 1
var n = 1
while count <= 13:
var k = 1
var p = One shl (1 shl n) - k
while not p.isPrime:
p -= 2
k += 2
echo &"{n:2} {k}"
inc n
inc count
</syntaxhighlight>
{{out}}
<pre> n k
1 1
2 3
3 5
4 15
5 5
6 59
7 159
8 189
9 569
10 105
11 1557
12 2549
13 2439
</pre>
=={{header|Perl}}==
Line 275 ⟶ 426:
<pre>1 3 5 15 5 59 159 189 569 105
1557 2549 2439</pre>
=={{header|Python}}==
<syntaxhighlight lang="python>
# useful.py by xing216
from gmpy2 import is_prime
def useful(n):
k = 1
is_useful = False
while is_useful == False:
if is_prime(2**(2**n) - k):
is_useful = True
break
k += 2
return k
if __name__ == "__main__":
print("n | k")
for i in range(1,14):
print(f"{i:<4}{useful(i)}")
</syntaxhighlight>
{{out}}
<pre>
n | K
1 1
2 3
3 5
4 15
5 5
6 59
7 159
8 189
9 569
10 105
11 1557
12 2549
13 2439
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
see "works..." + nl
limit = 10
for n = 1 to limit
k =
while true
k = k +
num = pow(2,pow(2,n)) - k
if isPrime(num)
exit
ok
end
next
see "done.." + nl
Line 302 ⟶ 485:
if (num % i = 0) return 0 ok
next
return 1
</syntaxhighlight
{{out}}
<pre>
Line 369 ⟶ 552:
</pre>
(takes ~20 seconds)
=={{header|V (Vlang)}}==
<syntaxhighlight lang="Zig">
import math
fn main() {
limit := 10 // depending on computer, higher numbers = longer times
mut num, mut k := i64(0), i64(0)
println("n k\n-------")
for n in 1..limit {
k = -1
for n < limit {
k = k + 2
num = math.powi(2, math.powi(2 , n)) - k
if is_prime(num) == true {
println("${n} ${k}")
break
}
}
}
}
fn is_prime(num i64) bool {
if num <= 1 {return false}
if num % 2 == 0 && num != 2 {return false}
for idx := 3; idx <= math.floor(num / 2) - 1; idx += 2 {
if num % idx == 0 {return false}
}
return true
}
</syntaxhighlight>
{{out}}
<pre>
n k
-------
1 1
2 3
3 5
4 15
5 5
6 59
7 159
8 189
9 569
10 105
</pre>
=={{header|Wren}}==
Line 375 ⟶ 605:
{{libheader|Wren-fmt}}
Manages to find the first ten but takes 84 seconds to do so.
<syntaxhighlight lang="
import "./fmt" for Fmt
Line 413 ⟶ 643:
{{libheader|Wren-gmp}}
The following takes about 17 seconds to get to n = 13 but 7 minutes 10 seconds to reach n = 14. I didn't bother after that.
<syntaxhighlight lang="
import "./fmt" for Fmt
| |||