I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Descending primes

From Rosetta Code
Task
Descending primes
You are encouraged to solve this task according to the task description, using any language you may know.

Generate and show all primes with strictly descending decimal digits.

See also
Related


ALGOL 68[edit]

Almost identical to the Ascending_primes Algol 68 sample.

Works with: ALGOL 68G version Any - tested with release 2.8.3.win32
Library: ALGOL 68-rows
BEGIN # find all primes with strictly decreasing digits                      #
PR read "primes.incl.a68" PR # include prime utilities #
PR read "rows.incl.a68" PR # include array utilities #
[ 1 : 512 ]INT primes; # there will be at most 512 (2^9) primes #
INT p count := 0; # number of primes found so far #
FOR d1 FROM 0 TO 1 DO
INT n1 = IF d1 = 1 THEN 9 ELSE 0 FI;
FOR d2 FROM 0 TO 1 DO
INT n2 = IF d2 = 1 THEN ( n1 * 10 ) + 8 ELSE n1 FI;
FOR d3 FROM 0 TO 1 DO
INT n3 = IF d3 = 1 THEN ( n2 * 10 ) + 7 ELSE n2 FI;
FOR d4 FROM 0 TO 1 DO
INT n4 = IF d4 = 1 THEN ( n3 * 10 ) + 6 ELSE n3 FI;
FOR d5 FROM 0 TO 1 DO
INT n5 = IF d5 = 1 THEN ( n4 * 10 ) + 5 ELSE n4 FI;
FOR d6 FROM 0 TO 1 DO
INT n6 = IF d6 = 1 THEN ( n5 * 10 ) + 4 ELSE n5 FI;
FOR d7 FROM 0 TO 1 DO
INT n7 = IF d7 = 1 THEN ( n6 * 10 ) + 3 ELSE n6 FI;
FOR d8 FROM 0 TO 1 DO
INT n8 = IF d8 = 1 THEN ( n7 * 10 ) + 2 ELSE n7 FI;
FOR d9 FROM 0 TO 1 DO
INT n9 = IF d9 = 1 THEN ( n8 * 10 ) + 1 ELSE n8 FI;
IF n9 > 0 THEN
IF is probably prime( n9 ) THEN
# have a prime with strictly descending digits #
primes[ p count +:= 1 ] := n9
FI
FI
OD
OD
OD
OD
OD
OD
OD
OD
OD;
QUICKSORT primes FROMELEMENT 1 TOELEMENT p count; # sort the primes #
# display the primes #
FOR i TO p count DO
print( ( " ", whole( primes[ i ], -8 ) ) );
IF i MOD 10 = 0 THEN print( ( newline ) ) FI
OD
END
Output:
         2         3         5         7        31        41        43        53        61        71
        73        83        97       421       431       521       541       631       641       643
       653       743       751       761       821       853       863       941       953       971
       983      5431      6421      6521      7321      7541      7621      7643      8431      8521
      8543      8641      8731      8741      8753      8761      9421      9431      9521      9631
      9643      9721      9743      9851      9871     75431     76421     76541     76543     86531
     87421     87541     87631     87641     87643     94321     96431     97651     98321     98543
     98621     98641     98731    764321    865321    876431    975421    986543    987541    987631
   8764321   8765321   9754321   9875321  97654321  98764321  98765431

Arturo[edit]

Translation of: ALGOL 68
descending: @[
loop 1..9 'a [
loop 1..dec a 'b [
loop 1..dec b 'c [
loop 1..dec c 'd [
loop 1..dec d 'e [
loop 1..dec e 'f [
loop 1..dec f 'g [
loop 1..dec g 'h [
loop 1..dec h 'i -> @[a b c d e f g h i]
@[a b c d e f g h]]
@[a b c d e f g]]
@[a b c d e f]]
@[a b c d e]]
@[a b c d]]
@[a b c]]
@[a b]]
@[a]]
]
 
descending: filter descending 'd -> some? d 'n [not? positive? n]
descending: filter descending 'd -> d <> unique d
descending: sort map descending 'd -> to :integer join to [:string] d
 
loop split.every:10 select descending => prime? 'row [
print map to [:string] row 'item -> pad item 8
]
Output:
       2        3        5        7       31       41       43       53       61       71 
      73       83       97      421      431      521      541      631      641      643 
     653      743      751      761      821      853      863      941      953      971 
     983     5431     6421     6521     7321     7541     7621     7643     8431     8521 
    8543     8641     8731     8741     8753     8761     9421     9431     9521     9631 
    9643     9721     9743     9851     9871    75431    76421    76541    76543    86531 
   87421    87541    87631    87641    87643    94321    96431    97651    98321    98543 
   98621    98641    98731   764321   865321   876431   975421   986543   987541   987631 
 8764321  8765321  9754321  9875321 97654321 98764321 98765431

AWK[edit]

 
# syntax: GAWK -f DESCENDING_PRIMES.AWK
BEGIN {
start = 1
stop = 99999999
for (i=start; i<=stop; i++) {
leng = length(i)
flag = 1
for (j=1; j<leng; j++) {
if (substr(i,j,1) <= substr(i,j+1,1)) {
flag = 0
break
}
}
if (flag) {
if (is_prime(i)) {
printf("%9d%1s",i,++count%10?"":"\n")
}
}
}
printf("\n%d-%d: %d descending primes\n",start,stop,count)
exit(0)
}
function is_prime(n, d) {
d = 5
if (n < 2) { return(0) }
if (n % 2 == 0) { return(n == 2) }
if (n % 3 == 0) { return(n == 3) }
while (d*d <= n) {
if (n % d == 0) { return(0) }
d += 2
if (n % d == 0) { return(0) }
d += 4
}
return(1)
}
 
Output:
        2         3         5         7        31        41        43        53        61        71
       73        83        97       421       431       521       541       631       641       643
      653       743       751       761       821       853       863       941       953       971
      983      5431      6421      6521      7321      7541      7621      7643      8431      8521
     8543      8641      8731      8741      8753      8761      9421      9431      9521      9631
     9643      9721      9743      9851      9871     75431     76421     76541     76543     86531
    87421     87541     87631     87641     87643     94321     96431     97651     98321     98543
    98621     98641     98731    764321    865321    876431    975421    986543    987541    987631
  8764321   8765321   9754321   9875321  97654321  98764321  98765431
1-99999999: 87 descending primes

F#[edit]

This task uses Extensible Prime Generator (F#)

 
// Descending primes. Nigel Galloway: April 19th., 2022
[2;3;5;7]::List.unfold(fun(n,i)->match n with []->None |_->let n=n|>List.map(fun(n,g)->[for n in n..9->(n+1,i*n+g)])|>List.concat in Some(n|>List.choose(fun(_,n)->if isPrime n then Some n else None),(n|>List.filter(fst>>(>)10),i*10)))([(4,3);(2,1);(8,7)],10)
|>List.concat|>List.sort|>List.iter(printf "%d "); printfn ""
 
Output:
2 3 5 7 31 41 43 53 61 71 73 83 97 421 431 521 541 631 641 643 653 743 751 761 821 853 863 941 953 971 983 5431 6421 6521 7321 7541 7621 7643 8431 8521 8543 8641 8731 8741 8753 8761 9421 9431 9521 9631 9643 9721 9743 9851 9871 75431 76421 76541 76543 86531 87421 87541 87631 87641 87643 94321 96431 97651 98321 98543 98621 98641 98731 764321 865321 876431 975421 986543 987541 987631 8764321 8765321 9754321 9875321 97654321 98764321 98765431

Factor[edit]

Works with: Factor version 0.99 2021-06-02
USING: grouping grouping.extras math math.combinatorics
math.functions math.primes math.ranges prettyprint sequences
sequences.extras ;
 
9 1 [a,b] all-subsets [ reverse 0 [ 10^ * + ] reduce-index ]
[ prime? ] map-filter 10 "" pad-groups 10 group simple-table.
Output:
7       5       3       2       97       83       73       71     61     53
43      41      31      983     971      953      941      863    853    821
761     751     743     653     643      641      631      541    521    431
421     9871    9851    9743    9721     9643     9631     9521   9431   9421
8761    8753    8741    8731    8641     8543     8521     8431   7643   7621
7541    7321    6521    6421    5431     98731    98641    98621  98543  98321
97651   96431   94321   87643   87641    87631    87541    87421  86531  76543
76541   76421   75431   987631  987541   986543   975421   876431 865321 764321
9875321 9754321 8765321 8764321 98765431 98764321 97654321               


FreeBASIC[edit]

Translation of: XPL0
#include "isprime.bas"
#include "sort.bas"
 
Dim As Double t0 = Timer
Dim As Integer i, n, tmp, num, cant
Dim Shared As Integer matriz(512)
For i = 0 To 511
n = 0
tmp = i
num = 9
While tmp
If tmp And 1 Then n = n * 10 + num
tmp = tmp Shr 1
num -= 1
Wend
matriz(i) = n
Next i
 
Sort(matriz())
 
cant = 0
For i = 1 To Ubound(matriz)-1
n = matriz(i)
If IsPrime(n) Then
Print Using "#########"; n;
cant += 1
If cant Mod 10 = 0 Then Print
End If
Next i
Print Using !"\n\nThere are & descending primes."; cant
Sleep
Output:
        2        3        5        7       31       41       43       53       61       71
       73       83       97      421      431      521      541      631      641      643
      653      743      751      761      821      853      863      941      953      971
      983     5431     6421     6521     7321     7541     7621     7643     8431     8521
     8543     8641     8731     8741     8753     8761     9421     9431     9521     9631
     9643     9721     9743     9851     9871    75431    76421    76541    76543    86531
    87421    87541    87631    87641    87643    94321    96431    97651    98321    98543
    98621    98641    98731   764321   865321   876431   975421   986543   987541   987631
  8764321  8765321  9754321  9875321 97654321 98764321 98765431

There are 87 descending primes.

Forth[edit]

Tested on vfxforth and GForth.

: is-prime?   \ n -- f ;    \ Fast enough for this application 
DUP 1 AND IF \ n is odd
DUP 3 DO
DUP I DUP * < IF DROP -1 LEAVE THEN \ Leave loop if I**2 > n
DUP I MOD 0= IF DROP 0 LEAVE THEN \ Leave loop if n%I is zero
2 +LOOP \ iterate over odd I only
ELSE \ n is even
2 = \ Returns true if n == 2.
THEN ;
 
: 1digit \ -- ; \ Select and print one digit numbers which are prime
10 2 ?DO
I is-prime? IF I 9 .r THEN
LOOP ;
 
: 2digit \ n-bfwd digit -- ;
\ Generate and print primes where least significant digit < digit
\ n-bfwd is the base number bought foward from calls to `digits` below.
SWAP 10 * SWAP 1 ?DO
DUP I + is-prime? IF DUP I + 9 .r THEN
2 I 3 = 2* - +LOOP DROP ; \ This generates the I sequence 1 3 7 9
 
: digits \ #digits n-bfwd max-digit -- ;
\ Print descendimg primes with #digits digits.
2 PICK 9 > IF ." #digits must be less than 10." 2DROP DROP EXIT THEN
2 PICK 1 = IF 2DROP DROP 1digit EXIT THEN \ One digit is special simple case
2 PICK 2 = IF \ Two digit special and
SWAP 10 * SWAP 2 DO \ I is 2 .. max-digit-1
DUP I + I 2digit
LOOP 2DROP
ELSE
SWAP 10 * SWAP 2 PICK ?DO \ I is #digits .. max-digit-1
DUP I + 2 PICK 1- SWAP I RECURSE \ Recurse with #digits reduced by 1.
LOOP 2DROP
THEN ;
 
: descending-primes
\ Print the descending primes. Call digits with increasing #digits
CR 9 1 DO I 0 10 digits LOOP ;
descending-primes 
        2        3        5        7       31       41       43       53       61       71       
       73       83       97      421      431      521      541      631      641      643
      653      743      751      761      821      853      863      941      953      971
      983     5431     6421     6521     7321     7541     7621     7643     8431     8521
     8543     8641     8731     8741     8753     8761     9421     9431     9521     9631
     9643     9721     9743     9851     9871    75431    76421    76541    76543    86531
    87421    87541    87631    87641    87643    94321    96431    97651    98321    98543
    98621    98641    98731   764321   865321   876431   975421   986543   987541   987631
  8764321  8765321  9754321  9875321 97654321 98764321 98765431 ok

Go[edit]

Translation of: Wren
Library: Go-rcu
package main
 
import (
"fmt"
"rcu"
"sort"
"strconv"
)
 
func combinations(a []int, k int) [][]int {
n := len(a)
c := make([]int, k)
var combs [][]int
var combine func(start, end, index int)
combine = func(start, end, index int) {
if index == k {
t := make([]int, len(c))
copy(t, c)
combs = append(combs, t)
return
}
for i := start; i <= end && end-i+1 >= k-index; i++ {
c[index] = a[i]
combine(i+1, end, index+1)
}
}
combine(0, n-1, 0)
return combs
}
 
func powerset(a []int) (res [][]int) {
if len(a) == 0 {
return
}
for i := 1; i <= len(a); i++ {
res = append(res, combinations(a, i)...)
}
return
}
 
func main() {
ps := powerset([]int{9, 8, 7, 6, 5, 4, 3, 2, 1})
var descPrimes []int
for i := 1; i < len(ps); i++ {
s := ""
for _, e := range ps[i] {
s += string(e + '0')
}
p, _ := strconv.Atoi(s)
if rcu.IsPrime(p) {
descPrimes = append(descPrimes, p)
}
}
sort.Ints(descPrimes)
fmt.Println("There are", len(descPrimes), "descending primes, namely:")
for i := 0; i < len(descPrimes); i++ {
fmt.Printf("%8d ", descPrimes[i])
if (i+1)%10 == 0 {
fmt.Println()
}
}
fmt.Println()
}
Output:
There are 87 descending primes, namely:
       2        3        5        7       31       41       43       53       61       71 
      73       83       97      421      431      521      541      631      641      643 
     653      743      751      761      821      853      863      941      953      971 
     983     5431     6421     6521     7321     7541     7621     7643     8431     8521 
    8543     8641     8731     8741     8753     8761     9421     9431     9521     9631 
    9643     9721     9743     9851     9871    75431    76421    76541    76543    86531 
   87421    87541    87631    87641    87643    94321    96431    97651    98321    98543 
   98621    98641    98731   764321   865321   876431   975421   986543   987541   987631 
 8764321  8765321  9754321  9875321 97654321 98764321 98765431 

J[edit]

Compare with Ascending primes (focusing on the computational details, rather than the presentation).

   extend=: {{ y;y,L:0(1+each i.1-{:y)}}
($~ q:@$)(#~ 1 p: ])10#.&>([:[email protected];extend each)^:# >:i.9
2 3 31 43 41 431 421 5 53 541 521 5431 61 653 643 641 631 6521 6421 7 73 71 761 751 743 7643 7621 7541 7321
76543 76541 76421 75431 764321 83 863 853 821 8761 8753 8741 8731 8641 8543 8521 8431 87643 87641 87631 87541 87421 86531 876431 865321 8765321 8764321 97 983
971 953 941 9871 9851 9743 9721 9643 9631 9521 9431 9421 98731 98641 98621 98543 98321 97651 96431 94321 987631 987541 986543 975421 9875321 9754321 98765431 98764321 97654321

Julia[edit]

using Combinatorics
using Primes
 
function descendingprimes()
return sort!(filter(isprime, [evalpoly(10, x)
for x in powerset([1, 2, 3, 4, 5, 6, 7, 8, 9]) if !isempty(x)]))
end
 
foreach(p -> print(rpad(p[2], 10), p[1] % 10 == 0 ? "\n" : ""), enumerate(descendingprimes()))
 
Output:
2         3         5         7         31        41        43        53        61        71
73        83        97        421       431       521       541       631       641       643
653       743       751       761       821       853       863       941       953       971
983       5431      6421      6521      7321      7541      7621      7643      8431      8521
8543      8641      8731      8741      8753      8761      9421      9431      9521      9631
9643      9721      9743      9851      9871      75431     76421     76541     76543     86531
87421     87541     87631     87641     87643     94321     96431     97651     98321     98543
98621     98641     98731     764321    865321    876431    975421    986543    987541    987631
8764321   8765321   9754321   9875321   97654321  98764321  98765431

Lua[edit]

Identical to Ascending_primes#Lua except for the order of digits list.

local function is_prime(n)
if n < 2 then return false end
if n % 2 == 0 then return n==2 end
if n % 3 == 0 then return n==3 end
for f = 5, n^0.5, 6 do
if n%f==0 or n%(f+2)==0 then return false end
end
return true
end
 
local function descending_primes()
local digits, candidates, primes = {9,8,7,6,5,4,3,2,1}, {0}, {}
for i = 1, #digits do
for j = 1, #candidates do
local value = candidates[j] * 10 + digits[i]
if is_prime(value) then primes[#primes+1] = value end
candidates[#candidates+1] = value
end
end
table.sort(primes)
return primes
end
 
print(table.concat(descending_primes(), ", "))
Output:
2, 3, 5, 7, 31, 41, 43, 53, 61, 71, 73, 83, 97, 421, 431, 521, 541, 631, 641, 643, 653, 743, 751, 761, 821, 853, 863, 941, 953, 971, 983, 5431, 6421, 6521, 7321, 7541, 7621, 7643, 8431, 8521, 8543, 8641, 8731, 8741, 8753, 8761, 9421, 9431, 9521, 9631, 9643, 9721, 9743, 9851, 9871, 75431, 76421, 76541, 76543, 86531, 87421, 87541, 87631, 87641, 87643, 94321, 96431, 97651, 98321, 98543, 98621, 98641, 98731, 764321, 865321, 876431, 975421, 986543, 987541, 987631, 8764321, 8765321, 9754321, 9875321, 97654321, 98764321, 98765431

Mathematica/Wolfram Language[edit]

Sort[Select[FromDigits/@Subsets[Range[9,1,-1],{1,\[Infinity]}],PrimeQ]]
Output:
{2, 3, 5, 7, 31, 41, 43, 53, 61, 71, 73, 83, 97, 421, 431, 521, 541, 631, 641, 643, 653, 743, 751, 761, 821, 853, 863, 941, 953, 971, 983, 5431, 6421, 6521, 7321, 7541, 7621, 7643, 8431, 8521, 8543, 8641, 8731, 8741, 8753, 8761, 9421, 9431, 9521, 9631, 9643, 9721, 9743, 9851, 9871, 75431, 76421, 76541, 76543, 86531, 87421, 87541, 87631, 87641, 87643, 94321, 96431, 97651, 98321, 98543, 98621, 98641, 98731, 764321, 865321, 876431, 975421, 986543, 987541, 987631, 8764321, 8765321, 9754321, 9875321, 97654321, 98764321, 98765431}

Perl[edit]

#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Descending_primes
use warnings;
use ntheory qw( is_prime );
 
print join('', sort map { sprintf "%9d", $_ } grep /./ && is_prime($_),
glob join '', map "{$_,}", reverse 1 .. 9) =~ s/.{45}\K/\n/gr;
Output:
        2        3        5        7       31
       41       43       53       61       71
       73       83       97      421      431
      521      541      631      641      643
      653      743      751      761      821
      853      863      941      953      971
      983     5431     6421     6521     7321
     7541     7621     7643     8431     8521
     8543     8641     8731     8741     8753
     8761     9421     9431     9521     9631
     9643     9721     9743     9851     9871
    75431    76421    76541    76543    86531
    87421    87541    87631    87641    87643
    94321    96431    97651    98321    98543
    98621    98641    98731   764321   865321
   876431   975421   986543   987541   987631
  8764321  8765321  9754321  9875321 97654321
 98764321 98765431

Phix[edit]

with javascript_semantics
function descending_primes(sequence res, atom p=0, max_digit=9)
    for d=1 to max_digit do
        atom np = p*10+d
        if odd(d) and is_prime(np) then res &= np end if
        res = descending_primes(res,np,d-1)
    end for
    return res
end function
 
sequence r = sort(descending_primes({2})),
--sequence r = descending_primes({2}),
         j = join_by(r,1,11," ","\n","%8d")
printf(1,"There are %,d descending primes:\n%s\n",{length(r),j})
Output:
There are 87 descending primes:
       2        3        5        7       31       41       43       53       61       71       73
      83       97      421      431      521      541      631      641      643      653      743
     751      761      821      853      863      941      953      971      983     5431     6421
    6521     7321     7541     7621     7643     8431     8521     8543     8641     8731     8741
    8753     8761     9421     9431     9521     9631     9643     9721     9743     9851     9871
   75431    76421    76541    76543    86531    87421    87541    87631    87641    87643    94321
   96431    97651    98321    98543    98621    98641    98731   764321   865321   876431   975421
  986543   987541   987631  8764321  8765321  9754321  9875321 97654321 98764321 98765431

Unsorted, ie in the order in which they are generated:

There are 87 descending primes:
       2        3       31       41      421       43      431        5      521       53      541
    5431       61      631      641     6421      643     6521      653        7       71       73
    7321      743      751     7541    75431      761     7621    76421     7643   764321    76541
   76543      821       83     8431     8521      853     8543      863     8641    86531   865321
    8731     8741    87421     8753    87541     8761    87631    87641    87643   876431  8764321
 8765321      941     9421     9431    94321     9521      953     9631     9643    96431       97
     971     9721     9743   975421  9754321    97651 97654321      983    98321     9851    98543
   98621    98641   986543     9871    98731  9875321   987541   987631 98764321 98765431

powerset[edit]

with javascript_semantics
function descending_primes()
    sequence powerset = tagset(9), 
             res = {}
    while length(powerset) do
        res &= filter(powerset,is_prime)
        sequence next = {}
        for i=1 to length(powerset) do
            for d=1 to remainder(powerset[i],10)-1 do
                next &= powerset[i]*10+d
            end for
        end for
        powerset = next
    end while
    return res
end function
 
sequence r = descending_primes(),
         j = join_by(r,1,11," ","\n","%8d")
printf(1,"There are %,d descending primes:\n%s\n",{length(r),j})

Output same as the sorted output above, without requiring a sort.

Picat[edit]

import util.
 
main =>
DP = [N : S in power_set("987654321"), S != [], N = S.to_int, prime(N)].sort,
foreach({P,I} in zip(DP,1..DP.len))
printf("%9d%s",P,cond(I mod 10 == 0,"\n",""))
end,
nl,
println(len=DP.len).
Output:
        2        3        5        7       31       41       43       53       61       71
       73       83       97      421      431      521      541      631      641      643
      653      743      751      761      821      853      863      941      953      971
      983     5431     6421     6521     7321     7541     7621     7643     8431     8521
     8543     8641     8731     8741     8753     8761     9421     9431     9521     9631
     9643     9721     9743     9851     9871    75431    76421    76541    76543    86531
    87421    87541    87631    87641    87643    94321    96431    97651    98321    98543
    98621    98641    98731   764321   865321   876431   975421   986543   987541   987631
  8764321  8765321  9754321  9875321 97654321 98764321 98765431
len = 87

Python[edit]

from sympy import isprime
 
def descending(xs=range(10)):
for x in xs:
yield x
yield from descending(x*10 + d for d in range(x%10))
 
for i, p in enumerate(sorted(filter(isprime, descending()))):
print(f'{p:9d}', end=' ' if (1 + i)%8 else '\n')
 
print()
Output:
        2         3         5         7        31        41        43        53
       61        71        73        83        97       421       431       521
      541       631       641       643       653       743       751       761
      821       853       863       941       953       971       983      5431
     6421      6521      7321      7541      7621      7643      8431      8521
     8543      8641      8731      8741      8753      8761      9421      9431
     9521      9631      9643      9721      9743      9851      9871     75431
    76421     76541     76543     86531     87421     87541     87631     87641
    87643     94321     96431     97651     98321     98543     98621     98641
    98731    764321    865321    876431    975421    986543    987541    987631
  8764321   8765321   9754321   9875321  97654321  98764321  98765431


Raku[edit]

Trivial variation of Ascending primes task.

put (flat 2, 3, 5, 7, sort +*, gather (3..9).map: &recurse ).batch(10)».fmt("%8d").join: "\n";
 
sub recurse ($str) {
.take for ($str X~ (1, 3, 7)).grep: { .is-prime && [>] .comb };
recurse $str × 10 + $_ for 2 ..^ $str % 10;
}
Output:
       2        3        5        7       31       41       43       53       61       71
      73       83       97      421      431      521      541      631      641      643
     653      743      751      761      821      853      863      941      953      971
     983     5431     6421     6521     7321     7541     7621     7643     8431     8521
    8543     8641     8731     8741     8753     8761     9421     9431     9521     9631
    9643     9721     9743     9851     9871    75431    76421    76541    76543    86531
   87421    87541    87631    87641    87643    94321    96431    97651    98321    98543
   98621    98641    98731   764321   865321   876431   975421   986543   987541   987631
 8764321  8765321  9754321  9875321 97654321 98764321 98765431

Ring[edit]

This example is incorrect. Please fix the code and remove this message.
Details:
Many of the numbers shown do not have strictly descending digits, e.g. all the ones starting with 2 (except 2 itself).
Largest is much larger than 1000.
 
load "stdlibcore.ring"
 
limit = 1000
row = 0
 
for n = 1 to limit
flag = 0
strn = string(n)
if isprime(n) = 1
for m = 1 to len(strn)-1
if number(substr(strn,m)) < number(substr(strn,m+1))
flag = 1
ok
next
if flag = 1
row++
see "" + n + " "
ok
if row % 10 = 0
see nl
ok
ok
next
 

Output:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997

Sidef[edit]

func primes_with_descending_digits(base = 10) {
 
var list = []
var digits = @(1..^base)
 
var end_digits = digits.grep { .is_coprime(base) }
list << digits.grep { .is_prime && !.is_coprime(base) }...
 
for k in (0 .. digits.end) {
digits.combinations(k, {|*a|
var v = a.digits2num(base)
end_digits.each {|d|
var n = (v*base + d)
next if ((n >= base) && (a[0] <= d))
list << n if n.is_prime
}
})
}
 
list.sort
}
 
var base = 10
var arr = primes_with_descending_digits(base)
 
say "There are #{arr.len} descending primes in base #{base}.\n"
 
arr.each_slice(8, {|*a|
say a.map { '%9s' % _ }.join(' ')
})
Output:
There are 87 descending primes in base 10.

        2         3         5         7        31        41        43        53
       61        71        73        83        97       421       431       521
      541       631       641       643       653       743       751       761
      821       853       863       941       953       971       983      5431
     6421      6521      7321      7541      7621      7643      8431      8521
     8543      8641      8731      8741      8753      8761      9421      9431
     9521      9631      9643      9721      9743      9851      9871     75431
    76421     76541     76543     86531     87421     87541     87631     87641
    87643     94321     96431     97651     98321     98543     98621     98641
    98731    764321    865321    876431    975421    986543    987541    987631
  8764321   8765321   9754321   9875321  97654321  98764321  98765431

Wren[edit]

Library: Wren-perm
Library: Wren-math
Library: Wren-seq
Library: Wren-fmt
import "./perm" for Powerset
import "./math" for Int
import "./seq" for Lst
import "./fmt" for Fmt
 
var ps = Powerset.list((9..1).toList)
var descPrimes = ps.skip(1).map { |s| Num.fromString(s.join()) }
.where { |p| Int.isPrime(p) }
.toList
.sort()
System.print("There are %(descPrimes.count) descending primes, namely:")
for (chunk in Lst.chunks(descPrimes, 10)) Fmt.print("$8s", chunk)
Output:
There are 87 descending primes, namely:
       2        3        5        7       31       41       43       53       61       71
      73       83       97      421      431      521      541      631      641      643
     653      743      751      761      821      853      863      941      953      971
     983     5431     6421     6521     7321     7541     7621     7643     8431     8521
    8543     8641     8731     8741     8753     8761     9421     9431     9521     9631
    9643     9721     9743     9851     9871    75431    76421    76541    76543    86531
   87421    87541    87631    87641    87643    94321    96431    97651    98321    98543
   98621    98641    98731   764321   865321   876431   975421   986543   987541   987631
 8764321  8765321  9754321  9875321 97654321 98764321 98765431

XPL0[edit]

include xpllib;         \provides IsPrime and Sort
 
int I, N, Mask, Digit, A(512), Cnt;
[for I:= 0 to 511 do
[N:= 0; Mask:= I; Digit:= 9;
while Mask do
[if Mask&1 then
N:= N*10 + Digit;
Mask:= Mask>>1;
Digit:= Digit-1;
];
A(I):= N;
];
Sort(A, 512);
Cnt:= 0;
Format(9, 0);
for I:= 1 to 511 do \skip empty set
[N:= A(I);
if IsPrime(N) then
[RlOut(0, float(N));
Cnt:= Cnt+1;
if rem(Cnt/10) = 0 then CrLf(0);
];
];
]
Output:
        2        3        5        7       31       41       43       53       61       71
       73       83       97      421      431      521      541      631      641      643
      653      743      751      761      821      853      863      941      953      971
      983     5431     6421     6521     7321     7541     7621     7643     8431     8521
     8543     8641     8731     8741     8753     8761     9421     9431     9521     9631
     9643     9721     9743     9851     9871    75431    76421    76541    76543    86531
    87421    87541    87631    87641    87643    94321    96431    97651    98321    98543
    98621    98641    98731   764321   865321   876431   975421   986543   987541   987631
  8764321  8765321  9754321  9875321 97654321 98764321 98765431