Rosetta Code

Nice primes: Difference between revisions

Page Discussion

Nice primes (view source)

Revision as of 17:48, 12 May 2024

25,182 bytes added ,  21 days ago
Added Easylang
(Added Algol 68)
(Added Easylang)
 
(47 intermediate revisions by 25 users not shown)
Line 1:
{{Draft task|Prime Numbers}}
 
 
;Task:
::#   Take an positive integer   '''n'''
::#   '''sumn'''   is the sum of the decimal digits of   '''n'''
Line 22 ⟶ 25:
::*   The OEIS article:   [http://oeis.org/A78403 A78403 Primes such that digital root is prime].
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">F is_prime(a)
I a == 2
R 1B
I a < 2 | a % 2 == 0
R 0B
L(i) (3 .. Int(sqrt(a))).step(2)
I a % i == 0
R 0B
R 1B
 
F digital_root(n)
R 1 + (n - 1) % 9
 
L(n) 501..999
I is_prime(digital_root(n)) & is_prime(n)
print(n, end' ‘ ’)</syntaxhighlight>
 
{{out}}
<pre>
509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"
 
BYTE Func IsNicePrime(INT i BYTE ARRAY primes)
BYTE sum,d
 
IF primes(i)=0 THEN
RETURN (0)
FI
 
DO
sum=0
WHILE i#0
DO
d=i MOD 10
sum==+d
i==/10
OD
IF sum<10 THEN
EXIT
FI
i=sum
OD
RETURN (primes(sum))
 
PROC Main()
DEFINE MAX="999"
BYTE ARRAY primes(MAX+1)
INT i,count=[0]
 
Put(125) PutE() ;clear the screen
Sieve(primes,MAX+1)
FOR i=501 TO 999
DO
IF IsNicePrime(i,primes) THEN
PrintI(i) Put(32)
count==+1
FI
OD
PrintF("%E%EThere are %I nice primes",count)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Nice_primes.png Screenshot from Atari 8-bit computer]
<pre>
509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997
 
There are 33 nice primes
</pre>
 
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<lang algol68>BEGIN # find nice primes - primes whose digital root is also prime #
<syntaxhighlight lang="algol68">BEGIN # find nice primes - primes whose digital root is also prime #
INT min prime = 501;
INT max prime = 999;
# sieve the primes to max prime #
PR read "primes.incl.a68" PR
[ 1 : max prime ]BOOL prime;
prime[ 1 ] := FALSE;BOOL prime[ 2= ]PRIMESIEVE :=max TRUEprime;
FOR i FROM 3 BY 2 TO UPB prime DO prime[ i ] := TRUE OD;
FOR i FROM 4 BY 2 TO UPB prime DO prime[ i ] := FALSE OD;
FOR i FROM 3 BY 2 TO ENTIER sqrt( max prime ) DO
IF prime[ i ] THEN FOR s FROM i * i BY i + i TO UPB prime DO prime[ s ] := FALSE OD FI
OD;
# find the nice primes #
INT nice count := 0;
Line 59 ⟶ 131:
FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 68 ⟶ 140:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin % find some nice primes - primes whose digital root is prime %
% returns the digital root of n in base 10 %
integer procedure digitalRoot( integer value n ) ;
Line 111 ⟶ 183:
end
end.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 152 ⟶ 224:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">(⊢(/⍨)(∧/(2=(0+.=⍳|⊢))¨∘(⊢,(+/10⊥⍣¯1⊢)⍣(9≥⊣)))¨) 500+⍳500</langsyntaxhighlight>
{{out}}
<pre>509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947
Line 159 ⟶ 231:
=={{header|AppleScript}}==
sumn formula borrowed from the [https://www.rosettacode.org/wiki/Nice_primes#Factor Factor] solution.
<langsyntaxhighlight lang="applescript">on sieveOfEratosthenes(limit)
script o
property numberList : {missing value}
Line 200 ⟶ 272:
end nicePrimes
 
return nicePrimes(501, 999)</langsyntaxhighlight>
{{output}}
<langsyntaxhighlight lang="applescript">{509, 547, 563, 569, 587, 599, 601, 617, 619, 641, 653, 659, 673, 677, 691, 709, 727, 743, 761, 797, 821, 839, 853, 857, 887, 907, 911, 929, 941, 947, 977, 983, 997}</langsyntaxhighlight>
 
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">sumd: function [n][
s: sum digits n
(1 = size digits s)? -> return s
-> return sumd s
]
 
nice?: function [x] -> and? prime? x
prime? sumd x
 
loop split.every:10 select 500..1000 => nice? 'a ->
print map a => [pad to :string & 4]</syntaxhighlight>
 
{{out}}
 
<pre> 509 547 563 569 587 599 601 617 619 641
653 659 673 677 691 709 727 743 761 797
821 839 853 857 887 907 911 929 941 947
977 983 997</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f NICE_PRIMES.AWK
BEGIN {
Line 244 ⟶ 336:
return(sum)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 284 ⟶ 376:
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="basic">10 DEFINT A-Z: B=500: E=1000
20 DIM P(E): P(0)=-1: P(1)=-1
30 FOR I=2 TO SQR(E)
Line 294 ⟶ 386:
90 IF J>0 THEN S=S+J MOD 10: J=J\10: GOTO 90
100 IF S>9 THEN J=S: GOTO 80 ELSE IF NOT P(S) THEN PRINT I,
110 NEXT</langsyntaxhighlight>
{{out}}
<pre> 509 547 563 569 587
Line 305 ⟶ 397:
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
manifest $(
begin = 500
Line 341 ⟶ 433:
writef("%N*N", i)
freevec(prime)
$)</langsyntaxhighlight>
 
{{out}}
Line 377 ⟶ 469:
983
997</pre>
 
 
=={{header|C}}==
{{trans|C++}}
<langsyntaxhighlight lang="c">#include <stdbool.h>
#include <stdio.h>
 
Line 430 ⟶ 523:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>Nice primes between 500 and 1000:
Line 440 ⟶ 533:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
 
bool is_prime(unsigned int n) {
Line 474 ⟶ 567:
}
std::cout << '\n' << count << " nice primes found.\n";
}</langsyntaxhighlight>
 
{{out}}
Line 488 ⟶ 581:
=={{header|D}}==
{{trans|C++}}
<langsyntaxhighlight lang="d">import std.stdio;
 
bool isPrime(uint n) {
Line 534 ⟶ 627:
writeln;
writeln(count, " nice primes found.");
}</langsyntaxhighlight>
{{out}}
<pre>Nice primes between 500 and 1000:
Line 542 ⟶ 635:
977 983 997
33 nice primes found.</pre>
 
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
function IsPrime(N: int64): boolean;
{Fast, optimised prime test}
var I,Stop: int64;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
begin
I:=5;
Stop:=Trunc(sqrt(N+0.0));
Result:=False;
while I<=Stop do
begin
if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
Inc(I,6);
end;
Result:=True;
end;
end;
 
 
 
function SumDigits(N: integer): integer;
{Sum the integers in a number}
var T: integer;
begin
Result:=0;
repeat
begin
T:=N mod 10;
N:=N div 10;
Result:=Result+T;
end
until N<1;
end;
 
 
 
function IsNiceNumber(N: integer): boolean;
{Return True if N is a nice number}
var Sum: integer;
begin
Result:=False;
{N must be primes}
if not IsPrime(N) then exit;
{Keep summing until one digit number}
Sum:=N;
repeat Sum:=SumDigits(Sum)
until Sum<10;
{Must be prime too}
Result:=IsPrime(Sum);
end;
 
 
procedure ShowNicePrimes(Memo: TMemo);
{Display Nice Primes between 501 and 999}
var I,Cnt: integer;
var S: string;
begin
Cnt:=0; S:='';
for I:=501 to 999 do
if IsNiceNumber(I) then
begin
S:=S+Format('%4d',[i]);
Inc(Cnt);
if (Cnt mod 5)=0 then S:=S+#$0D#$0A;
end;
Memo.Lines.Add(Format('Nice Primes: %3D',[Cnt]));
Memo.Lines.Add(S);
end;
 
</syntaxhighlight>
{{out}}
<pre>
Nice Primes: 33
509 547 563 569 587
599 601 617 619 641
653 659 673 677 691
709 727 743 761 797
821 839 853 857 887
907 911 929 941 947
977 983 997
 
</pre>
 
 
=={{header|EasyLang}}==
{{trans|11l}}
<syntaxhighlight>
fastfunc isprim num .
if num < 2
return 0
.
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
func digroot n .
return 1 + (n - 1) mod 9
.
for n = 501 to 999
if isprim digroot n = 1 and isprim n = 1
write n & " "
.
.
</syntaxhighlight>
{{out}}
<pre>
509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997
</pre>
 
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<langsyntaxhighlight lang="fsharp">
// Nice primes. Nigel Galloway: March 22nd., 2021
let fN g=1+((g-1)%9) in primes32()|>Seq.skipWhile((>)500)|>Seq.takeWhile((>)1000)|>Seq.filter(fN>>isPrime)|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 565 ⟶ 782:
({{math|<var>n</var> &#61; 0}} may not need to be special-cased depending on the behavior of your language's modulo operator.)
 
<langsyntaxhighlight lang="factor">USING: math math.primes prettyprint sequences ;
 
: digital-root ( m -- n ) 1 - 9 mod 1 + ;
 
500 1000 primes-between [ digital-root prime? ] filter .</langsyntaxhighlight>
{{out}}
<pre style="height:10em">
Line 611 ⟶ 828:
{{trans|Factor}}
{{works with|Gforth}}
<langsyntaxhighlight lang="forth">: prime? ( n -- ? ) here + c@ 0= ;
: notprime! ( n -- ) here + 1 swap c! ;
 
Line 648 ⟶ 865:
 
1000 500 print_nice_primes
bye</langsyntaxhighlight>
 
{{out}}
Line 659 ⟶ 876:
33 nice primes found.
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
Function isPrime(Byval ValorEval As Integer) As Boolean
If ValorEval <= 1 Then Return False
For i As Integer = 2 To Int(Sqr(ValorEval))
If ValorEval Mod i = 0 Then Return False
Next i
Return True
End Function
 
Dim As Integer column = 0, limit1 = 500, limit2 = 1000, sumn
 
Print !"Buenos n£meros entre"; limit1; " y"; limit2; !": \n"
 
For n As Integer = limit1 To limit2
Dim As String strn = Str(n)
Do
sumn = 0
For m As Integer = 1 To Len(strn)
sumn += Val(Mid(strn,m,1))
Next m
strn = Str(sumn)
Loop Until Len(strn) = 1
If isPrime(n) And isPrime(sumn) Then
column += 1
Print Using " ###"; n;
If column Mod 8 = 0 Then Print : End If
End If
Next n
 
Print !"\n\n"; column; " buenos n£meros encontrados."
Sleep
</syntaxhighlight>
{{out}}
<pre>
Buenos números entre 500 y 1000:
 
509 547 563 569 587 599 601 617
619 641 653 659 673 677 691 709
727 743 761 797 821 839 853 857
887 907 911 929 941 947 977 983
997
 
33 buenos números encontrados.
</pre>
 
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Nice_primes}}
 
'''Solution'''
 
[[File:Fōrmulæ - Nice primes 01.png]]
 
'''Test case'''
 
[[File:Fōrmulæ - Nice primes 02.png]]
 
[[File:Fōrmulæ - Nice primes 03.png]]
 
'''Showing nice primes in the range 500 .. 1,000'''
 
[[File:Fōrmulæ - Nice primes 04.png]]
 
[[File:Fōrmulæ - Nice primes 05.png]]
 
[[File:Fōrmulæ - Nice primes 06.png]]
 
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 714 ⟶ 1,001:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 721 ⟶ 1,008:
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">
import Data.Char ( digitToInt )
 
isPrime :: Int -> Bool
isPrime n
|n == 2 = True
|n == 1 = False
|otherwise = null $ filter (\i -> mod n i == 0 ) [2 .. root]
where
root :: Int
root = floor $ sqrt $ fromIntegral n
 
digitsum :: Int -> Int
digitsum n = sum $ map digitToInt $ show n
 
findSumn :: Int -> Int
findSumn n = until ( (== 1) . length . show ) digitsum n
 
isNicePrime :: Int -> Bool
isNicePrime n = isPrime n && isPrime ( findSumn n )
 
solution :: [Int]
solution = filter isNicePrime [501..999]</syntaxhighlight>
{{out}}
<pre>
[509,547,563,569,587,599,601,617,619,641,653,659,673,677,691,709,727,743,761,797,821,839,853,857,887,907,911,929,941,947,977,983,997]
</pre>
 
=={{header|J}}==
Line 736 ⟶ 1,051:
(#~ (2 3 5 7 e.~ digital_root&>)) p: 95 + i. 168 - 95
509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997
</pre>
 
=={{header|Java}}==
{{trans|Kotlin}}
<syntaxhighlight lang="java">public class NicePrimes {
private static boolean isPrime(long n) {
if (n < 2) {
return false;
}
if (n % 2 == 0L) {
return n == 2L;
}
if (n % 3 == 0L) {
return n == 3L;
}
 
var p = 5L;
while (p * p <= n) {
if (n % p == 0L) {
return false;
}
p += 2;
if (n % p == 0L) {
return false;
}
p += 4;
}
return true;
}
 
private static long digitalRoot(long n) {
if (n == 0) {
return 0;
}
return 1 + (n - 1) % 9;
}
 
public static void main(String[] args) {
final long from = 500;
final long to = 1000;
int count = 0;
 
System.out.printf("Nice primes between %d and %d%n", from, to);
long n = from;
while (n < to) {
if (isPrime(digitalRoot(n)) && isPrime(n)) {
count++;
System.out.print(n);
if (count % 10 == 0) {
System.out.println();
} else {
System.out.print(' ');
}
}
 
n++;
}
System.out.println();
System.out.printf("%d nice primes found.%n", count);
}
}</syntaxhighlight>
{{out}}
<pre>Nice primes between 500 and 1000
509 547 563 569 587 599 601 617 619 641
653 659 673 677 691 709 727 743 761 797
821 839 853 857 887 907 911 929 941 947
977 983 997
33 nice primes found.</pre>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
 
This entry uses `is_prime` as defined at
[[Erd%C5%91s-primes#jq]].
<syntaxhighlight lang="jq">def is_nice:
# input: a non-negative integer
def sumn:
. as $in
| tostring
| if length == 1 then $in
else explode | map([.] | implode | tonumber) | add | sumn
end;
 
is_prime and (sumn|is_prime);
 
# The task:
range(501; 1000) | select(is_nice)</syntaxhighlight>
{{out}}
<pre>
509
547
563
569
587
599
601
617
619
641
653
659
673
677
691
709
727
743
761
797
821
839
853
857
887
907
911
929
941
947
977
983
997
</pre>
 
=={{header|Julia}}==
See [[Strange_numbers#Julia]] for the filter_open_interval function.
<langsyntaxhighlight lang="julia">using Primes
 
isnice(n, base=10) = isprime(n) && (mod1(n - 1, base - 1) + 1) in [2, 3, 5, 7, 11, 13, 17, 19]
 
filter_open_interval(500, 1000, isnice)
</langsyntaxhighlight>{{out}}
<pre>
Finding numbers matching isnice for open interval (500, 1000):
Line 757 ⟶ 1,195:
=={{header|Kotlin}}==
{{trans|C}}
<langsyntaxhighlight lang="scala">fun isPrime(n: Long): Boolean {
if (n < 2) {
return false
Line 811 ⟶ 1,249:
println()
println("$count nice primes found.")
}</langsyntaxhighlight>
{{out}}
<pre>Nice primes between 500 and 1000:
Line 822 ⟶ 1,260:
=={{header|Lua}}==
{{trans|C}}
<langsyntaxhighlight lang="lua">function isPrime(n)
if n < 2 then
return false
Line 872 ⟶ 1,310:
n = n + 1
end
print(count .. " nice primes found.")</langsyntaxhighlight>
{{out}}
<pre>Nice primes between 500 and 1000
Line 879 ⟶ 1,317:
821 839 853 857 887 907 911 929 941 947
977 983 997 33 nice primes found.</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[summ]
summ[n_] := FixedPoint[IntegerDigits /* Total, n]
Select[Range[501, 999], PrimeQ[#] \[And] PrimeQ[summ[#]] &]</syntaxhighlight>
{{out}}
<pre>{509, 547, 563, 569, 587, 599, 601, 617, 619, 641, 653, 659, 673, 677, 691, 709, 727, 743, 761, 797, 821, 839, 853, 857, 887, 907, 911, 929, 941, 947, 977, 983, 997}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strutils, sugar
 
func isPrime(n: Positive): bool =
Line 911 ⟶ 1,356:
for i, n in list:
stdout.write n, if (i + 1) mod 10 == 0: '\n' else: ' '
echo()</langsyntaxhighlight>
 
{{out}}
Line 919 ⟶ 1,364:
821 839 853 857 887 907 911 929 941 947
977 983 997 </pre>
 
=={{header|OCaml}}==
After ruling out all multiples of three, <code>mod 9</code> (the digital root) can only return {1, 2, 4, 5, 7, 8}. Adding 6 before calculating <code>mod 9</code> makes all primes in the result even (and the composites odd), so <code>(n + 6) mod 9 land 1 = 0</code> is sufficient for checking the digital root.
<syntaxhighlight lang="ocaml">let is_nice_prime n =
let rec test x =
x * x > n || n mod x <> 0 && 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 && (n + 6) mod 9 land 1 = 0 && test 5
 
let () =
Seq.(ints 500 |> take 500 |> filter is_nice_prime |> iter (Printf.printf " %u"))
|> print_newline</syntaxhighlight>
{{out}}
<pre> 509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997</pre>
 
=={{header|ooRexx}}==
<syntaxhighlight lang="oorexx">/* REXX */
n=1000
prime = .Array~new(n)~fill(.true)~~remove(1)
p.=0
Do i = 2 to n
If prime[i] = .true Then Do
Do j = i * i to n by i
prime~remove(j)
End
p.i=1
End
End
z=0
ol=''
Do i=500 To 1000
If p.i then Do
dr=digroot(i)
If p.dr Then Do
ol=ol' 'i'('dr')'
z=z+1
If z//10=0 Then Do
Say strip(ol)
ol=''
End
End
End
End
Say strip(ol)
Say z 'nice primes in the range 500 to 1000'
Exit
 
digroot:
Parse Arg s
Do Until length(s)=1
dr=0
Do j=1 To length(s)
dr=dr+substr(s,j,1)
End
s=dr
End
Return s</syntaxhighlight>
{{out}}
<pre>509(5) 547(7) 563(5) 569(2) 587(2) 599(5) 601(7) 617(5) 619(7) 641(2)
653(5) 659(2) 673(7) 677(2) 691(7) 709(7) 727(7) 743(5) 761(5) 797(5)
821(2) 839(2) 853(7) 857(2) 887(5) 907(7) 911(2) 929(2) 941(5) 947(2)
977(5) 983(2) 997(7)
33 nice primes in the range 500 to 1000</pre>
 
=={{header|PARI/GP}}==
<syntaxhighlight lang="python">nicePrimes( s, e ) = { local( m );
forprime( p = s, e,
m = p; \\
while( m > 9, \\ m == p mod 9
m = sumdigits( m ) ); \\
if( isprime( m ),
print1( p, " " ) ) );
}</syntaxhighlight>
or
<syntaxhighlight lang="pari/gp">select( p -> isprime( p % 9 ), primes( [500, 1000] ))</syntaxhighlight>
 
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
 
Line 939 ⟶ 1,461:
$cnt = @nice_primes;
print "Nice primes between $low and $high (total of $cnt):\n" .
(sprintf "@{['%5d' x $cnt]}", @nice_primes[0..$cnt-1]) =~ s/(.{55})/$1\n/gr;</langsyntaxhighlight>
{{out}}
<pre>Nice primes between 500 and 1000 (total of 33):
Line 948 ⟶ 1,470:
=={{header|Phix}}==
{{trans|Factor}}
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>function pdr(integer n) return is_prime(n) and is_prime(1+remainder(n-1,9)) end function
<span style="color: #008080;">function</span> <span style="color: #000000;">pdr</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">+</span><span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
sequence res = filter(tagset(1000,500),pdr)
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">,</span><span style="color: #000000;">500</span><span style="color: #0000FF;">),</span><span style="color: #000000;">pdr</span><span style="color: #0000FF;">)</span>
printf(1,"%d nice primes found:\n %s\n",{length(res),join_by(apply(res,sprint),1,11," ","\n ")})</lang>
<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;">"%d nice primes found:\n %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">11</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n "</span><span style="color: #0000FF;">)})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 957 ⟶ 1,481:
659 673 677 691 709 727 743 761 797 821 839
853 857 887 907 911 929 941 947 977 983 997
</pre>
 
=={{header|PHP}}==
{{trans|Python}}
<syntaxhighlight lang="php">
<?php
// Function to check if a number is prime
function isPrime($n) {
if ($n <= 1) {
return false;
}
for ($i = 2; $i <= sqrt($n); $i++) {
if ($n % $i == 0) {
return false;
}
}
return true;
}
 
// Function to sum the digits of a number until the sum is a single digit
function sumOfDigits($n) {
while ($n > 9) {
$sum = 0;
while ($n > 0) {
$sum += $n % 10;
$n = (int)($n / 10);
}
$n = $sum;
}
return $n;
}
 
function findNicePrimes($lower_limit=501, $upper_limit=1000) {
// Find all Nice primes within the specified range
$nice_primes = array();
for ($n = $lower_limit; $n < $upper_limit; $n++) {
if (isPrime($n)) {
$sumn = sumOfDigits($n);
if (isPrime($sumn)) {
array_push($nice_primes, $n);
}
}
}
return $nice_primes;
}
// Main loop to find and print "Nice Primes"
$nice_primes = findNicePrimes();
foreach ($nice_primes as $prime) {
echo $prime . " ";
}
?>
</syntaxhighlight>
{{out}}
<pre>
509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997
</pre>
 
=={{header|Python}}==
<syntaxhighlight lang="python">
def is_prime(n):
"""Check if a number is prime."""
if n <= 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
 
def sum_of_digits(n):
"""Calculate the repeated sum of digits until the sum's length is 1."""
while n > 9:
n = sum(int(digit) for digit in str(n))
return n
 
def find_nice_primes(lower_limit=501, upper_limit=1000):
"""Find all Nice primes within the specified range."""
nice_primes = []
for n in range(lower_limit, upper_limit):
if is_prime(n):
sumn = sum_of_digits(n)
if is_prime(sumn):
nice_primes.append(n)
return nice_primes
 
# Example usage
nice_primes = find_nice_primes()
print(nice_primes)
</syntaxhighlight>
{{out}}
<pre>
[509, 547, 563, 569, 587, 599, 601, 617, 619, 641, 653, 659, 673, 677, 691, 709, 727, 743, 761, 797, 821, 839, 853, 857, 887, 907, 911, 929, 941, 947, 977, 983, 997]
</pre>
=={{header|PL/0}}==
<syntaxhighlight lang="pascal">
var n, sum, prime, i;
procedure sumdigitsofn;
var v, vover10;
begin
sum := 0;
v := n;
while v > 0 do begin
vover10 := v / 10;
sum := sum + ( v - ( vover10 * 10 ) );
v := vover10
end
end;
procedure isnprime;
var p;
begin
prime := 1;
if n < 2 then prime := 0;
if n > 2 then begin
prime := 0;
if odd( n ) then prime := 1;
p := 3;
while p * p <= n * prime do begin
if n - ( ( n / p ) * p ) = 0 then prime := 0;
p := p + 2;
end
end
end;
begin
i := 500;
while i < 999 do begin
i := i + 1;
n := i;
call isnprime;
if prime = 1 then begin
sum := n;
while sum > 9 do begin
call sumdigitsofn;
n := sum
end;
if sum = 2 then ! i;
if sum = 3 then ! i;
if sum = 5 then ! i;
if sum = 7 then ! i
end
end
end.
</syntaxhighlight>
{{out}}
Note: PL/0 can only output one value per line, to avoid a long output, the results have been manually combined to 7 per line.
<pre>
509 547 563 569 587 599 601
617 619 641 653 659 673 677
691 709 727 743 761 797 821
839 853 857 887 907 911 929
941 947 977 983 997
</pre>
 
=={{header|PL/M}}==
{{Trans|ALGOL 68}}
<syntaxhighlight lang="plm">100H: /* FIND NICE PRIMES - PRIMES WHOSE DIGITAL ROOT IS ALSO PRIME */
BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */
DECLARE FN BYTE, ARG ADDRESS;
GOTO 5;
END BDOS;
PRINT$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PRINT$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PRINT$NUMBER: PROCEDURE( N );
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR( 6 ) BYTE, W BYTE;
V = N;
W = LAST( N$STR );
N$STR( W ) = '$';
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL PRINT$STRING( .N$STR( W ) );
END PRINT$NUMBER;
/* INTEGER SUARE ROOT: BASED ON THE ONE IN THE PL/M FOR FROBENIUS NUMBERS */
SQRT: PROCEDURE( N )ADDRESS;
DECLARE ( N, X0, X1 ) ADDRESS;
IF N <= 3 THEN DO;
IF N = 0 THEN X0 = 0; ELSE X0 = 1;
END;
ELSE DO;
X0 = SHR( N, 1 );
DO WHILE( ( X1 := SHR( X0 + ( N / X0 ), 1 ) ) < X0 );
X0 = X1;
END;
END;
RETURN X0;
END SQRT;
DECLARE MIN$PRIME LITERALLY '501';
DECLARE MAX$PRIME LITERALLY '999';
DECLARE DCL$PRIME LITERALLY '1000';
DECLARE FALSE LITERALLY '0';
DECLARE TRUE LITERALLY '1';
/* SIEVE THE PRIMES TO MAX$PRIME */
DECLARE ( I, S ) ADDRESS;
DECLARE PRIME ( DCL$PRIME )BYTE;
PRIME( 1 ) = FALSE; PRIME( 2 ) = TRUE;
DO I = 3 TO LAST( PRIME ) BY 2; PRIME( I ) = TRUE; END;
DO I = 4 TO LAST( PRIME ) BY 2; PRIME( I ) = FALSE; END;
DO I = 3 TO SQRT( MAX$PRIME );
IF PRIME( I ) THEN DO;
DO S = I * I TO LAST( PRIME ) BY I + I;PRIME( S ) = FALSE; END;
END;
END;
/* FIND THE NICE PRIMES */
DECLARE NICE$COUNT ADDRESS;
NICE$COUNT = 0;
DO I = MIN$PRIME TO MAX$PRIME;
IF PRIME( I ) THEN DO;
/* HAVE A PRIME */
DECLARE DIGIT$SUM BYTE, V ADDRESS;
DIGIT$SUM = LOW( V := I );
DO WHILE( V > 9 );
DIGIT$SUM = 0;
DO WHILE( V > 0 );
DIGIT$SUM = DIGIT$SUM + ( V MOD 10 );
V = V / 10;
END;
V = DIGIT$SUM;
END;
IF PRIME( DIGIT$SUM ) THEN DO;
/* THE DIGITAL ROOT IS PRIME */
NICE$COUNT = NICE$COUNT + 1;
CALL PRINT$CHAR( ' ' );
CALL PRINT$NUMBER( I );
CALL PRINT$CHAR( '(' );
CALL PRINTCHAR( DIGIT$SUM + '0' );
CALL PRINT$CHAR( ')' );
IF NICE$COUNT MOD 12 = 0 THEN DO;
CALL PRINT$STRING( .( 0DH, 0AH, '$' ) );
END;
END;
END;
END;
EOF</syntaxhighlight>
{{out}}
<pre>
509(5) 547(7) 563(5) 569(2) 587(2) 599(5) 601(7) 617(5) 619(7) 641(2) 653(5) 659(2)
673(7) 677(2) 691(7) 709(7) 727(7) 743(5) 761(5) 797(5) 821(2) 839(2) 853(7) 857(2)
887(5) 907(7) 911(2) 929(2) 941(5) 947(2) 977(5) 983(2) 997(7)
</pre>
 
=={{header|Quackery}}==
<code>eratosthenes</code> and <code>isprime</code> are defined at [[Sieve of Eratosthenes#Quackery]].
 
<syntaxhighlight lang="quackery"> 1000 eratosthenes
 
[ 1 - 9 mod 1+ ] is digitalroot ( n --> n )
 
[ dup digitalroot isprime
swap isprime and ] is niceprime ( n --> b )
 
500 times
[ i^ 500 + niceprime if
[ i^ 500 + echo sp ] ]</syntaxhighlight>
 
{{out}}
 
<pre>509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997
</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>sub digroot ($r) { .tail given $r, { [+] .comb } ... { .chars == 1 } }
my @is-nice = lazy (0..*).map: { .&is-prime && .&digroot.&is-prime ?? $_ !! False };
say @is-nice[500 ^..^ 1000].grep(*.so).batch(11)».fmt("%4d").join: "\n";</langsyntaxhighlight>
{{out}}
<pre> 509 547 563 569 587 599 601 617 619 641 653
Line 969 ⟶ 1,750:
 
Alternately, with somewhat better separation of concerns.
<syntaxhighlight lang="raku" perl6line>sub digroot ($r) { ($r, { .comb.sum } … { .chars == 1 }).tail }
sub is-nice ($_) { .is-prime && .&digroot.is-prime }
say (500 ^..^ 1000).grep( *.&is-nice ).batch(11)».fmt("%4d").join: "\n";</langsyntaxhighlight>
Same output.
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX program finds and displays nice primes, primes whose digital root is also prime.*/
parse arg lo hi cols . /*obtain optional argument from the CL.*/
if lo=='' | lo=="," then lo= 500 /*Not specified? Then use the default.*/
Line 982 ⟶ 1,763:
call genP /*build array of semaphores for primes.*/
w= 10 /*width of a number in any column. */
@nicetitle= ' nice primes that are between ' commas(lo) " and " commas(hi)
if cols>0 then say ' index │'center(@nicetitle ' (not inclusive)', 1 + cols*(w+1) )
if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─')
Nprimesfound= 0; idx= 1 /*initialize # of nice primes and index*/
$= /*a list of nice primes (so far). */
do j=lo+1 to hi-1; if \!.j then iterate /*search for nice primes within range*/
digRoot= 1 + (j - 1) // 9 /*obtain the digital root of J. */
if \!.digRoot then iterate /*Is digRoot prime? No, then skip it.*/
Nprimesfound= Nprimesfound + 1 /*bump the number of nice primes. */
if cols==<0 then iterate /*Build the list (to be shown later)? */
c= commas(j) /*maybe add commas to the number. */
$= $ right(c, max(w, length(c) ) ) /*add a nice prime ──► list, allow big#*/
if Nprimesfound//cols\==0 then iterate /*have we populated a line of output? */
say center(idx, 7)'│' substr($, 2); $= /*display what we have so far (cols). */
idx= idx + cols /*bump the index count for the output*/
Line 1,002 ⟶ 1,783:
if cols>0 then say '───────┴'center("" , 1 + cols*(w+1), '─')
say
say 'Found ' commas(Nprimesfound) @nicetitle ' (not inclusive).'
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
genP: !.= 0 @.1=2; @.2=3; @.3=5; @.4=7; @.5=11 /*define some low primes. /*placeholders for primes (semaphores).*/
@!.1=20; @!.2=31; @!.3=51; @!.45=1; !.7=1; @!.5=11=1 /* " /*define some low primes. " " " semaphores. */
!.2=1; !.3=1; !.5=1; !.7=1; !.11=1 /* " "#=5; "s.#= @.# **2 " /*number of primes so flags. far; prime². */
#=5; s.#= @.# **2 /*number of primes so far; prime². */
/* [↓] generate more primes ≤ high.*/
do j=@.#+2 by 2 to hi /*find odd primes from here on. */
parse var j '' -1 _; if _==5 then iterate /*J divisible by 5? (right dig)*/
if j// 3==0 then iterate /*" " " 3? */
if j// 7==0 then iterate /*" " " 7? */
/* [↑] the above 3 five lines saves time.*/
do k=5 while s.k<=j /* [↓] divide by the known odd primes.*/
if j // @.k == 0 then iterate j /*Is J ÷ X? Then not prime. ___ */
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; s.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,036 ⟶ 1,815:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 1,065 ⟶ 1,844:
 
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,104 ⟶ 1,883:
33: 997 > Σ = 7
done...
</pre>
 
=={{header|RPL}}==
≪ { } 500
'''DO'''
NEXTPRIME
'''IF''' DUP 1 - 9 MOD 1 + ISPRIME? '''THEN'''
SWAP OVER + SWAP '''END'''
'''UNTIL''' DUP 1000 ≥ '''END'''
DROP
≫ '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { 509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997 }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
 
class Integer
def dig_root = (1+(self-1).remainder(9))
def nice? = prime? && dig_root.prime?
end
 
p (500..1000).select(&:nice?)
</syntaxhighlight>
{{out}}
<pre>[509, 547, 563, 569, 587, 599, 601, 617, 619, 641, 653, 659, 673, 677, 691, 709, 727, 743, 761, 797, 821, 839, 853, 857, 887, 907, 911, 929, 941, 947, 977, 983, 997]
</pre>
 
=={{header|Rust}}==
{{trans|Factor}}
<langsyntaxhighlight lang="rust">// [dependencies]
// primal = "0.3"
 
Line 1,129 ⟶ 1,936:
fn main() {
nice_primes(500, 1000);
}</langsyntaxhighlight>
 
{{out}}
Line 1,166 ⟶ 1,973:
983
997
</pre>
 
=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const func boolean: isPrime (in integer: number) is func
result
var boolean: prime is FALSE;
local
var integer: upTo is 0;
var integer: testNum is 3;
begin
if number = 2 then
prime := TRUE;
elsif odd(number) and number > 2 then
upTo := sqrt(number);
while number rem testNum <> 0 and testNum <= upTo do
testNum +:= 2;
end while;
prime := testNum > upTo;
end if;
end func;
 
const proc: main is func
local
var integer: n is 0;
begin
for n range 501 to 999 step 2 do
if isPrime(n) and 1 + ((n - 1) rem 9) in {2, 3, 5, 7} then
write(n <& " ");
end if;
end for;
end func;</syntaxhighlight>
{{out}}
<pre>
509 547 563 569 587 599 601 617 619 641 653 659 673 677 691 709 727 743 761 797 821 839 853 857 887 907 911 929 941 947 977 983 997
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func digital_root(n, base=10) {
while (n.len(base) > 1) {
n = n.sumdigits(base)
}
return n
}
 
say primes(500, 1000).grep { digital_root(_).is_prime }</syntaxhighlight>
{{out}}
<pre>
[509, 547, 563, 569, 587, 599, 601, 617, 619, 641, 653, 659, 673, 677, 691, 709, 727, 743, 761, 797, 821, 839, 853, 857, 887, 907, 911, 929, 941, 947, 977, 983, 997]
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-traititerate}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int
import "./traititerate" for Stepped
import "./fmt" for Fmt
 
var sumDigits = Fn.new { |n|
Line 1,196 ⟶ 2,053:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 1,234 ⟶ 2,091:
32: 983 -> Σ = 2
33: 997 -> Σ = 7
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">func IntLen(N); \Return number of digits in N
int N, I;
for I:= 1 to 10 do
[N:= N/10;
if N = 0 then return I;
];
 
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;
];
 
func SumDigits(N); \Return sum of digits in N
int N, Sum;
[Sum:= 0;
repeat N:= N/10;
Sum:= Sum + rem(0);
until N=0;
return Sum;
];
 
int C, N, SumN;
[C:= 0;
for N:= 501 to 999 do
if IsPrime(N) then
[SumN:= N;
repeat SumN:= SumDigits(SumN);
until IntLen(SumN) = 1;
if IsPrime(SumN) then
[IntOut(0, N);
C:= C+1;
if rem (C/10) then ChOut(0, ^ ) else CrLf(0);
];
];
]</syntaxhighlight>
 
{{out}}
<pre>
509 547 563 569 587 599 601 617 619 641
653 659 673 677 691 709 727 743 761 797
821 839 853 857 887 907 911 929 941 947
977 983 997
</pre>
Chkas
2,046

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/309120...364433"