Rosetta Code

Even numbers which cannot be expressed as the sum of two twin primes: Difference between revisions

Page Discussion

Even numbers which cannot be expressed as the sum of two twin primes (view source)

Revision as of 20:21, 24 April 2024

22,326 bytes added ,  1 month ago
Added various BASIC dialects (BASIC256, FreeBASIC and Yabasic)
(J)
(Added various BASIC dialects (BASIC256, FreeBASIC and Yabasic))
 
(13 intermediate revisions by 11 users not shown)
Line 31:
 
 
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">
F list_primality(n)
V result = [1B] * (n + 1)
result[0] = result[1] = 0B
L(i) 0 .. Int(sqrt(n))
I result[i]
L(j) (i * i .< result.len).step(i)
result[j] = 0B
R result
 
F nonpairsums(include1 = 0B, limit = 20'000)
V prim = list_primality(limit + 2)
 
‘ Even numbers which cannot be expressed as the sum of two twin primes ’
V tpri = (0 .< limit + 2).map(i -> @prim[i] & (@prim[i - 2] | @prim[i + 2]))
I include1
tpri[1] = 1B
V twinsums = [0B] * (limit * 2)
L(i) 0 .< limit
L(j) 0 .. limit - i
I tpri[i] & tpri[j]
twinsums[i + j] = 1B
 
R (2 .. limit).step(2).filter(i -> !@twinsums[i])
 
print(‘Non twin prime sums:’)
L(p) nonpairsums()
V k = L.index
print(f:‘{p:6}’, end' I (k + 1) % 10 == 0 {"\n"} E ‘’)
 
print("\n\nNon twin prime sums (including 1):")
L(p) nonpairsums(include1' 1B)
V k = L.index
print(f:‘{p:6}’, end' I (k + 1) % 10 == 0 {"\n"} E ‘’)
</syntaxhighlight>
 
{{out}}
<pre>
Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
 
Non twin prime sums (including 1):
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
</pre>
 
=={{header|ALGOL 68}}==
Line 108 ⟶ 162:
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
Found 33
</pre>
 
=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="vbnet">#include "isprime.kbs"
 
global limite
limite = 1e4
global TPTbl
dim TPTbl(limite)
global TPMax
 
i = 1
TPTbl[0] = 1
for n = 2 to limite
if isPrime(n) and isPrime(n+2) then
TPTbl[i] = n
i = i + 1
TPTbl[i] = n+2
i = i + 1
end if
next n
 
TPMax = i - 1
call Mostrar(1)
call Mostrar(0)
end
 
subroutine Mostrar(inicio)
dim ints(limite+1) fill 0
 
print "Non twin prime sums";
if inicio = 0 then print " (including 1 as a prime)";
print ":"
for i = inicio to TPMax
for j = i to TPMax
suma = TPTbl[i] + TPTbl[j]
if suma <= limite then
ints[suma] = 1
else
j = TPMax
end if
next j
next i
cnt = 0
for i = 2 to limite
if ints[i] = 0 then
print rjust(i, 5);
cnt += 1
if cnt mod 10 = 0 then print
end if
i = i + 1
next i
print : print "Found: "; cnt : print
end subroutine</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
==={{header|FreeBASIC}}===
<syntaxhighlight lang="vbnet">#include "isprime.bas"
 
Const limite = 1e4
Dim Shared As Uinteger TPTbl(limite)
Dim Shared As Uinteger TPMax
 
Sub Mostrar(inicio As Uinteger)
Dim As Uinteger i, j, suma, cnt
Dim As Uinteger ints(limite+1)
Print "Non twin prime sums";
If inicio = 0 Then Print " (including 1 as a prime)";
Print ":"
For i = inicio To TPMax
For j = i To TPMax
suma = TPTbl(i) + TPTbl(j)
If suma <= limite Then
ints(suma) = 1
Else
j = TPMax
End If
Next j
Next i
cnt = 0
For i = 2 To limite
If ints(i) = 0 Then
Print Using "#####"; i;
cnt += 1
If cnt Mod 10 = 0 Then Print
End If
i += 1
Next i
Print !"\nFound: "; cnt : Print
End Sub
 
Dim As Uinteger n, i = 1
TPTbl(0) = 1
For n = 2 To limite
If isPrime(n) Andalso isPrime(n+2) Then
TPTbl(i) = n
i += 1
TPTbl(i) = n+2
i += 1
End If
Next n
 
TPMax = i - 1
Mostrar(1)
Mostrar(0)
 
Sleep</syntaxhighlight>
{{out}}
<pre>Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
Found: 35
 
Non twin prime sums (including 1 as a prime):
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
Found: 33</pre>
 
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="vbnet">import isprime
 
limite = 10000
dim TPTbl(limite)
dim ints(limite+1)
 
TPTbl(0) = 1
i = 1
for n = 2 to limite
if isPrime(n) and isPrime(n+2) then
TPTbl(i) = n
i = i + 1
TPTbl(i) = n+2
i = i + 1
fi
next n
 
TPMax = i - 1
Mostrar(1)
Mostrar(0)
end
 
sub Mostrar(inicio)
local i, j, suma, cnt
print "Non twin prime sums";
if inicio = 0 print " (including 1 as a prime)";
print ":"
for i = inicio to TPMax
for j = i to TPMax
suma = TPTbl(i) + TPTbl(j)
if suma <= limite then
ints(suma) = 1
else
j = TPMax
fi
next j
next i
cnt = 0
for i = 2 to limite
if ints(i) = 0 then
print i using "#####";
cnt = cnt + 1
if mod(cnt, 10) = 0 print
fi
i = i + 1
next i
print "\nFound: ", cnt
print
end sub</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <iomanip>
#include <iostream>
#include <vector>
 
std::vector<bool> prime_sieve(int limit) {
std::vector<bool> sieve(limit, true);
if (limit > 0)
sieve[0] = false;
if (limit > 1)
sieve[1] = false;
for (int i = 4; i < limit; i += 2)
sieve[i] = false;
for (int p = 3, sq = 9; sq < limit; p += 2) {
if (sieve[p]) {
for (int q = sq; q < limit; q += p << 1)
sieve[q] = false;
}
sq += (p + 1) << 2;
}
return sieve;
}
 
void print_non_twin_prime_sums(const std::vector<bool>& sums) {
int count = 0;
for (size_t i = 2; i < sums.size(); i += 2) {
if (!sums[i]) {
++count;
std::cout << std::setw(4) << i << (count % 10 == 0 ? '\n' : ' ');
}
}
std::cout << "\nFound " << count << '\n';
}
 
int main() {
const int limit = 100001;
 
std::vector<bool> sieve = prime_sieve(limit + 2);
// remove non-twin primes from the sieve
for (size_t i = 0; i < limit; ++i) {
if (sieve[i] && !((i > 1 && sieve[i - 2]) || sieve[i + 2]))
sieve[i] = false;
}
 
std::vector<bool> twin_prime_sums(limit, false);
for (size_t i = 0; i < limit; ++i) {
if (sieve[i]) {
for (size_t j = i; i + j < limit; ++j) {
if (sieve[j])
twin_prime_sums[i + j] = true;
}
}
}
 
std::cout << "Non twin prime sums:\n";
print_non_twin_prime_sums(twin_prime_sums);
 
sieve[1] = true;
for (size_t i = 1; i + 1 < limit; ++i) {
if (sieve[i])
twin_prime_sums[i + 1] = true;
}
 
std::cout << "\nNon twin prime sums (including 1):\n";
print_non_twin_prime_sums(twin_prime_sums);
}</syntaxhighlight>
 
{{out}}
<pre>
Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
Found 35
 
Non twin prime sums (including 1):
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
Found 33
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
 
 
procedure ShowSumTwinPrimes(Memo: TMemo);
var Sieve: TPrimeSieve;
var Twins: TIntegerDynArray;
var S: string;
 
procedure GetTwinPrimes(WithOne: boolean);
{Build list of twin primes - include one, WithOne is true}
var I,P1,P2: integer;
begin
{Add one to list?}
if WithOne then
begin
SetLength(Twins,1);
Twins[0]:=1;
end
else SetLength(Twins,0);
{Look for numbers that P-1 or P+1 are two apart}
for I:=0 to Sieve.PrimeCount-1 do
if ((I>0) and ((Sieve.Primes[I]-Sieve.Primes[I-1]) = 2)) or
((I<(Sieve.PrimeCount-1)) and ((Sieve.Primes[I+1]-Sieve.Primes[I]) = 2)) then
begin
{Store twin}
SetLength(Twins,Length(Twins)+1);
Twins[High(Twins)]:=Sieve.Primes[I];
end;
end;
 
 
function IsNotTwinPrimeSum(N: integer): boolean;
{Test if number is NOT the sum of twin primes}
var I,J,Sum: integer;
begin
Result:=False;
{Test all combination of twin-prime sums}
for I:=0 to High(Twins) do
for J:=0 to High(Twins) do
begin
Sum:=Twins[I]+Twins[J];
if Sum>N then break;
if Sum=N then exit;
end;
Result:=True;
end;
 
 
function GetItems: string;
{Get first 5000 non twin prime sums}
var I,N,Cnt: integer;
begin
Result:=''; Cnt:=0;
for I:=1 to (5000 div 2)-1 do
begin
N:=I * 2;
if IsNotTwinPrimeSum(N) then
begin
Inc(Cnt);
Result:=Result+Format('%5d',[N]);
if (Cnt mod 10)=0 then Result:=Result+CRLF;
end;
end;
end;
 
begin
Sieve:=TPrimeSieve.Create;
try
Sieve.Intialize(1000000);
GetTwinPrimes(False);
Memo.Lines.Add('Non twin prime sums:');
Memo.Lines.Add(GetItems);
GetTwinPrimes(True);
Memo.Lines.Add('Non twin prime sums with one:');
Memo.Lines.Add(GetItems);
finally Sieve.Free; end;
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
Non twin prime sums with one:
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
 
Elapsed Time: 37.563 ms.
</pre>
 
 
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<syntaxhighlight lang="go">package main
 
import (
"fmt"
"rcu"
)
 
const limit = 100000 // say
 
func nonTwinSums(twins []int) []int {
sieve := make([]bool, limit+1)
for i := 0; i < len(twins); i++ {
for j := i; j < len(twins); j++ {
sum := twins[i] + twins[j]
if sum > limit {
break
}
sieve[sum] = true
}
}
var res []int
for i := 2; i < limit; i += 2 {
if !sieve[i] {
res = append(res, i)
}
}
return res
}
 
func main() {
primes := rcu.Primes(limit)[2:] // exclude 2 and 3
twins := []int{3}
for i := 0; i < len(primes)-1; i++ {
if primes[i+1]-primes[i] == 2 {
if twins[len(twins)-1] != primes[i] {
twins = append(twins, primes[i])
}
twins = append(twins, primes[i+1])
}
}
fmt.Println("Non twin prime sums:")
ntps := nonTwinSums(twins)
rcu.PrintTable(ntps, 10, 4, false)
fmt.Println("Found", len(ntps))
 
fmt.Println("\nNon twin prime sums (including 1):")
twins = append([]int{1}, twins...)
ntps = nonTwinSums(twins)
rcu.PrintTable(ntps, 10, 4, false)
fmt.Println("Found", len(ntps))
}</syntaxhighlight>
 
{{out}}
<pre>
Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
Found 35
 
Non twin prime sums (including 1):
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
Found 33
</pre>
Line 123 ⟶ 615:
</syntaxhighlight>
 
For the stretch goal, we count primesomitted sums of twin prime pairs, and compare the count with the count we get with a raised limit:
<syntaxhighlight lang="J">
#(2*1+i.2500)-.,+/~twp 5000
Line 130 ⟶ 622:
35
</syntaxhighlight>
 
=={{header|jq}}==
'''Adapted from [[#Wren|Wren]]'''
{{Works with|jq}}
'''Also works with gojq, the Go implementation of jq'''
 
'''Infrastructure'''
<syntaxhighlight lang=jq>
# Produce a stream of primes <= .
def eratosthenes:
# The array we use for the sieve only stores information for the odd integers greater than 1:
# index integer
# 0 3
# k 2*k + 3
# So if we wish to mark m = 2*k + 3, the relevant index is: m - 3 / 2
def ix:
if . % 2 == 0 then null
else ((. - 3) / 2)
end;
 
# erase(i) sets .[i*j] to false for odd integral j > i on the assumption that i is odd
def erase(i):
((i - 3) / 2) as $k
| (((length * 2 + 3) / i)) as $upper
# ... only consider odd multiples from i onwards
| reduce range(i; $upper; 2) as $j (.;
(((i * $j) - 3) / 2) as $m
| if .[$m] then .[$m] = false else . end);
 
if . < 2 then []
else (. + 1) as $n
| (($n|sqrt) / 2) as $s
| [range(3; $n; 2)|true]
| reduce (1 + (2 * range(1; $s)) ) as $i (.; erase($i))
| . as $sieve
# We could at this point produce an array of primes by writing:
# | [2] + reduce range(3; $n; 2) as $k ([]; if $sieve[$k|ix] then . + [$k] else . end)
| 2, (range(3; $n; 2) | select($sieve[ix]))
end ;
 
# Emit an array of the primes <= $limit that have twins
def twins($limit):
# exclude 2 and 3
($limit | [eratosthenes][2:]) as $primes
| reduce range(0;$primes|length-1) as $i ([3];
if ($primes[$i+1] - $primes[$i] == 2)
then if (.[-1] != $primes[$i]) then . + [$primes[$i]] else . end
| . + [$primes[$i+1]]
else .
end);
 
# Emit an array
def nonTwinSums($limit; $twins):
reduce range(0; $twins|length) as $i (
{ sieve: [range(0; $limit+1) | false] };
.emit = null
| .j = $i
| until(.emit;
($twins[$i] + $twins[.j]) as $sum
| if $sum > $limit then .emit = .sieve
else .sieve[$sum] = true
end
| .j += 1
| if .j == ($twins|length) then .emit = .sieve else . end )
)
| .sieve as $sieve
| reduce range(2; $limit + 1; 2) as $i ([];
if ($sieve[$i] | not) then . + [ $i ] else . end) ;
</syntaxhighlight>
 
'''The Task'''
<syntaxhighlight lang=jq>
def task($limit):
twins($limit) as $twins
| ( "Non twin prime sums:",
( nonTwinSums($limit; $twins) as $ntps
| $ntps, " Found \($ntps|length)" ) ),
("\nNon twin prime sums (including 1):",
( nonTwinSums($limit; [1] + $twins) as $ntps
| $ntps, " Found \($ntps|length)" )) ;
 
# Example:
task(100000)
</syntaxhighlight>
 
'''Invocation''': jq -nrc -f task.jq
{{output}}
<syntaxhighlight lang=bash>
Non twin prime sums:
[2,4,94,96,98,400,402,404,514,516,518,784,786,788,904,906,908,1114,1116,1118,1144,1146,1148,1264,1266,1268,1354,1356,1358,3244,3246,3248,4204,4206,4208]
Found 35
 
Non twin prime sums (including 1):
[94,96,98,400,402,404,514,516,518,784,786,788,904,906,908,1114,1116,1118,1144,1146,1148,1264,1266,1268,1354,1356,1358,3244,3246,3248,4204,4206,4208]
Found 33
</syntaxhighlight>
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Primes
Line 169 ⟶ 758:
4204 4206 4208
</pre>
 
=={{header|Nim}}==
{{trans|Wren}}
Instead of using a sieve to build the list of primes, we check directly if a number is prime.
<syntaxhighlight lang="Nim">import std/[strformat, sugar]
 
const Limit = 100_000
 
func isPrime(n: Natural): bool =
if n < 2: return false
if (n and 1) == 0: return n == 2
if n mod 3 == 0: return n == 3
var k = 5
var delta = 2
while k * k <= n:
if n mod k == 0: return false
inc k, delta
delta = 6 - delta
result = true
 
let primes = collect:
for n in countup(5, Limit, 2):
if n.isPrime: n
 
var twins = @[3]
for i in 0..<primes.high:
if primes[i + 1] - primes[i] == 2:
if twins[^1] != primes[i]:
twins.add primes[i]
twins.add primes[i + 1]
 
func nonTwinSums(twins: seq[int]): seq[int] =
var sieve = newSeq[bool](Limit + 1)
for i in 0..twins.high:
for j in i..twins.high:
let sum = twins[i] + twins[j]
if sum > Limit: break
sieve[sum] = true
var i = 2
while i <= Limit:
if not sieve[i]:
result.add i
inc i, 2
 
echo "Non twin prime sums:"
var ntps = nonTwinSums(twins)
for i, n in ntps:
stdout.write &"{n:4}"
stdout.write if i mod 10 == 9: '\n' else: ' '
echo &"\nFound {ntps.len}.\n"
 
echo "Non twin prime sums (including 1):"
twins.insert(1, 0)
ntps = nonTwinSums(twins)
for i, n in ntps:
stdout.write &"{n:4}"
stdout.write if i mod 10 == 9: '\n' else: ' '
echo &"\nFound {ntps.len}.\n"
</syntaxhighlight>
 
{{out}}
<pre>Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
Found 35.
 
Non twin prime sums (including 1):
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
Found 33.
</pre>
 
=={{header|Perl}}==
{{trans|Raku}}
{{libheader|ntheory}}
<syntaxhighlight lang="perl" line>use v5.36;
use experimental 'for_list';
use List::Util 'uniq';
use ntheory 'is_prime';
 
sub X ($a, $b) { my @c; for my $aa (0..$a-1) { for my $bb (0..$b-1) { push @c, $aa, $bb } } @c }
sub table ($c, @V) { my $t = $c * (my $w = 6); ( sprintf( ('%'.$w.'d')x@V, @V) ) =~ s/.{1,$t}\K/\n/gr }
sub display (@s) { table 10, grep { $_ < 5000 } grep { not $s[$_] and 0==$_%2 and $_ } 0..@s }
 
my ($limit, @sums) = 10_000;
my @twins = uniq map { $_, $_+2 } grep { is_prime $_ and is_prime($_+2) } 3 .. $limit;
for my($i,$j) ( X ((scalar @twins) x 2) ) { ++$sums[ $twins[$i] + $twins[$j] ] }
say "Non twin prime sums:\n" . display @sums;
++$sums[1 + $_] for 1, @twins;
say "\nNon twin prime sums (including 1):\n" . display @sums;</syntaxhighlight>
{{out}}
<pre>Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
 
Non twin prime sums (including 1):
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208</pre>
 
=={{header|Phix}}==
Line 420 ⟶ 1,115:
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var limit = 1e4
 
func display(msg, sums) {
say msg
2..limit -> by(2).grep{ !sums.has(_) }.each_slice(10, {|*s|
say s.map{ '%4s' % _ }.join(' ')
})
}
 
var sums = Set()
var twins = primes(3, limit).cons(2).grep{ .diffs[0] == 2 }.flat.uniq
 
[twins, twins].cartesian{|a,b| sums << a+b }
display("Non twin prime sums:", sums)
 
sums << (2, twins.map{.inc}...)
display("\nNon twin prime sums (including 1):", sums)</syntaxhighlight>
{{out}}
<pre>
Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
 
Non twin prime sums (including 1):
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="ecmascriptwren">import "./math" for Int
import "./fmt" for Fmt
 
Line 483 ⟶ 1,211:
Found 33
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func IsPrime(N); \Return 'true' if N is prime
int N, I;
[if N <= 2 then return N = 2;
if (N&1) = 0 then \even >2\ return false;
for I:= 3 to sqrt(N) do
[if rem(N/I) = 0 then return false;
I:= I+1;
];
return true;
];
 
def Limit = 1000000; \stretch case
int TPTbl(Limit), \Twin Prime Table
Ints(Limit+1);
int I, J, N, Sum, TPMax, Cnt;
 
 
proc Show(Start); \Show non twin prime sums
int Start;
[Text(0, "Non twin prime sums");
if Start = 0 then Text(0, " (including 1 as a prime)");
Text(0, ":^m^j");
for N:= 0 to Limit do \initialize all Ints as not a sum
Ints(N):= false;
for I:= Start to TPMax do
for J:= I to TPMax do
[Sum:= TPTbl(I) + TPTbl(J);
if Sum <= Limit then
Ints(Sum):= true \mark integer as "is a sum"
else J:= TPMax; \don't search beyond Limit
];
Format(5, 0);
Cnt:= 0;
for I:= 2 to Limit do
[if Ints(I) = false then
[RlOut(0, float(I));
Cnt:= Cnt+1;
if rem(Cnt/10) = 0 then CrLf(0);
];
I:= I+1; \step 'for' loop by 2
];
CrLf(0);
];
 
 
[TPTbl(0):= 1; \case where 1 = prime
I:= 1;
for N:= 2 to Limit do \build table of primes with a twin
if IsPrime(N) & IsPrime(N+2) then
[TPTbl(I):= N; I:= I+1;
TPTbl(I):= N+2; I:= I+1;
];
TPMax:= I-1;
Show(1);
Show(0);
]</syntaxhighlight>
{{out}}
<pre>
Non twin prime sums:
2 4 94 96 98 400 402 404 514 516
518 784 786 788 904 906 908 1114 1116 1118
1144 1146 1148 1264 1266 1268 1354 1356 1358 3244
3246 3248 4204 4206 4208
Non twin prime sums (including 1 as a prime):
94 96 98 400 402 404 514 516 518 784
786 788 904 906 908 1114 1116 1118 1144 1146
1148 1264 1266 1268 1354 1356 1358 3244 3246 3248
4204 4206 4208
</pre>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">UpperLimit = 10000;
SmallerTwinPrimes = Select[Range[UpperLimit], (PrimeQ[#] && PrimeQ[# + 2]) &];(*Finds set of smaller twin primes up to UpperLimit*)
AllTwinPrimes = Union[SmallerTwinPrimes, SmallerTwinPrimes + 2]; (*Gives set of all twin primes up to UpperLimit*)
CheckIfNotSumOfNumbersInSet[n_, set_] := If[Intersection[(n - set), set] == {}, n, ## &[]] (*Finds elements in set_ that sum to n_, then displays them, otherwise it gives an empty set*)
ListOfNonTwinPrimeSums = Table[CheckIfNotSumOfNumbersInSet[n, AllTwinPrimes], {n, 2, UpperLimit, 2}]; (*Generates table of elements that are not sums of twin \primes*)
ListOfNonTwinPrimeSumsWith1 = Table[CheckIfNotSumOfNumbersInSet[n, Union[AllTwinPrimes, {1}]], {n, 2, UpperLimit, 2}]; (*Same as above, but treating 1 as a twin prime*)
StringTemplate["Non twin prime sums: `list`, found `length`"][<|"list" -> ListOfNonTwinPrimeSums, "length" -> Length[ListOfNonTwinPrimeSums]|>]
StringTemplate["Non twin prime sums (including 1 as a prime): `list`, found `length`"][<|"list" -> ListOfNonTwinPrimeSumsWith1, "length" -> Length[ListOfNonTwinPrimeSumsWith1]|>]</syntaxhighlight>
 
{{out}}<pre>Non twin prime sums: {2, 4, 94, 96, 98, 400, 402, 404, 514, 516, 518, 784, 786, 788, 904, 906, 908, 1114, 1116, 1118, 1144, 1146, 1148, 1264, 1266, 1268, 1354, 1356, 1358, 3244, 3246, 3248, 4204, 4206, 4208}, found 35
 
Non twin prime sums (including 1 as a prime): {94, 96, 98, 400, 402, 404, 514, 516, 518, 784, 786, 788, 904, 906, 908, 1114, 1116, 1118, 1144, 1146, 1148, 1264, 1266, 1268, 1354, 1356, 1358, 3244, 3246, 3248, 4204, 4206, 4208}, found 33</pre>
Jjuanhdez
2,130

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/332700...363934"