Sum of primes in odd positions is prime: Difference between revisions
Sum of primes in odd positions is prime (view source)
Revision as of 10:34, 11 February 2024
, 3 months ago→{{header|Wren}}: Minor tidy
(add FreeBASIC) |
m (→{{header|Wren}}: Minor tidy) |
||
| (27 intermediate revisions by 16 users not shown) | |||
Line 2:
;Task:
<br>Let '''p(i)''' be a sequence of prime numbers. such that 2=p(1), 3=p(2), 5=p(3), ...
<br>Consider the '''p(1),p(3),p(5), ... ,p(i)''', for each '''p(i) < 1,000''' and '''i''' is odd.
<br>Let '''sum''' be
<br>If '''sum''' is prime then print '''i''', '''p(i)''' and '''sum'''.
<br><br>
=={{header|11l}}==
{{trans|Nim}}
<syntaxhighlight lang="11l">F is_prime(n)
I n == 2
R 1B
I n < 2 | n % 2 == 0
R 0B
L(i) (3 .. Int(sqrt(n))).step(2)
I n % i == 0
R 0B
R 1B
print(‘ i p(i) sum’)
V idx = 0
V s = 0
V p = 1
L p < 1000
p++
I is_prime(p)
idx++
I idx % 2 != 0
s += p
I is_prime(s)
print(f:‘{idx:3} {p:3} {s:5}’)</syntaxhighlight>
{{out}}
<pre>
i p(i) sum
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:PRINTF.ACT" ;from the Action! Tool Kit
BYTE FUNC IsPrime(CARD x)
CARD i,max
i=2 max=x/2
WHILE i<=max
DO
IF x MOD i=0 THEN
RETURN (0)
FI
i==+1
OD
RETURN (1)
PROC Main()
CARD x,count,sum
CHAR ARRAY s(6)
Put(125) PutE() ;clear the screen
PrintF("%3S%5S%6S%E","i","p(i)","sum")
count=0 sum=0
FOR x=2 TO 999
DO
IF IsPrime(x) THEN
count==+1
IF (count&1)=1 THEN
sum==+x
IF IsPrime(sum) THEN
StrC(count,s) PrintF("%3S",s)
StrC(x,s) PrintF("%5S",s)
StrC(sum,s) PrintF("%6S%E",s)
FI
FI
FI
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_primes_in_odd_positions_is_prime.png Screenshot from Atari 8-bit computer]
<pre>
i p(i) sum
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<
PR read "primes.incl.a68" PR
INT max prime = 999;
Line 32 ⟶ 130:
FI
OD
END</
{{out}}
<pre>
Line 48 ⟶ 146:
143 823 26879
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">print " i | p(i) sum"
print repeat "-" 17
idx: 0
sm: 0
p: 1
while [p < 1000][
inc 'p
if prime? p [
inc 'idx
if odd? idx [
sm: sm + p
if prime? sm ->
print (pad to :string idx 4) ++ " | " ++ (pad to :string p 3) ++ (pad to :string sm 6)
]
]
]</syntaxhighlight>
{{out}}
<pre> i | p(i) sum
-----------------
1 | 2 2
3 | 5 7
11 | 31 89
27 | 103 659
35 | 149 1181
67 | 331 5021
91 | 467 9923
95 | 499 10909
99 | 523 11941
119 | 653 17959
143 | 823 26879</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f SUM_OF_PRIMES_IN_ODD_POSITIONS_IS_PRIME.AWK
# converted from Ring
Line 82 ⟶ 216:
return(1)
}
</syntaxhighlight>
{{out}}
<pre>
Line 101 ⟶ 235:
</pre>
=={{header|C}}==
<syntaxhighlight lang="c">#include<stdio.h>
#include<stdlib.h>
int isprime( int p ) {
int i;
if(p==2) return 1;
if(!(p%2)) return 0;
for(i=3; i*i<=p; i+=2) {
if(!(p%i)) return 0;
}
return 1;
}
int main( void ) {
int s=0, p, i=1;
for(p=2;p<=999;p++) {
if(isprime(p)) {
if(i%2) {
s+=p;
if(isprime(s)) printf( "%d %d %d\n", i, p, s );
}
i+=1;
}
}
return 0;
}</syntaxhighlight>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Uses the [[Extensible_prime_generator#Delphi|Delphi Prime-Generator Object]]
<syntaxhighlight lang="Delphi">
procedure SumOddPrimes(Memo: TMemo);
var Sieve: TPrimeSieve;
var I,Inx, Sum: integer;
begin
Sieve:=TPrimeSieve.Create;
try
Sieve.Intialize(100000);
Memo.Lines.Add(' I P(I) Sum');
Memo.Lines.Add('---------------');
I:=0;
Sum:=0;
while Sieve.Primes[I]<1000 do
begin
Sum:=Sum+Sieve.Primes[I];
if Sieve.Flags[Sum] then
begin
Memo.Lines.Add(Format('%3d %4d %6d',[I,Sieve.Primes[I],Sum]));
end;
Inc(I,2);
end;
finally Sieve.Free; end;
end;
</syntaxhighlight>
{{out}}
<pre>
I P(I) Sum
---------------
0 2 2
2 5 7
10 31 89
26 103 659
34 149 1181
66 331 5021
90 467 9923
94 499 10909
98 523 11941
118 653 17959
142 823 26879
Elapsed Time: 16.077 ms.
</pre>
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<syntaxhighlight lang="fsharp">
// Sum of primes in odd positions is prime. Nigel Galloway: November 9th., 2021
primes32()|>Seq.chunkBySize 2|>Seq.mapi(fun n g->(2*n+1,g.[0]))|>Seq.scan(fun(n,i,g)(e,l)->(e,l,g+l))(0,0,0)|>Seq.takeWhile(fun(_,n,_)->n<1000)|>Seq.filter(fun(_,_,n)->isPrime n)|>Seq.iter(fun(n,g,l)->printfn $"i=%3d{n} p[i]=%3d{g} sum=%5d{l}")
</syntaxhighlight>
{{out}}
<pre>
i= 1 p[i]= 2 sum= 2
i= 3 p[i]= 5 sum= 7
i= 11 p[i]= 31 sum= 89
i= 27 p[i]=103 sum= 659
i= 35 p[i]=149 sum= 1181
i= 67 p[i]=331 sum= 5021
i= 91 p[i]=467 sum= 9923
i= 95 p[i]=499 sum=10909
i= 99 p[i]=523 sum=11941
i=119 p[i]=653 sum=17959
i=143 p[i]=823 sum=26879
</pre>
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<
prettyprint sequences.extras ;
1000 primes-upto <evens> dup cum-sum zip [ prime? ] filter-values .</
{{out}}
<pre>
Line 123 ⟶ 358:
}
</pre>
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">s:=0;
for ii=0 to 83 do oi:=1+2*ii;s:=s+Prime(oi);if Isprime(s)=1 then !!(oi, Prime(oi), s) fi od;</syntaxhighlight>
=={{header|FreeBASIC}}==
<
dim as uinteger i = 1, p, sum = 0
for p = 2 to 999
Line 135 ⟶ 374:
i = i + 1
end if
next p</
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<
import (
Line 158 ⟶ 397:
}
}
}</
{{out}}
Line 178 ⟶ 417:
=={{header|GW-BASIC}}==
<
20 A = 1
30 PRINT 1, 2, 2
Line 204 ⟶ 443:
250 IF Q = 1 THEN PRINT A, T, S
260 P = T
270 RETURN</
=={{header|J}}==
<syntaxhighlight lang=J> (i,.p,.sum) #~ 1 p: sum=. +/\p=. p:<:i=. (#~ 2|])i. 1+p:inv 1000
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879</syntaxhighlight>
=={{header|jq}}==
Line 211 ⟶ 465:
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
<
def task:
Line 223 ⟶ 477:
| "\(.i|lpad(3)) \($oddPositionPrimes[$i]|lpad(3)) \(.sum|lpad(5))" ) ;
" i p[$i] sum", task</
{{out}}
<pre>
Line 242 ⟶ 496:
=={{header|Julia}}==
{{trans|Factor}}
<
p = primes(1000)
arr = filter(n -> isprime(n[2]), accumulate((x, y) -> (y, x[2] + y), p[1:2:length(p)], init = (0, 0)))
println(join(arr, "\n"))
</
<pre>
(2, 2)
Line 262 ⟶ 516:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
p = {p, Accumulate[p]} // Transpose;
Select[p, Last /* PrimeQ]</
{{out}}
<pre>{{2,2},{5,7},{31,89},{103,659},{149,1181},{331,5021},{467,9923},{499,10909},{523,11941},{653,17959},{823,26879}}</pre>
=={{header|Nim}}==
<
template isOdd(n: Natural): bool = (n and 1) != 0
Line 298 ⟶ 552:
inc sum, p
if sum.isPrime:
echo &"{idx:3} {p:3} {sum:5}"</
{{out}}
Line 313 ⟶ 567:
119 653 17959
143 823 26879</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let is_prime n =
let rec test x =
let q = n / x in x > q || x * q <> n && n mod (x + 2) <> 0 && test (x + 6)
in if n < 5 then n lor 1 = 3 else n land 1 <> 0 && n mod 3 <> 0 && test 5
let () = Seq.ints 3
|> Seq.filter is_prime
|> Seq.take_while ((>) 1000)
|> Seq.zip (Seq.ints 2)
|> Seq.filter (fun (i, _) -> i land 1 = 1)
|> Seq.scan (fun (_, pi, sum) (i, p) -> i, p, sum + p) (1, 2, 2)
|> Seq.filter (fun (_, _, sum) -> is_prime sum)
|> Seq.iter (fun (i, pi, sum) -> Printf.printf "p(%u) = %u, %u\n" i pi sum)</syntaxhighlight>
{{out}}
<pre>
p(1) = 2, 2
p(3) = 5, 7
p(11) = 31, 89
p(27) = 103, 659
p(35) = 149, 1181
p(67) = 331, 5021
p(91) = 467, 9923
p(95) = 499, 10909
p(99) = 523, 11941
p(119) = 653, 17959
p(143) = 823, 26879
</pre>
=={{header|PARI-GP}}==
<syntaxhighlight lang="parigp">sm=0;for(ii=0, 83, oi=1+2*ii;sm=sm+prime(oi);if(isprime(sm),print(oi," ", prime(oi)," ",sm)))</syntaxhighlight>
{{out}}
<pre>
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use ntheory 'is_prime';
Line 329 ⟶ 629:
printf "%6d%6d%6d\n", $c, $odd[$_], $sums[$_] if is_prime $sums[$_];
$c += 2;
}</
{{out}}
<pre> 1 2 2
Line 344 ⟶ 644:
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">sequence</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;">1000</span><span style="color: #0000FF;">)</span>
Line 356 ⟶ 656:
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre>
Line 372 ⟶ 672:
119 653 17,959
143 823 26,879
</pre>
=={{header|Quackery}}==
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
<syntaxhighlight lang="Quackery"> [ dip number$
over size -
space swap of
swap join echo$ ] is justify ( n n --> )
[] 1000 times
[ i^ isprime if [ i^ join ] ]
[] swap witheach
[ i^ 1 & 0 = iff join else drop ]
0 swap witheach
[ tuck + dup isprime if
[ i^ 2 * 1+ 3 justify
over 5 justify
dup 7 justify
cr ]
nip ]
drop</syntaxhighlight>
{{out}}
<pre> 1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
my @sums = [\+] @odd;
say .fmt('%5d') for grep { .[2].is-prime }, ( (1,3…*) Z @odd Z @sums );</
{{out}}
<pre> 1 2 2
Line 393 ⟶ 730:
=={{header|REXX}}==
<
parse arg hi . /*obtain optional argument from the CL.*/
if hi=='' | hi=="," then hi= 1000 /*Not specified? Then use the default.*/
Line 425 ⟶ 762:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return</
{{out|output|text= when using the default inputs:}}
<pre>
Line 447 ⟶ 784:
=={{header|Ring}}==
<
load "stdlib.ring"
see "working..." + nl
Line 469 ⟶ 806:
see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
Line 486 ⟶ 823:
143 823 26879
done...
</pre>
=={{header|RPL}}==
{{works with|HP|49}}
≪ → max
≪ { } 0 2
1 max '''FOR''' j
SWAP OVER + SWAP
'''IF''' OVER ISPRIME? '''THEN'''
j OVER 4 PICK →V3
4 ROLL SWAP + UNROT
'''END'''
NEXTPRIME NEXTPRIME
'''IF''' DUP max ≥ '''THEN''' max 'j' STO '''END'''
2 '''STEP'''
DROP2
≫ ≫ '<span style="color:blue">TASK</span>' STO
1000 <span style="color:blue">TASK</span>
{{out}}
<pre>
1:. {[1. 2. 2.] [3. 5. 7.] [11. 31. 89.] [27. 103. 659.] [35. 149. 1181.] [67. 331. 5021.] [91. 467. 9923.] [95. 499. 10909.] [99. 523. 11941.] [119. 653. 17959.] [143. 823. 26879.]}
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
sum = 0
Prime.each(1000).with_index(1).each_slice(2) do |(odd_i, i),(_)|
puts "%6d%6d%6d" % [i, odd_i, sum] if (sum += odd_i).prime?
end
</syntaxhighlight>
{{out}}
<pre> 1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var sum = 0
1e3.primes.each_kv {|k,v|
if (k+1 -> is_odd) {
sum += v
say "#{k+1} #{v} #{sum}" if sum.is_prime
}
}</syntaxhighlight>
{{out}}
<pre>
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
=={{header|Tiny BASIC}}==
<syntaxhighlight lang="tinybasic"> LET I = 0
LET S = 0
LET P = 1
10 LET P = P + 1
LET X = P
GOSUB 100
IF Z = 1 THEN LET I = I + 1
IF Z = 0 THEN GOTO 20
IF (I/2)*2<>I THEN GOSUB 200
20 IF P<917 THEN GOTO 10 REM need to cheat a little to avoid overflow
END
100 REM is X a prime? Z=1 for yes, 0 for no
LET Z = 1
IF X = 3 THEN RETURN
IF X = 2 THEN RETURN
LET A = 1
110 LET A = A + 1
IF (X/A)*A = X THEN GOTO 120
IF A*A<=X THEN GOTO 110
RETURN
120 LET Z = 0
RETURN
200 LET S = S + P
LET X = S
GOSUB 100
IF Z = 1 THEN PRINT I," ", P," ", S
RETURN</syntaxhighlight>
{{out}}<pre>1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
</pre>
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-
{{libheader|Wren-fmt}}
<
import "./
import "./fmt" for Fmt
var primes = Int.primeSieve(999)
Line 503 ⟶ 951:
sum = sum + se.value
if (Int.isPrime(sum)) Fmt.print("$3d $3d $,6d", se.index + 1, se.value, sum)
}</
{{out}}
Line 523 ⟶ 971:
=={{header|XPL0}}==
<
int N, I;
[if N <= 1 then return false;
Line 544 ⟶ 992:
];
];
]</
{{out}}
Line 561 ⟶ 1,009:
823 26879
</pre>
=={{header|Yabasic}}==
{{trans|XPL0}}
<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Sum_of_primes_in_odd_positions_is_prime
// by Galileo, 04/2022
sub isPrime(n)
local i
if n < 4 return n >= 2
for i = 2 to sqrt(n)
if not mod(n, i) return false
next
return true
end sub
print "i\tp(n)\tsum\n----\t-----\t------"
for n = 1 to 1000
if isPrime(n) then
i = i + 1
if mod(i, 2) then
sum = sum + n
if isPrime(sum) print i, "\t", n, "\t", sum
end if
end if
next</syntaxhighlight>
{{out}}
<pre>i p(n) sum
---- ----- ------
1 2 2
3 5 7
11 31 89
27 103 659
35 149 1181
67 331 5021
91 467 9923
95 499 10909
99 523 11941
119 653 17959
143 823 26879
---Program done, press RETURN---</pre>
| |||