Rosetta Code

Successive prime differences: Difference between revisions

Page Discussion

Successive prime differences (view source)

Revision as of 16:54, 10 February 2024

14,453 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
(Added Arturo implementation)
m (→‎{{header|Wren}}: Minor tidy)
 
(10 intermediate revisions by 7 users not shown)
Line 34:
{{trans|D}}
 
<langsyntaxhighlight lang="11l">F primes_upto(limit)
V is_prime = [0B] * 2 [+] [1B] * (limit - 1)
L(n) 0 .< Int(limit ^ 0.5 + 1.5)
Line 67:
print(‘ Last group = ’sp.last)
print(‘ Number found = ’sp.len)
print()</langsyntaxhighlight>
 
{{out}}
Line 105:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68">BEGIN # find some sequences of primes where the gaps between the elements #
# follow specific patterns #
# reurns a list of primes up to n #
Line 172:
try differences( p list, ( 2, 4, 6, 8 ) );try differences( p list, ( 2, 4, 6, 8, 10 ) );
try differences( p list, ( 32, 16, 8, 4, 2 ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 202:
Found 1 prime sequence(s) that differ by: [ 32 16 8 4 2 ]
first: [ 148091 148123 148139 148147 148151 148153 ] last: [ 148091 148123 148139 148147 148151 148153 ]
 
</pre>
 
 
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="c">
 
#proto buscarprimos(_X_,_Y_)
 
#include <basico.h>
 
algoritmo
 
pila de trabajo 50
decimales '0'
números( dif 1, dif 2, dif 22, dif 24, dif 42, dif 642)
cadenas( inicio1, inicio2, inicio22, inicio24, inicio42, inicio642,\
final1, final2, final22, final24, final42, final642 )
sw1=1, sw2=1, sw22=1, sw24=1, sw42=1, sw642=1
i=2
iterar
i, es primo?, entonces {
i2 = i, i4=i, i6=i
++i2; i2, es primo?, entonces{
++dif 1
sw1, entonces{
#( string(i)),#(string(i2)), unir en 'inicio1'
sw1=0
}
#( string(i)),#(string(i2)), unir en 'final1'
}
++i2; i2, es primo?, entonces{
++dif 2
sw2, entonces{
#( string(i)),#(string(i2)), unir en 'inicio2'
sw2=0
}
#( string(i)),#(string(i2)), unir en 'final2'
 
i2+=2; i2, es primo?, entonces{
++dif 22
sw22, entonces{
#( string(i)),#(string(i2-2)),#(string(i2))
unir en 'inicio22'
sw22=0
}
#( string(i)),#(string(i2-2)),#(string(i2))
unir en 'final22'
}
i2+=2; i2, es primo?, entonces{
++dif 24
sw24, entonces{
#( string(i)),#(string(i2-4)),#(string(i2))
unir en 'inicio24'
sw24=0
}
#( string(i)),#(string(i2-4)),#(string(i2))
unir en 'final24'
}
}
i4+=4, i4, es primo?, entonces{
i4+=2, i4, es primo?, entonces{
++dif 42
sw42, entonces{
#( string(i)),#(string(i4-2)),#(string(i4))
unir en 'inicio42'
sw42=0
}
#( string(i)),#(string(i4-2)),#(string(i4))
unir en 'final42'
}
}
/* aquí, debido al espaciamiento, pueden haber primos entre 'i'
e 'i+12', y debo chequear eso */
i6+=6, i6, es primo?, entonces{
i6+=4, i6, es primo?, entonces{
i6+=2, i6, es primo?, entonces{
si '#(buscar primos( (i+1),(i6-6) ) && buscar primos( (i6-5),i6-2))'
sw642, entonces{
#( string(i)),#(string(i6-6)),#(string(i6-2)),#(string(i6))
unir en 'inicio642'
sw642=0
}
++dif 642
fin si
 
#( string(i)),#(string(i6-6)),#(string(i6-2)),#(string(i6))
unir en 'final642'
}
}
}
}
++i
hasta que '#(i == 1000000)'
imprimir( "Diff Sequence\tCount\t\tFirst\tLast\n")
imprimir( "[ 1 ] \t", dif 1, "\t", #(lpad(" ",13,inicio1))," ",final1,\
"\n[ 2 ] \t", dif 2, "\t", #(lpad(" ",13,inicio2))," ",final2,\
"\n[ 2-2 ] \t", dif22, "\t", #(lpad(" ",13,inicio22))," ",final22,\
"\n[ 2-4 ] \t", dif 24,"\t", #(lpad(" ",13,inicio24))," ",final24,\
"\n[ 4-2 ] \t", dif 42,"\t", #(lpad(" ",13,inicio42))," ",final42,\
"\n[ 6-4-2 ]\t", dif 642,"\t", #(lpad(" ",13,inicio642))," ",final642,"\n")
 
terminar
 
subrutinas
 
buscar primos(x,y)
sw=1
iterar para( i=x, #(sw && i<y), ++i )
i, es primo?, entonces{
sw=0
}
siguiente
retornar 'sw'
</syntaxhighlight>
{{out}}
<pre>
Diff Sequence Count First Last
[ 1 ] 1 2,3 2,3
[ 2 ] 8169 3,5 999959,999961
[ 2-2 ] 1 3,5,7 3,5,7
[ 2-4 ] 1393 5,7,11 999431,999433,999437
[ 4-2 ] 1444 7,11,13 997807,997811,997813
[ 6-4-2 ] 306 31,37,41,43 997141,997147,997151,997153
 
</pre>
Line 207 ⟶ 335:
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">LIM: 1000000
 
findDiffs: function [r][
Line 236 ⟶ 364:
print ["\tLast: " join.with:" " to [:string] last diffs]
print ["\tCount: " size diffs]
]</langsyntaxhighlight>
 
{{out}}
Line 266 ⟶ 394:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f SUCCESSIVE_PRIME_DIFFERENCES.AWK
BEGIN {
Line 311 ⟶ 439:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 328 ⟶ 456:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
Line 497 ⟶ 625:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>differences|count|first group|last group
Line 508 ⟶ 636:
 
=={{header|C sharp}}==
<langsyntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using static System.Linq.Enumerable;
Line 556 ⟶ 684:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 568 ⟶ 696:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <cstdint>
#include <vector>
Line 646 ⟶ 774:
}
return 0;
}</langsyntaxhighlight>
 
Contents of prime_sieve.hpp:
<langsyntaxhighlight lang="cpp">#ifndef PRIME_SIEVE_HPP
#define PRIME_SIEVE_HPP
 
Line 700 ⟶ 828:
}
 
#endif</langsyntaxhighlight>
 
{{out}}
Line 714 ⟶ 842:
=={{header|D}}==
{{trans|Go}}
<langsyntaxhighlight lang="d">import std.algorithm;
import std.array;
import std.range;
Line 822 ⟶ 950:
writeln();
}
}</langsyntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-
Line 858 ⟶ 986:
{{libheader| System.SysUtils}}
{{libheader| System.Generics.Collections}}
<syntaxhighlight lang="delphi">
<lang Delphi>
program Successive_prime_differences;
 
Line 1,007 ⟶ 1,135:
end.
 
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,018 ⟶ 1,146:
(6, 4, 2): first group = (31,37,41,43), last group = (997141,997147,997151,997153), count = 306
</pre>
 
=={{header|EasyLang}}==
{{trans|FreeBASIC}}
<syntaxhighlight>
fastfunc isprim num .
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
func nextprime n .
n += 1
while isprim n = 0
n += 1
.
return n
.
func spd n d[] .
if isprim n = 0
return 0
.
for i = 1 to len d[]
if nextprime n <> n + d[i]
return 0
.
n += d[i]
.
return 1
.
proc print_set n d[] . .
write "( " & n & " "
for i = 1 to len d[]
write n + d[i] & " "
n += d[i]
.
print ")"
.
proc show max d[] . .
write "Differences of "
for d in d[]
write d & " "
.
print ""
for n = 2 to max - d[len d[]]
if spd n d[] = 1
c += 1
if c = 1
print_set n d[]
.
last = n
.
.
print_set last d[]
print "Number of occurrences: " & c
print ""
.
show 1000000 [ 2 ]
show 1000000 [ 1 ]
show 1000000 [ 2 2 ]
show 1000000 [ 2 4 ]
show 1000000 [ 4 2 ]
show 1000000 [ 6 4 2 ]
</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]
<langsyntaxhighlight lang="fsharp">
// Successive primes. Nigel Galloway: May 6th., 2019
let sP n=let sP=pCache|>Seq.takeWhile(fun n->n<1000000)|>Seq.windowed(Array.length n+1)|>Seq.filter(fun g->g=(Array.scan(fun n g->n+g) g.[0] n))
printfn "sP %A\t-> Min element = %A Max element = %A of %d elements" n (Seq.head sP) (Seq.last sP) (Seq.length sP)
List.iter sP [[|2|];[|1|];[|2;2|];[|2;4|];[|4;2|];[|6;4;2|]]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,039 ⟶ 1,234:
=={{header|Factor}}==
{{works with|Factor|0.99}}
<langsyntaxhighlight lang="factor">USING: formatting fry grouping kernel math math.primes
math.statistics sequences ;
IN: rosetta-code.successive-prime-differences
Line 1,065 ⟶ 1,260:
} [ show ] with each ;
MAIN: successive-prime-differences</langsyntaxhighlight>
{{out}}
<pre>
Line 1,101 ⟶ 1,296:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#include "isprime.bas"
 
function nextprime( n as uinteger ) as uinteger
Line 1,189 ⟶ 1,384:
print "Differences of 6, 4, 2"
c = count_below(1000000, d())
print "Number of occurrences: ", c</langsyntaxhighlight>
{{out}}<pre>
Differences of 2 (the twin primes)
Line 1,223 ⟶ 1,418:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 1,291 ⟶ 1,486:
fmt.Println()
}
}</langsyntaxhighlight>
 
{{out}}
Line 1,331 ⟶ 1,526:
Uses primes library: http://hackage.haskell.org/package/primes-0.2.1.0/docs/Data-Numbers-Primes.html
===Fixed computed values===
<langsyntaxhighlight lang="haskell">{-# LANGUAGE NumericUnderscores #-}
import Data.Numbers.Primes (primes)
 
Line 1,362 ⟶ 1,557:
main :: IO ()
main = showGroup "2" >> showGroup "1" >> showGroup "(2 2)" >> showGroup "(2 4)" >> showGroup "(4 2)"
>> showGroup "(6 4 2)"</langsyntaxhighlight>
 
===Dynamic computed input===
<langsyntaxhighlight lang="haskell">{-# LANGUAGE NumericUnderscores #-}
import Data.Numbers.Primes (primes)
 
Line 1,399 ⟶ 1,594:
where
(diffs, result) = groups [[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]]
groups diffs = (diffs, findPrimes (takeWhile (< 1_000_000) primes) diffs)</langsyntaxhighlight>
{{out}}
<pre>
Line 1,428 ⟶ 1,623:
 
=={{header|J}}==
<syntaxhighlight lang="j">
<lang j>
primes_less_than=: i.&.:(p:inv)
assert 2 3 5 -: primes_less_than 7
Line 1,466 ⟶ 1,661:
│6 4 2│306 │ 31 37 41 43│
│ │ │997141 997147 997151 997153│
└─────┴─────┴───────────────────────────┘</langsyntaxhighlight>
 
=={{header|Java}}==
{{trans|Go}}
<langsyntaxhighlight lang="java">import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
Line 1,537 ⟶ 1,732:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-
Line 1,576 ⟶ 1,771:
 
For a suitable implementation of `is_prime` as used here, see e.g. # [[Erd%C5%91s-primes#jq]].
<langsyntaxhighlight lang="jq"># Emit a stream of consecutive primes.
# The stream is unbounded if . is null or infinite,
# otherwise it continues up to but excluding `.`.
Line 1,613 ⟶ 1,808:
| .count = .count + 1
| .last = $x ) ;
</syntaxhighlight>
</lang>
'''The Tasks'''
<langsyntaxhighlight lang="jq">[pow(10;6) | primes] as $p1e6
| ([2], [1], [2,2], [2,4], [4,2], [6,4,2]) as $d
| ("\nFor deltas = \($d):", report_first_last_count(filter_differences($p1e6[]; $d ) ) )</langsyntaxhighlight>
{{out}}
<pre>
Line 1,639 ⟶ 1,834:
</pre>
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
function filterdifferences(deltas, N)
Line 1,662 ⟶ 1,857:
 
filterdifferences([[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]], 1000000)
</langsyntaxhighlight>{{out}}
<pre>
Diff Sequence Count First Last
Line 1,675 ⟶ 1,870:
=={{header|Lua}}==
This task uses <code>primegen</code> from: [[Extensible_prime_generator#Lua]]
<langsyntaxhighlight lang="lua">function findspds(primelist, diffs)
local results = {}
for i = 1, #primelist-#diffs do
Line 1,700 ⟶ 1,895:
print("LAST : ["..table.concat(spdlist[#spdlist]," ").."]")
print()
end</langsyntaxhighlight>
{{out}}
<pre>DIFFS: [2]
Line 1,734 ⟶ 1,929:
=={{header|Kotlin}}==
{{trans|Java}}
<langsyntaxhighlight lang="scala">private fun sieve(limit: Int): Array<Int> {
val primes = mutableListOf<Int>()
primes.add(2)
Line 1,804 ⟶ 1,999:
println()
}
}</langsyntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-
Line 1,839 ⟶ 2,034:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">ClearAll[Primediffs]
p = Prime[Range[PrimePi[10^6]]];
Primediffs[seq_] := {First[#], Last[#], Length[#]} &[p[[#1 ;; #2 + 1]] & @@@ SequencePosition[Differences[p], seq]]
Line 1,847 ⟶ 2,042:
Primediffs[{2, 4}]
Primediffs[{4, 2}]
Primediffs[{6, 4, 2}]</langsyntaxhighlight>
{{out}}
<pre>{{3,5},{999959,999961},8169}
Line 1,857 ⟶ 2,052:
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import math, strutils
 
const N = 1_000_000
Line 1,906 ⟶ 2,101:
primes.findGroups(2, 4)
primes.findGroups(4, 2)
primes.findGroups(6, 4, 2)</langsyntaxhighlight>
 
{{out}}
Line 1,941 ⟶ 2,136:
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use List::EachCons;
Line 1,962 ⟶ 2,157:
join(' ', @primes[$offsets[ 0]..($offsets[ 0]+@$diffs)]),
join(' ', @primes[$offsets[-1]..($offsets[-1]+@$diffs)]);
}</langsyntaxhighlight>
{{out}}
<pre> (2) has 8169 sets: 3 5 … 999959 999961
Line 1,972 ⟶ 2,167:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">primes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1_000_000</span><span style="color: #0000FF;">)</span>
Line 1,997 ⟶ 2,192:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Differences Count First Last\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}},</span><span style="color: #000000;">test</span><span style="color: #0000FF;">)</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 2,007 ⟶ 2,202:
{4,2} : 1444 {7,11,13}...{997807,997811,997813}
{6,4,2} : 306 {31,37,41,43}...{997141,997147,997151,997153}
</pre>
=={{header|Picat}}==
{{trans|Prolog}}
<syntaxhighlight lang="picat">main =>
Num is 1_000_000,
statistics(runtime,[Start|_]),
PrimeList = primes(Num),
NumPrimes = PrimeList.len,
statistics(runtime,[Stop|_]),
RunTime = Stop - Start,
printf("There are %w primes until %w [time(ms) %w]%n",NumPrimes, Num, RunTime),
DiffList = [[1], [2], [2,2], [2,4], [4,2], [2,4,6],
[2,6,4], [4,2,6], [4,6,2], [6,2,4], [6,4,2],[6,4,2,4]],
run(DiffList, PrimeList).
 
primesByDiffs([],_,[]).
primesByDiffs([Prime|Primes], Diff, [Slide|Slides]):-
Slide = new_list(Diff.len+1),
append(Slide, _, [Prime|Primes]),
select(Diff, Slide),!,
primesByDiffs(Primes, Diff, Slides).
primesByDiffs([_|Primes], Diff, Slides):-
primesByDiffs(Primes, Diff, Slides).
 
select([],_).
select([Diff|Diffs],[S1, S2|Stail]):-
S2 = S1 + Diff,
select(Diffs, [S2|Stail]).
run([],_).
run([Diff|Dtail], PrimeList):-
statistics(runtime,[Start|_]),
primesByDiffs(PrimeList, Diff, SlideList),
Num = SlideList.len,
statistics(runtime,[Stop|_]),
Runtime = Stop - Start,
printf("%-10w number: %5w (%2wms) first: %-22w last: %-22w\n", Diff, Num, Runtime, SlideList.first, SlideList.last),
!,
run(Dtail, PrimeList).</syntaxhighlight>
 
{{out}}
<pre>There are 78498 primes until 1000000 [time(ms) 130]
[1] number: 1 ( 9ms) first: [2,3] last: [2,3]
[2] number: 8169 (10ms) first: [3,5] last: [999959,999961]
[2,2] number: 1 (10ms) first: [3,5,7] last: [3,5,7]
[2,4] number: 1393 (11ms) first: [5,7,11] last: [999431,999433,999437]
[4,2] number: 1444 (10ms) first: [7,11,13] last: [997807,997811,997813]
[2,4,6] number: 279 (12ms) first: [17,19,23,29] last: [997097,997099,997103,997109]
[2,6,4] number: 297 (12ms) first: [29,31,37,41] last: [979541,979543,979549,979553]
[4,2,6] number: 162 (12ms) first: [67,71,73,79] last: [980587,980591,980593,980599]
[4,6,2] number: 300 (12ms) first: [19,23,29,31] last: [997099,997103,997109,997111]
[6,2,4] number: 159 (12ms) first: [1601,1607,1609,1613] last: [997091,997097,997099,997103]
[6,4,2] number: 306 (13ms) first: [31,37,41,43] last: [997141,997147,997151,997153]
[6,4,2,4] number: 62 (13ms) first: [31,37,41,43,47] last: [959461,959467,959471,959473,959477]
 
</pre>
 
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">prime(2). % use swi prolog
prime(N):-
N /\ 1 > 0, % odd
M is floor(sqrt(N)) - 1, % reverse 2*I+1
Max is M // 2, % integer division
forall(between(1, Max, I), N mod (2*I+1) > 0).
 
primesByDiffs([],_,[]).
primesByDiffs([Prime|Primes], Diff, [Slide|Slides]):-
length(Diff, Len0),
Len is Len0 + 1,
length(Slide, Len),
append(Slide, _, [Prime|Primes]),
select(Diff, Slide),!,
primesByDiffs(Primes, Diff, Slides).
primesByDiffs([_|Primes], Diff, Slides):-
primesByDiffs(Primes, Diff, Slides).
 
select([],_).
select([Diff|Diffs],[S1, S2|Stail]):-
S2 is S1 + Diff,
select(Diffs, [S2|Stail]).
 
run([],_).
run([Diff|Dtail], PrimeList):-
statistics(runtime,[Start|_]),
primesByDiffs(PrimeList, Diff, SlideList),
length(SlideList, Num),
statistics(runtime,[Stop|_]),
Runtime is Stop - Start,
SlideList = [First|SlideTail],
format('~|~w~t~7+ number: ~|~t~d~4+ [time(ms) ~|~t~d~3+] first: ~|~w~t~22+',[Diff, Num, Runtime, First]),
writeLast(SlideTail),!, nl,
run(Dtail, PrimeList).
 
writeLast([]).
writeLast(SlideTail):-
last(SlideTail, Last),
format('last: ~w',[Last]).
 
do:- Num is 1000000,
statistics(runtime,[Start|_]),
numlist(2, Num, List),
include(prime, List, PrimeList),
length(PrimeList, NumPrimes),
statistics(runtime,[Stop|_]),
RunTime is Stop - Start,
format('there are ~w primes until ~w [time(ms) ~w]~n',[NumPrimes, Num, RunTime]),
DiffList = [[1], [2], [2,2], [2,4], [4,2], [2,4,6],
[2,6,4], [4,2,6], [4,6,2], [6,2,4], [6,4,2]],
run(DiffList, PrimeList).</syntaxhighlight>
{{out}}
<pre>?- do.
there are 78498 primes until 1000000 [time(ms) 14614]
[1] number: 1 [time(ms) 123] first: [2,3]
[2] number: 8169 [time(ms) 124] first: [3,5] last: [999959,999961]
[2,2] number: 1 [time(ms) 131] first: [3,5,7]
[2,4] number: 1393 [time(ms) 133] first: [5,7,11] last: [999431,999433,999437]
[4,2] number: 1444 [time(ms) 133] first: [7,11,13] last: [997807,997811,997813]
[2,4,6] number: 279 [time(ms) 141] first: [17,19,23,29] last: [997097,997099,997103,997109]
[2,6,4] number: 297 [time(ms) 141] first: [29,31,37,41] last: [979541,979543,979549,979553]
[4,2,6] number: 162 [time(ms) 142] first: [67,71,73,79] last: [980587,980591,980593,980599]
[4,6,2] number: 300 [time(ms) 141] first: [19,23,29,31] last: [997099,997103,997109,997111]
[6,2,4] number: 159 [time(ms) 142] first: [1601,1607,1609,1613] last: [997091,997097,997099,997103]
[6,4,2] number: 306 [time(ms) 142] first: [31,37,41,43] last: [997141,997147,997151,997153]
true.
</pre>
 
Line 2,012 ⟶ 2,331:
Uses the [https://www.sympy.org/en/index.html Sympy] library.
 
<langsyntaxhighlight lang="python"># https://docs.sympy.org/latest/index.html
from sympy import Sieve
 
Line 2,046 ⟶ 2,365:
print(" First group:", str(first)[1:-1])
print(" Last group:", str(last)[1:-1])
print(" Count:", count)</langsyntaxhighlight>
 
{{out}}
Line 2,080 ⟶ 2,399:
Essentially the code from the [[Sexy_primes#Raku|Sexy primes]] task with minor tweaks.
 
<syntaxhighlight lang="raku" perl6line>use Math::Primesieve;
my $sieve = Math::Primesieve.new;
 
Line 2,110 ⟶ 2,429:
}
say ' Count: ', +$primes{$i}, "\n";
}</langsyntaxhighlight>
{{out}}
<pre>## Sets of 2 successive primes <= 1,000,000 with successive differences of 2
Line 2,144 ⟶ 2,463:
===Precomputed Differences===
{{works with|Rakudo|2019.03}}
<syntaxhighlight lang="raku" perl6line>use Math::Primesieve;
 
constant $max = 1_000_000;
Line 2,162 ⟶ 2,481:
say sprintf '%10s has %5d sets: %15s … %s',
@succ.gist, @group_start_offsets.elems, $first, $last;
}</langsyntaxhighlight>
{{Out}}
<pre>Given all ordered primes <= 1000000, sets with successive differences of:
Line 2,173 ⟶ 2,492:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX program finds and displays primes with successive differences (up to a limit).*/
parse arg H . 1 . difs /*allow the highest number be specified*/
if H=='' | H=="," then H= 1000000 /*Not specified? Then use the default.*/
Line 2,217 ⟶ 2,536:
do m=jj to N by j+j; @.m=; end /*odd multiples.*/
end /* [↑] strike odd multiples ¬ prime. */
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 2,252 ⟶ 2,571:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl + nl
Line 2,320 ⟶ 2,639:
txt = txt + "]"
see txt
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,359 ⟶ 2,678:
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
« DUP SIZE 1 + { } DUP 0 → diff n first last count
« 1
2 n '''START''' DUP NEXTPRIME '''NEXT'''
'''WHILE''' DUP 1000000 < '''REPEAT'''
n ROLL DROP DUP NEXTPRIME
n DUPN n →LIST
'''IF''' DUP ΔLIST diff == '''THEN'''
1 →LIST
'''IF''' first SIZE THEN 'last' '''ELSE''' 'first' '''END''' STO
1 'count' STO+
'''ELSE''' DROP '''END'''
'''END'''
n DROPN first last + count
» » '<span style="color:blue">SUCCP</span>' STO
 
{ 2 4 } <span style="color:blue">SUCCP</span>
{{out}}
<pre>
2: { { 5 7 11 } { 999431 999433 999437 } }
1: 1393
</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'prime'
PRIMES = Prime.each(1_000_000).to_a
difs = [[2], [1], [2,2], [2,4], [4,2], [6,4,2]]
Line 2,371 ⟶ 2,714:
puts "#{ar} has #{res.size} sets. #{res.first}...#{res.last}"
end
</syntaxhighlight>
</lang>
{{output}}
<pre>[2] has 8169 sets. [3, 5]...[999959, 999961]
Line 2,380 ⟶ 2,723:
[6, 4, 2] has 306 sets. [31, 37, 41, 43]...[997141, 997147, 997151, 997153]
</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">
<lang Rust>
fn is_prime(num: u32) -> bool {
match num {
Line 2,429 ⟶ 2,773:
}
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,461 ⟶ 2,805:
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">object SuccessivePrimeDiffs {
def main(args: Array[String]): Unit = {
val d2 = primesByDiffs(2)(1000000)
Line 2,490 ⟶ 2,834:
def primesSliding(len: Int): Iterator[Vector[Int]] = primes.sliding(len).map(_.toVector)
def primes: LazyList[Int] = 2 #:: LazyList.from(3, 2).filter(n => !Iterator.range(3, math.sqrt(n).toInt + 1, 2).exists(n%_ == 0))
}</langsyntaxhighlight>
 
{{out}}
Line 2,502 ⟶ 2,846:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">var limit = 1e6
var primes = limit.primes
 
Line 2,518 ⟶ 2,862:
say ("...for differences #{diffs}, there are #{groups.len} groups, where ",
"the first group = #{groups.first} and the last group = #{groups.last}")
}</langsyntaxhighlight>
{{out}}
<pre>
Line 2,532 ⟶ 2,876:
=={{header|Visual Basic .NET}}==
{{trans|Java}}
<langsyntaxhighlight lang="vbnet">Imports System.Text
 
Module Module1
Line 2,621 ⟶ 2,965:
End Sub
 
End Module</langsyntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-
Line 2,658 ⟶ 3,002:
{{trans|Go}}
{{libheader|Wren-math}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
 
var successivePrimes = Fn.new { |primes, diffs|
Line 2,696 ⟶ 3,040:
System.print(" Number found = %(sp.count)\n")
}
}</langsyntaxhighlight>
 
{{out}}
Line 2,731 ⟶ 3,075:
Last group = [997141, 997147, 997151, 997153]
Number found = 306
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func IsPrime(N); \Return 'true' if N is prime
int N, D;
[if N < 2 then return false;
if (N&1) = 0 then return N = 2;
if rem(N/3) = 0 then return N = 3;
D:= 5;
while D*D <= N do
[if rem(N/D) = 0 then return false;
D:= D+2;
if rem(N/D) = 0 then return false;
D:= D+4;
];
return true;
];
 
char Prime(1_000_000), S;
int Diff, Diffs, Count, N, I, First, Last;
int Str, Len;
[for N:= 0 to 1_000_000-1 do
Prime(N):= if IsPrime(N) then ^1 else ^0;
Diffs:= [[2, 0, 0], [1, 0, 0], [2, 2+2, 0], [2, 4+2, 0], [4, 2+4, 0], [6, 4+6, 2+4+6]];
Str:= [ "101 ", "11 ", "10101 ", "1010001 ", "1000101 ", "1000001000101 "];
Len:= [ 3, 2, 5, 7, 7, 13];
for Diff:= 0 to 6-1 do
[Count:= 0;
for N:= 0 to 1_000_000-1 -13 do
[S:= Str(Diff);
for I:= 0 to Len(Diff)-1 do
if S(I) # Prime(N+I) then I:= 100;
if I < 100 then \have match
[Count:= Count+1;
if Count = 1 then First:= N;
Last:= N;
];
];
Text(0, "First: "); IntOut(0, First);
for I:= 0 to 2 do
if Diffs(Diff,I) # 0 then
[ChOut(0, ^ ); IntOut(0, First+Diffs(Diff,I))];
Text(0, " Last: "); IntOut(0, Last);
for I:= 0 to 2 do
if Diffs(Diff,I) # 0 then
[ChOut(0, ^ ); IntOut(0, Last+Diffs(Diff,I))];
Text(0, " Groups: "); IntOut(0, Count); CrLf(0);
];
]</syntaxhighlight>
{{out}}
<pre>
First: 3 5 Last: 999959 999961 Groups: 8169
First: 2 3 Last: 2 3 Groups: 1
First: 3 5 7 Last: 3 5 7 Groups: 1
First: 5 7 11 Last: 999431 999433 999437 Groups: 1393
First: 7 11 13 Last: 997807 997811 997813 Groups: 1444
First: 31 37 41 43 Last: 997141 997147 997151 997153 Groups: 306
</pre>
 
Line 2,741 ⟶ 3,142:
 
Treat this as a string search problem.
<langsyntaxhighlight lang="zkl">const PRIME_LIMIT=1_000_000;
var [const] BI=Import("zklBigNum"); // libGMP
var [const] primeBitMap=Data(PRIME_LIMIT).fill(0x30); // one big string
Line 2,754 ⟶ 3,155:
while(n=primeBitMap.find(sp,n+1)){ r.append(n) } // (31, 61, 271,...)
r.apply('wrap(n){ T(n).extend(ds.apply('+(n))) }) //( (31,37,41,43), (61,67,71,73), (271,277,281,283) ...)
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">foreach w in (T( T(2), T(1), T(2,2), T(2,4), T(4,2), T(6,4,2) )){
r:=primeWindows(PRIME_LIMIT,w);
println("Successive primes (<=%,d) with deltas of %s (%,d groups):"
Line 2,761 ⟶ 3,162:
println(" First group: %s; Last group: %s\n"
.fmt(r[0].concat(", "),r[-1].concat(", ")));
}</langsyntaxhighlight>
{{out}}
<pre>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/290224...353810"