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

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.

Related

## ALGOL 68

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    ODEND`
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

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

` # syntax: GAWK -f DESCENDING_PRIMES.AWKBEGIN {    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#

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

Works with: Factor version 0.99 2021-06-02
`USING: grouping grouping.extras math math.combinatoricsmath.functions math.primes math.ranges prettyprint sequencessequences.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

Translation of: XPL0
`#include "isprime.bas"#include "sort.bas" Dim As Double t0 = TimerDim As Integer i, n, tmp, num, cantDim 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) = nNext i Sort(matriz()) cant = 0For 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 IfNext iPrint Using !"\n\nThere are & descending primes."; cantSleep`
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

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

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

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

`using Combinatoricsusing 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

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 trueend 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 primesend 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

`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

`#!/usr/bin/perl use strict; # https://rosettacode.org/wiki/Descending_primesuse 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

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

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

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

## Raku

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

 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 = 1000row = 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    oknext `

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

`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 = 10var 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

Library: Wren-perm
Library: Wren-math
Library: Wren-seq
Library: Wren-fmt
`import "./perm" for Powersetimport "./math" for Intimport "./seq" for Lstimport "./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

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