Primes with digits in nondecreasing order: Difference between revisions
Primes with digits in nondecreasing order (view source)
Revision as of 11:18, 28 August 2022
, 1 year agosyntax highlighting fixup automation
(Frink) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 9:
{{trans|Nim}}
<
I a == 2
R 1B
Line 34:
print(‘#3’.format(n), end' I c % 10 == 0 {"\n"} E ‘ ’)
print()
print(‘Found ’c‘ primes with digits in nondecreasing order’)</
{{out}}
Line 49:
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<
BYTE FUNC NonDecreasingDigits(INT x)
Line 81:
OD
PrintF("%E%EThere are %I primes",count)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Primes_with_digits_in_nondecreasing_order.png Screenshot from Atari 8-bit computer]
Line 93:
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<
INT max number = 1000;
# sieve the primes to max number #
Line 129:
)
)
END</
{{out}}
<pre>
Line 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 151:
=={{header|Arturo}}==
<
nondecreasing?: function [n][
ds: digits n
Line 166:
loop split.every: 10 select primes => nondecreasing? 'a ->
print map a => [pad to :string & 4]</
{{out}}
Line 177:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f PRIMES_WITH_DIGITS_IN_NONDECREASING_ORDER.AWK
BEGIN {
Line 209:
return(1)
}
</syntaxhighlight>
{{out}}
<pre>
Line 223:
=={{header|BASIC}}==
{{works with|QBasic}}
<
20 DIM P(1000)
30 P(0)=-1: P(1)=-1
Line 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 247:
==={{header|BASIC256}}===
<
if v < 2 then return False
if v mod 2 = 0 then return v = 2
Line 279:
next i
print chr(10); c; " such primes found."
end</
==={{header|PureBasic}}===
<
If v <= 1 : ProcedureReturn #False
ElseIf v < 4 : ProcedureReturn #True
Line 325:
Next i
PrintN(#CRLF$ + Str(c) + " such primes found."): Input()
CloseConsole()</
==={{header|Yabasic}}===
<
if v < 2 then return False : fi
if mod(v, 2) = 0 then return v = 2 : fi
Line 360:
next i
print chr$(10), c, " such primes found."
end</
=={{header|BCPL}}==
<
let sieve(prime, max) be
Line 396:
$)
freevec(prime)
$)</
{{out}}
<pre> 2 3 5 7 11 13 17 19 23 29
Line 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 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 516:
=={{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 527:
=={{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 587:
=={{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 608:
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}}==
<
if sort[integerDigits[n]] == integerDigits[n]
print["$n "]</
{{out}}
<pre>
Line 623:
{{trans|Wren}}
{{libheader|Go-rcu}}
<
import (
Line 660:
}
fmt.Printf("\n%d such primes found.\n", len(nonDesc))
}</
{{out}}
Line 679:
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
<
# Input: an upper bound, or `infinite`
Line 687:
| select( (digits | (. == sort)) and is_prime);
1000 | primes_with_nondecreasing_digits</
{{out}} (abbreviated)
<pre>
Line 706:
{{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 716:
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 792:
=={{header|Ksh}}==
<
#!/bin/ksh
Line 841:
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 847:
=={{header|MAD}}==
<
BOOLEAN PRIME
DIMENSION PRIME(1000), COL(10)
Line 877:
TEST CONTINUE
VECTOR VALUES CFMT = $10(I4)*$
END OF PROGRAM </
{{out}}
<pre> 2 3 5 7 11 13 17 19 23 29
Line 885:
449 457 467 479 499 557 569 577 599 677</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
Cases[Most@
NestWhileList[NextPrime,
2, # < 1000 &], _?(OrderedQ[IntegerDigits@#] &)],
UpTo[10]] // TableForm</
{{out}}<pre>
Line 900:
=={{header|Nim}}==
<
func isPrime(n: Natural): bool =
Line 930:
echo &"Found {result.len} primes:"
for i, n in result:
stdout.write &"{n:3}", if (i + 1) mod 10 == 0: '\n' else: ' '</
{{out}}
Line 941:
=={{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 953:
=={{header|Perl}}==
{{libheader|ntheory}}
<
use strict;
Line 960:
my @want = grep ! /(.)(.)(??{$1 > $2 ? '' : '(*FAIL)'})/, @{ primes(1000) };
print "@want" =~ s/.{50}\K /\n/gr . "\n\ncount: " . @want . "\n";</
{{out}}
<pre>
Line 972:
=={{header|Plain English}}==
<
Start up.
Loop.
Line 995:
If the number is not prime, say no.
If the number is not non-decreasing, say no.
Say yes.</
{{out}}
<pre>
Line 1,002:
=={{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 1,058:
END;
CALL EXIT;
EOF</
{{out}}
<pre>2 3 5 7 11 13 17 19 23 29
Line 1,067:
=={{header|Python}}==
<
from operator import le
Line 1,182:
if __name__ == '__main__':
main()
</syntaxhighlight>
{{Out}}
<pre>50 matches for base 10:
Line 1,193:
=={{header|Raku}}==
<syntaxhighlight lang="raku"
for flat 2..10, 17, 27, 31 -> $base {
Line 1,199:
.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,259:
=={{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,302:
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,318:
=={{header|Ring}}==
<
? "working..."
Line 1,351:
s = string(x) l = len(s)
if l > y y = l ok
return substr(" ", 11 - y + l) + s</
{{out}}
<pre>working...
Line 1,365:
=={{header|Seed7}}==
<
Line 1,415:
end if;
end for;
end func;</
{{out}}
<pre>
Line 1,423:
=={{header|Sidef}}==
Simple solution:
<
Generate such primes from digits (asymptotically faster):
<
upto = prev_prime(upto+1)
Line 1,451:
}
say primes_with_nondecreasing_digits(1000)</
{{out}}
<pre>
Line 1,459:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Imports System.Collections.Generic
Imports System.Console
Line 1,513:
Next
End Sub
End Module</
{{out}}
Same as C#.
Line 1,521:
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<
import "/seq" for Lst
import "/fmt" for Fmt
Line 1,542:
System.print("Primes below 1,000 with digits in non-decreasing order:")
for (chunk in Lst.chunks(nonDesc, 10)) Fmt.print("$3d", chunk)
System.print("\n%(nonDesc.count) such primes found.")</
{{out}}
Line 1,557:
=={{header|XPL0}}==
<
int N, I;
[if N <= 1 then return false;
Line 1,592:
Text(0, " primes found with nondecreasing digits below 1000.
");
]</
{{out}}
|