Primes with digits in nondecreasing order: Difference between revisions

{{trans|Nim}}

I a == 2

R 1B

print(‘#3’.format(n), end' I c % 10 == 0 {"\n"} E ‘ ’)

print()

{{out}}

=={{header|Action!}}==

{{libheader|Action! Sieve of Eratosthenes}}

BYTE FUNC NonDecreasingDigits(INT x)

OD

PrintF("%E%EThere are %I primes",count)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Primes_with_digits_in_nondecreasing_order.png Screenshot from Atari 8-bit computer]

=={{header|ALGOL 68}}==

{{libheader|ALGOL 68-primes}}

INT max number = 1000;

# sieve the primes to max number #

)

)

{{out}}

<pre>

=={{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

=={{header|Arturo}}==

nondecreasing?: function [n][

ds: digits n

loop split.every: 10 select primes => nondecreasing? 'a ->

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f PRIMES_WITH_DIGITS_IN_NONDECREASING_ORDER.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

=={{header|BASIC}}==

{{works with|QBasic}}

20 DIM P(1000)

30 P(0)=-1: P(1)=-1

80 N=A*100+B*10+C

90 IF P(N)=0 THEN PRINT N,

{{out}}

<pre> 2 3 5 7 11

==={{header|BASIC256}}===

if v < 2 then return False

if v mod 2 = 0 then return v = 2

next i

print chr(10); c; " such primes found."

==={{header|PureBasic}}===

If v <= 1 : ProcedureReturn #False

ElseIf v < 4 : ProcedureReturn #True

Next i

PrintN(#CRLF$ + Str(c) + " such primes found."): Input()

==={{header|Yabasic}}===

if v < 2 then return False : fi

if mod(v, 2) = 0 then return v = 2 : fi

next i

print chr$(10), c, " such primes found."

=={{header|BCPL}}==

let sieve(prime, max) be

$)

freevec(prime)

{{out}}

<pre> 2 3 5 7 11 13 17 19 23 29

=={{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 {

if (!flags[j]) { yield return j;

for (int k = sq, i = j << 1; k <= lim; k += i) flags[k] = true; }

{{out}}

<pre style="height:20em"> 11 111 11111 1111111

=={{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 ""

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

present prettyprint ;

lprimes [ present [ <= ] monotonic? ] lfilter

{{out}}

<pre style="height:14em">

=={{header|J}}==

{{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

for i as uinteger = 2 to 999

if isprime(i) andalso is_ndp(i) then print i;" ";

{{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]

{{out}}

<pre>

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

}

fmt.Printf("\n%d such primes found.\n", len(nonDesc))

{{out}}

See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.

# Input: an upper bound, or `infinite`

| select( (digits | (. == sort)) and is_prime);

{{out}} (abbreviated)

<pre>

{{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

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:

=={{header|Ksh}}==

#!/bin/ksh

done

printf "\n%d Primes with digits in nondecreasing order < %d\n" ${cnt} $MAXPRIME

{{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

=={{header|MAD}}==

BOOLEAN PRIME

DIMENSION PRIME(1000), COL(10)

TEST CONTINUE

VECTOR VALUES CFMT = $10(I4)*$

{{out}}

<pre> 2 3 5 7 11 13 17 19 23 29

449 457 467 479 499 557 569 577 599 677</pre>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Cases[Most@

NestWhileList[NextPrime,

2, # < 1000 &], _?(OrderedQ[IntegerDigits@#] &)],

{{out}}<pre>

=={{header|Nim}}==

func isPrime(n: Natural): bool =

echo &"Found {result.len} primes:"

for i, n in result:

{{out}}

=={{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 &lt; 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>

=={{header|Perl}}==

{{libheader|ntheory}}

use strict;

my @want = grep ! /(.)(.)(??{$1 > $2 ? '' : '(*FAIL)'})/, @{ primes(1000) };

{{out}}

<pre>

=={{header|Plain English}}==

Start up.

Loop.

If the number is not prime, say no.

If the number is not non-decreasing, say no.

{{out}}

<pre>

=={{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;

END;

CALL EXIT;

{{out}}

<pre>2 3 5 7 11 13 17 19 23 29

=={{header|Python}}==

from operator import le

if __name__ == '__main__':

main()

{{Out}}

<pre>50 matches for base 10:

=={{header|Raku}}==

for flat 2..10, 17, 27, 31 -> $base {

.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:

=={{header|REXX}}==

parse arg n cols . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 1000 /*Not specified? Then use the default.*/

end /*k*/ /* [↑] only process numbers ≤ √ J */

#= #+1; @.#= j; s.#= j*j /*bump # of Ps; assign next P; P²; P# */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

? "working..."

s = string(x) l = len(s)

if l > y y = l ok

{{out}}

<pre>working...

=={{header|Seed7}}==

end if;

end for;

{{out}}

<pre>

=={{header|Sidef}}==

Simple solution:

Generate such primes from digits (asymptotically faster):

upto = prev_prime(upto+1)

}

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Imports System.Collections.Generic

Imports System.Console

Next

End Sub

{{out}}

Same as C#.

{{libheader|Wren-seq}}

{{libheader|Wren-fmt}}

import "/seq" for Lst

import "/fmt" for Fmt

System.print("Primes below 1,000 with digits in non-decreasing order:")

for (chunk in Lst.chunks(nonDesc, 10)) Fmt.print("$3d", chunk)

{{out}}

=={{header|XPL0}}==

int N, I;

[if N <= 1 then return false;

Text(0, " primes found with nondecreasing digits below 1000.

");

{{out}}