Primes with digits in nondecreasing order: Difference between revisions
Primes with digits in nondecreasing order (view source)
Revision as of 16:28, 28 January 2024
, 4 months ago→{{header|Wren}}: Changed to Wren S/H
No edit summary |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(9 intermediate revisions by 9 users not shown) | |||
Line 5:
Find all primes ('''n''') with their decimal digits in non-decreasing order, where '''n < 1,000'''
<br><br>
=={{header|11l}}==
{{trans|Nim}}
<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 is_non_decreasing(=n)
V prev = 10
L n != 0
V d = n % 10
I d > prev {R 0B}
prev = d
n I/= 10
R 1B
V c = 0
L(n) 1000
I is_non_decreasing(n) & is_prime(n)
c++
print(‘#3’.format(n), end' I c % 10 == 0 {"\n"} E ‘ ’)
print()
print(‘Found ’c‘ primes with digits in nondecreasing order’)</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11 13 17 19 23 29
37 47 59 67 79 89 113 127 137 139
149 157 167 179 199 223 227 229 233 239
257 269 277 337 347 349 359 367 379 389
449 457 467 479 499 557 569 577 599 677
Found 50 primes with digits in nondecreasing order
</pre>
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"
BYTE FUNC NonDecreasingDigits(INT x)
BYTE c,d,last
c=0 last=9
WHILE x#0
DO
d=x MOD 10
IF d>last THEN
RETURN (0)
FI
last=d
x==/10
OD
RETURN (1)
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=2 TO MAX
DO
IF primes(i)=1 AND NonDecreasingDigits(i)=1 THEN
PrintI(i) Put(32)
count==+1
FI
OD
PrintF("%E%EThere are %I primes",count)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Primes_with_digits_in_nondecreasing_order.png Screenshot from Atari 8-bit computer]
<pre>
2 3 5 7 11 13 17 19 23 29 37 47 59 67 79 89 113 127 137 139 149 157 167 179 199 223 227 229
233 239 257 269 277 337 347 349 359 367 379 389 449 457 467 479 499 557 569 577 599 677
There are 50 primes
</pre>
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<
INT max number = 1000;
# sieve the primes to max number #
Line 44 ⟶ 129:
)
)
END</
{{out}}
<pre>
Line 58 ⟶ 143:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
{{out}}
<pre>2 3 5 7 11 13 17 19 23 29 37 47 59 67 79 89 113 127 137 139 149 157 167
Line 66 ⟶ 151:
=={{header|Arturo}}==
<
nondecreasing?: function [n][
ds: digits n
Line 81 ⟶ 166:
loop split.every: 10 select primes => nondecreasing? 'a ->
print map a => [pad to :string & 4]</
{{out}}
Line 92 ⟶ 177:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f PRIMES_WITH_DIGITS_IN_NONDECREASING_ORDER.AWK
BEGIN {
Line 124 ⟶ 209:
return(1)
}
</syntaxhighlight>
{{out}}
<pre>
Line 137 ⟶ 222:
=={{header|BASIC}}==
{{works with|QBasic}}
<syntaxhighlight lang="basic">10 DEFINT A-Z
20 DIM P(1000)
30 P(0)=-1: P(1)=-1
Line 146 ⟶ 232:
80 N=A*100+B*10+C
90 IF P(N)=0 THEN PRINT N,
100 NEXT C,B,A</
{{out}}
<pre> 2 3 5 7 11
Line 158 ⟶ 244:
449 457 467 479 499
557 569 577 599 677</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">function isPrime(v)
if v < 2 then return False
if v mod 2 = 0 then return v = 2
if v mod 3 = 0 then return v = 3
d = 5
while d * d <= v
if v mod d = 0 then return False else d += 2
end while
return True
end function
function is_ndp(n)
d = 10
do
ld = d
d = n mod 10
if d > ld then return False
n /= 10
until n = 0
return True
end function
c = 0
print "Primes below 1,000 with digits in non-decreasing order:"
for i = 2 to 999
if isPrime(i) and is_ndp(i) then
c += 1
print i; chr(9);
if c mod 10 = 0 then print
end if
next i
print chr(10); c; " such primes found."
end</syntaxhighlight>
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">Procedure isPrime(v.i)
If v <= 1 : ProcedureReturn #False
ElseIf v < 4 : ProcedureReturn #True
ElseIf v % 2 = 0 : ProcedureReturn #False
ElseIf v < 9 : ProcedureReturn #True
ElseIf v % 3 = 0 : ProcedureReturn #False
Else
Protected r = Round(Sqr(v), #PB_Round_Down)
Protected f = 5
While f <= r
If v % f = 0 Or v % (f + 2) = 0
ProcedureReturn #False
EndIf
f + 6
Wend
EndIf
ProcedureReturn #True
EndProcedure
Procedure is_ndp(n.i)
d.i = 10
Repeat
ld.i = d
d = n % 10
If d > ld
ProcedureReturn #False
EndIf
n / 10
Until n = 0
ProcedureReturn #True
EndProcedure
OpenConsole()
c.i = 0
PrintN("Primes below 1,000 with digits in non-decreasing order:")
For i.i = 2 To 999
If isPrime(i) And is_ndp(i)
c + 1
Print(Str(i) + #TAB$)
If c % 10 = 0 : PrintN("") : EndIf
EndIf
Next i
PrintN(#CRLF$ + Str(c) + " such primes found."): Input()
CloseConsole()</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">sub isPrime(v)
if v < 2 then return False : fi
if mod(v, 2) = 0 then return v = 2 : fi
if mod(v, 3) = 0 then return v = 3 : fi
d = 5
while d * d <= v
if mod(v, d) = 0 then return False else d = d + 2 : fi
wend
return True
end sub
sub is_ndp(n)
d = 10
repeat
ld = d
d = mod(n, 10)
if d > ld then return False : fi
n = int(n / 10)
until n = 0
return True
end sub
c = 0
print "Primes below 1,000 with digits in non-decreasing order:"
for i = 2 to 999
if isPrime(i) and is_ndp(i) then
c = c + 1
print i using "####";
if mod(c, 10) = 0 then print : fi
endif
next i
print chr$(10), c, " such primes found."
end</syntaxhighlight>
=={{header|BCPL}}==
<
let sieve(prime, max) be
Line 192 ⟶ 396:
$)
freevec(prime)
$)</
{{out}}
<pre> 2 3 5 7 11 13 17 19 23 29
Line 202 ⟶ 406:
=={{header|C#|CSharp}}==
The ''chars'' array explicitly enforces the case order, not relying on the language's idea of what letters are before or after each other.
<
class Program {
Line 234 ⟶ 438:
if (!flags[j]) { yield return j;
for (int k = sq, i = j << 1; k <= lim; k += i) flags[k] = true; }
for (; j <= lim; j += 2) if (!flags[j]) yield return j; } }</
{{out}}
<pre style="height:20em"> 11 111 11111 1111111
Line 309 ⟶ 513:
Eh Ep Ez FH FN Fb Ff Fl Fr Fz
Base 62: found 150 non-decreasing primes under G8</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;
procedure GetDigits(N: integer; var IA: TIntegerDynArray);
{Get an array of the integers in a number}
var T: integer;
begin
SetLength(IA,0);
repeat
begin
T:=N mod 10;
N:=N div 10;
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=T;
end
until N<1;
end;
procedure NonDecreasingPrime(Memo: TMemo);
var I,Cnt: integer;
var IA: TIntegerDynArray;
var S: string;
function NotDecreasing(N: integer): boolean;
var I: integer;
begin
Result:=False;
GetDigits(N,IA);
for I:=0 to High(IA)-1 do
if IA[I]<IA[I+1] then exit;
Result:=True;
end;
begin
Cnt:=0;
S:='';
for I:=0 to 1000-1 do
if IsPrime(I) then
if NotDecreasing(I) then
begin
Inc(Cnt);
S:=S+Format('%5D',[I]);
If (Cnt mod 5)=0 then S:=S+CRLF;
end;
Memo.Lines.Add(S);
Memo.Lines.Add('Count = '+IntToStr(Cnt));
end;
</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11
13 17 19 23 29
37 47 59 67 79
89 113 127 137 139
149 157 167 179 199
223 227 229 233 239
257 269 277 337 347
349 359 367 379 389
449 457 467 479 499
557 569 577 599 677
Count = 50
Elapsed Time: 3.008 ms.
</pre>
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<
// Primes with digits in nondecreasing order: Nigel Galloway. May 16th., 2021
let rec fN g=function n when n<10->(n<=g) |n when (n%10)<=g->fN(n%10)(n/10) |_->false
let fN=fN 9 in primes32()|>Seq.takeWhile((>)1000)|>Seq.filter fN|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
{{out}}
<pre>
Line 323 ⟶ 622:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<
present prettyprint ;
lprimes [ present [ <= ] monotonic? ] lfilter
[ 1000 < ] lwhile [ . ] leach</
{{out}}
<pre style="height:14em">
Line 383 ⟶ 682:
=={{header|J}}==
<
exit 0</
{{out}}
<pre>2 3 5 7 11 13 17 19 23 29 37 47 59 67 79 89 113 127 137 139 149 157 167 179 199 223 227 229 233 239 257 269 277 337 347 349 359 367 379 389 449 457 467 479 499 557 569 577 599 677</pre>
=={{header|FreeBASIC}}==
<
function is_ndp( byval n as integer ) as boolean
Line 404 ⟶ 703:
for i as uinteger = 2 to 999
if isprime(i) andalso is_ndp(i) then print i;" ";
next i : print</
{{out}}<pre>2 3 5 7 11 13 17 19 23 29 37 47 59 67 79 89 113 127 137 139 149 157 167 179 199 223 227 229 233 239 257 269 277 337 347 349 359 367 379 389 449 457 467 479 499 557 569 577 599 677</pre>
=={{header|Frink}}==
<syntaxhighlight lang="frink">for n = primes[2,1000]
if sort[integerDigits[n]] == integerDigits[n]
print["$n "]</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 11 13 17 19 23 29 37 47 59 67 79 89 113 127 137 139 149 157 167 179 199 223 227 229 233 239 257 269 277 337 347 349 359 367 379 389 449 457 467 479 499 557 569 577 599 677
</pre>
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<
import (
Line 447 ⟶ 755:
}
fmt.Printf("\n%d such primes found.\n", len(nonDesc))
}</
{{out}}
Line 466 ⟶ 774:
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
<
# Input: an upper bound, or `infinite`
Line 474 ⟶ 782:
| select( (digits | (. == sort)) and is_prime);
1000 | primes_with_nondecreasing_digits</
{{out}} (abbreviated)
<pre>
Line 493 ⟶ 801:
{{trans|Raku}}
Note for the case-sensitive digits base 62 example: Julia defaults to 'A' < 'a' in sorting. So Aa is in order, but aA is not nondecreasing.
<
const range = 2:999
Line 503 ⟶ 811:
foreach(p -> print(lpad(string(p[2], base=base), 5), p[1] % 16 == 0 ? "\n" : ""), enumerate(primes))
end
</
<pre>
Base 2: 4 non-descending primes between 1 and 1111111:
Line 579 ⟶ 887:
=={{header|Ksh}}==
<
#!/bin/ksh
Line 628 ⟶ 936:
done
printf "\n%d Primes with digits in nondecreasing order < %d\n" ${cnt} $MAXPRIME
</syntaxhighlight>
{{out}}<pre>
3 5 7 11 13 17 19 23 29 37 47 59 67 79 89 113 127 137 139 149 157 167 179 199 223 227 229 233 239 257 269 277 337 347 349 359 367 379 389 449 457 467 479 499 557 569 577 599 677
Line 634 ⟶ 942:
=={{header|MAD}}==
<
BOOLEAN PRIME
DIMENSION PRIME(1000), COL(10)
Line 664 ⟶ 972:
TEST CONTINUE
VECTOR VALUES CFMT = $10(I4)*$
END OF PROGRAM </
{{out}}
<pre> 2 3 5 7 11 13 17 19 23 29
Line 671 ⟶ 979:
257 269 277 337 347 349 359 367 379 389
449 457 467 479 499 557 569 577 599 677</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Partition[
Cases[Most@
NestWhileList[NextPrime,
2, # < 1000 &], _?(OrderedQ[IntegerDigits@#] &)],
UpTo[10]] // TableForm</syntaxhighlight>
{{out}}<pre>
2 3 5 7 11 13 17 19 23 29
37 47 59 67 79 89 113 127 137 139
149 157 167 179 199 223 227 229 233 239
257 269 277 337 347 349 359 367 379 389
449 457 467 479 499 557 569 577 599 677
</pre>
=={{header|Nim}}==
<
func isPrime(n: Natural): bool =
Line 703 ⟶ 1,025:
echo &"Found {result.len} primes:"
for i, n in result:
stdout.write &"{n:3}", if (i + 1) mod 10 == 0: '\n' else: ' '</
{{out}}
Line 714 ⟶ 1,036:
=={{header|Phix}}==
<!--<
<span style="color: #008080;">function</span> <span style="color: #000000;">nd</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<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;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"%d"</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><span style="color: #000000;">nd</span><span style="color: #0000FF;">)</span>
<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 non-decreasing primes < 1,000: %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</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">))})</span>
<!--</
{{out}}
<pre>
Line 726 ⟶ 1,048:
=={{header|Perl}}==
{{libheader|ntheory}}
<
use strict;
Line 733 ⟶ 1,055:
my @want = grep ! /(.)(.)(??{$1 > $2 ? '' : '(*FAIL)'})/, @{ primes(1000) };
print "@want" =~ s/.{50}\K /\n/gr . "\n\ncount: " . @want . "\n";</
{{out}}
<pre>
Line 745 ⟶ 1,067:
=={{header|Plain English}}==
<
Start up.
Loop.
Line 768 ⟶ 1,090:
If the number is not prime, say no.
If the number is not non-decreasing, say no.
Say yes.</
{{out}}
<pre>
Line 775 ⟶ 1,097:
=={{header|PL/M}}==
<
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
Line 831 ⟶ 1,153:
END;
CALL EXIT;
EOF</
{{out}}
<pre>2 3 5 7 11 13 17 19 23 29
Line 840 ⟶ 1,162:
=={{header|Python}}==
<
from operator import le
Line 955 ⟶ 1,277:
if __name__ == '__main__':
main()
</syntaxhighlight>
{{Out}}
<pre>50 matches for base 10:
Line 966 ⟶ 1,288:
=={{header|Raku}}==
<syntaxhighlight lang="raku"
for flat 2..10, 17, 27, 31 -> $base {
Line 972 ⟶ 1,294:
.batch(20)».fmt("%{.tail.chars}s").join: "\n" }"
given $range.grep( *.is-prime ).map( *.base: $base ).grep: { [le] .comb }
}</
{{out}}
<pre>Base 2: 4 non-decending primes between 0 and 1111100111:
Line 1,032 ⟶ 1,354:
=={{header|REXX}}==
<
parse arg n cols . /*obtain optional argument from the CL.*/
if n=='' | n=="," then n= 1000 /*Not specified? Then use the default.*/
Line 1,075 ⟶ 1,397:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; s.#= j*j /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,091 ⟶ 1,413:
=={{header|Ring}}==
<
? "working..."
Line 1,124 ⟶ 1,446:
s = string(x) l = len(s)
if l > y y = l ok
return substr(" ", 11 - y + l) + s</
{{out}}
<pre>working...
Line 1,136 ⟶ 1,458:
Found 50 base 10 primes with digits in nondecreasing order
done...</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
base = 10
upto = 1000
res = Prime.each(upto).select do |pr|
pr.digits(base).each_cons(2).all?{|p1, p2| p1 >= p2}
end
puts "There are #{res.size} non-descending primes below #{upto}:"
puts res.join(", ")
</syntaxhighlight>
{{out}}
<pre>There are 50 non-descending primes below 1000:
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 37, 47, 59, 67, 79, 89, 113, 127, 137, 139, 149, 157, 167, 179, 199, 223, 227, 229, 233, 239, 257, 269, 277, 337, 347, 349, 359, 367, 379, 389, 449, 457, 467, 479, 499, 557, 569, 577, 599, 677
</pre>
=={{header|Seed7}}==
<
Line 1,188 ⟶ 1,528:
end if;
end for;
end func;</
{{out}}
<pre>
Line 1,196 ⟶ 1,536:
=={{header|Sidef}}==
Simple solution:
<
Generate such primes from digits (asymptotically faster):
<
upto = prev_prime(upto+1)
Line 1,224 ⟶ 1,564:
}
say primes_with_nondecreasing_digits(1000)</
{{out}}
<pre>
Line 1,232 ⟶ 1,572:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Imports System.Collections.Generic
Imports System.Console
Line 1,286 ⟶ 1,626:
Next
End Sub
End Module</
{{out}}
Same as C#.
Line 1,292 ⟶ 1,632:
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<
import "./
var nonDescending = Fn.new { |p|
Line 1,314 ⟶ 1,652:
for (p in primes) if (nonDescending.call(p)) nonDesc.add(p)
System.print("Primes below 1,000 with digits in non-decreasing order:")
Fmt.tprint("$3d", nonDesc, 10)
System.print("\n%(nonDesc.count) such primes found.")</
{{out}}
Line 1,330 ⟶ 1,668:
=={{header|XPL0}}==
<
int N, I;
[if N <= 1 then return false;
Line 1,365 ⟶ 1,703:
Text(0, " primes found with nondecreasing digits below 1000.
");
]</
{{out}}
|