# Descending primes

(Redirected from DescendingPrimes)
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

## 11l

Translation of: C#
```F is_prime(p)
I p < 2 | p % 2 == 0
R p == 2
L(i) (3 .. Int(sqrt(p))).step(2)
I p % i == 0
R 0B
R 1B

V c = 0
V ps = [1, 2, 3, 4, 5, 6, 7, 8, 9]
V nxt = [0] * 128

L
V nc = 0
L(a) ps
I is_prime(a)
c++
print(‘#8’.format(a), end' I c % 5 == 0 {"\n"} E ‘ ’)
V b = a * 10
V l = a % 10 + b
b++
L b < l
nxt[nc] = b
nc++
b++

I nc > 1
ps = nxt[0 .< nc]
E
L.break

print("\n"c‘ descending primes found’)```
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
87 descending primes found
```

Alternative solution:

```F is_prime(p)
I p < 2 | p % 2 == 0
R p == 2
L(i) (3 .. Int(sqrt(p))).step(2)
I p % i == 0
R 0B
R 1B

[Int] descending_primes

L(n) 1 .< 2 ^ 9
V s = ‘’
L(i) (8 .. 0).step(-1)
I n [&] (1 << i) != 0
s ‘’= String(i + 1)
I is_prime(Int(s))
descending_primes.append(Int(s))

L(n) sorted(descending_primes)
print(‘#8’.format(n), end' I (L.index + 1) % 5 == 0 {"\n"} E ‘ ’)

print("\n"descending_primes.len‘ descending primes found’)```

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

## ALGOL W

Translation of: Lua

...and only a few characters different from the Algol W Ascending primes sample.

```begin % find all primes with strictly descending digits - translation of Lua %

% quicksorts v, the bounds of v must be specified in lb and ub           %
procedure quicksort ( integer array v( * )
; integer value lb, ub
) ;
if ub > lb then begin
% more than one element, so must sort %
integer left, right, pivot;
left   := lb;
right  := ub;
% choosing the middle element of the array as the pivot %
pivot  := v( left + ( ( right + 1 ) - left ) div 2 );
while begin
while left  <= ub and v( left  ) < pivot do left  := left  + 1;
while right >= lb and v( right ) > pivot do right := right - 1;
left <= right
end do begin
integer swap;
swap       := v( left  );
v( left  ) := v( right );
v( right ) := swap;
left       := left  + 1;
right      := right - 1
end while_left_le_right ;
quicksort( v, lb,   right );
quicksort( v, left, ub    )
end quicksort ;

% returns true if n is prime, false otherwise                            %
logical procedure is_prime( integer value n ) ;
if      n  <  2     then false
else if n rem 2 = 0 then n = 2
else if n rem 3 = 0 then n = 3
else begin
logical prime; prime := true;
for f := 5 step 6 until entier( sqrt( n ) ) do begin
if n rem f = 0 or n rem ( f + 2 ) = 0 then begin
prime := false;
goto done
end if_n_rem_f_eq_0_or_n_rem_f_plus_2_eq_0
end for_f;
done:       prime
end is_prime ;

% increments n and also returns its new value                            %
integer procedure inc ( integer value result n ) ; begin n := n + 1; n end;

% sets primes to the list of descending primes and lenPrimes to the      %
% number of descending primes - primes must be big enough, e.g. have 511 %
% elements                                                               %
procedure descending_primes ( integer array primes ( * )
; integer result lenPrimes
) ;
begin
integer array digits     ( 1 ::    9 );
integer array candidates ( 1 :: 6000 );
integer lenCandidates;
candidates( 1 ) := 0;
lenCandidates   := 1;
lenPrimes       := 0;
for i := 1 until 9 do digits( i ) := 10 - i;
for i := 1 until 9 do begin
for j := 1 until lenCandidates do begin
integer cValue; cValue := candidates( j ) * 10 + digits( i );
if is_prime( cValue ) then primes( inc( lenPrimes ) ) := cValue;
candidates( inc( lenCandidates ) ) := cValue
end for_j
end for_i ;
quickSort( primes, 1, lenPrimes );
end descending_primes ;

begin % find the descending primes and print them                        %
integer array primes ( 1 :: 512 );
integer lenPrimes;
descending_primes( primes, lenPrimes );
for i := 1 until lenPrimes do begin
writeon( i_w := 8, s_w := 0, " ", primes( i ) );
if i rem 10 = 0 then write()
end for_i
end
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

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

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

## C

Translation of: C#
```#include <stdio.h>

int ispr(unsigned int n) {
if ((n & 1) == 0 || n < 2) return n == 2;
for (unsigned int j = 3; j * j <= n; j += 2)
if (n % j == 0) return 0; return 1; }

int main() {
unsigned int c = 0, nc, pc = 9, i, a, b, l,
ps[128], nxt[128];
for (a = 0, b = 1; a < pc; a = b++) ps[a] = b;
while (1) {
nc = 0;
for (i = 0; i < pc; i++) {
if (ispr(a = ps[i]))
printf("%8d%s", a, ++c % 5 == 0 ? "\n" : " ");
for (b = a * 10, l = a % 10 + b++; b < l; b++)
nxt[nc++] = b;
}
if (nc > 1) for(i = 0, pc = nc; i < pc; i++) ps[i] = nxt[i];
else break;
}
printf("\n%d descending primes found", c);
}
```
Output:

Same as C#

## C#

This task can be accomplished without using nine nested loops, without external libraries, without dynamic arrays, without sorting, without string operations and without signed integers.

```using System;

class Program {

static bool ispr(uint n) {
if ((n & 1) == 0 || n < 2) return n == 2;
for (uint j = 3; j * j <= n; j += 2)
if (n % j == 0) return false; return true; }

static void Main(string[] args) {
uint c = 0; int nc;
var ps = new uint[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var nxt = new uint[128];
while (true) {
nc = 0;
foreach (var a in ps) {
if (ispr(a))
Console.Write("{0,8}{1}", a, ++c % 5 == 0 ? "\n" : " ");
for (uint b = a * 10, l = a % 10 + b++; b < l; b++)
nxt[nc++] = b;
}
if (nc > 1) {
Array.Resize (ref ps, nc); Array.Copy(nxt, ps, nc); }
else break;
}
Console.WriteLine("\n{0} descending primes found", c);
}
}
```
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
87 descending primes found```

## C++

Translation of: C#
```#include <iostream>

bool ispr(unsigned int n) {
if ((n & 1) == 0 || n < 2) return n == 2;
for (unsigned int j = 3; j * j <= n; j += 2)
if (n % j == 0) return false; return true; }

int main() {
unsigned int c = 0, nc, pc = 9, i, a, b, l,
ps[128]{ 1, 2, 3, 4, 5, 6, 7, 8, 9 }, nxt[128];
while (true) {
nc = 0;
for (i = 0; i < pc; i++) {
if (ispr(a = ps[i]))
printf("%8d%s", a, ++c % 5 == 0 ? "\n" : " ");
for (b = a * 10, l = a % 10 + b++; b < l; b++)
nxt[nc++] = b;
}
if (nc > 1) for(i = 0, pc = nc; i < pc; i++) ps[i] = nxt[i];
else break;
}
printf("\n%d descending primes found", c);
}
```
Output:

Same as C#

## Delphi

Works with: Delphi version 6.0

```type TProgress = procedure(Percent: integer);

function IsPrime(N: integer): boolean;
{Optimised prime test - about 40% faster than the naive approach}
var I,Stop: integer;
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));
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;

function IsDescending(N: integer): boolean;
{Determine if each digit is less than previous, left to right}
var S: string;
var I: integer;
begin
Result:=False;
S:=IntToStr(N);
for I:=1 to Length(S)-1 do
if S[I]<=S[I+1] then exit;
Result:=True;
end;

procedure ShowDescendingPrimes(Memo: TMemo; Prog: TProgress);
{Write Descending primes up to 123,456,789 }
{The Optional progress }
var I,Cnt: integer;
var S: string;
const Max = 123456789;
begin
if Assigned(Prog) then Prog(0);
S:='';
Cnt:=0;
for I:=2 to Max do
begin
if ((I mod 1000000)=0) and Assigned(Prog) then Prog(Trunc(100*(I/Max)));
if IsDescending(I) and IsPrime(I) then
begin
S:=S+Format('%12.0n', [I*1.0]);
Inc(Cnt);
if (Cnt mod 8)=0 then
begin
S:='';
end;
end;
end;
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       5,431
6,421       6,521       7,321       7,541       7,621       7,643       8,431       8,521
8,543       8,641       8,731       8,741       8,753       8,761       9,421       9,431
9,521       9,631       9,643       9,721       9,743       9,851       9,871      75,431
76,421      76,541      76,543      86,531      87,421      87,541      87,631      87,641
87,643      94,321      96,431      97,651      98,321      98,543      98,621      98,641
98,731     764,321     865,321     876,431     975,421     986,543     987,541     987,631
8,764,321   8,765,321   9,754,321   9,875,321  97,654,321  98,764,321  98,765,431
Descending Primes Found: 87
```

## EasyLang

```func isprim num .
if num < 2
return 0
.
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
proc nextdesc n . .
if isprim n = 1
write n & " "
.
if n > 987654321
return
.
for d = n mod 10 - 1 downto 1
nextdesc n * 10 + d
.
.
for i = 9 downto 1
nextdesc i
.```

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

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

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

## FutureBasic

```local fn IsPrime( n as NSUInteger ) as BOOL
BOOL       isPrime = YES
NSUInteger i

if n < 2        then exit fn = NO
if n = 2        then exit fn = YES
if n mod 2 == 0 then exit fn = NO
for i = 3 to int(n^.5) step 2
if n mod i == 0 then exit fn = NO
next
end fn = isPrime

void local fn DesecendingPrimes( limit as long )
long i, n, mask, num, count = 0

for i = 0 to limit -1
n = 0 : mask = i : num = 9
if mask & 1 then n = n * 10 + num
num--
wend
mda(i) = n
next

mda_sort @"compare:"

for i = 1 to mda_count (0) - 1
n = mda_integer(i)
if ( fn IsPrime( n ) )
printf @"%10ld\b", n
count++
if count mod 10 == 0 then print
end if
next
printf @"\n\n\tThere are %ld descending primes.", count
end fn

window 1, @"Desecending Primes", ( 0, 0, 780, 230 )
print

CFTimeInterval t
t = fn CACurrentMediaTime
fn DesecendingPrimes( 512 )
printf @"\n\tCompute time: %.3f ms\n",(fn CACurrentMediaTime-t)*1000

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

Compute time: 8.976 ms
```

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

```   NB. increase maximum output line length
9!:37 (512) 1} 9!:36 ''

(#~ 1&p:) (#: }. i. 512) 10&#.@# >: i. _9
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
```

## Java

```import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class DescendingPrimes {

public static void main(String[] aArgs) {
for ( int i = 0; i < 512; i++ ) {
int number = 0;
int temp = i;
int digit = 9;
while ( temp > 0 ) {
if ( temp % 2 == 1 ) {
number = number * 10 + digit;
}
temp >>= 1;
digit -= 1;
}
}

int count = 0;
for ( int number : allNumbersStrictlyDescendingDigits ) {
if ( isPrime(number) ) {
System.out.print(String.format("%9d%s", number, ( ++count % 10 == 0 ? "\n" : " " )));
}
}
System.out.println(System.lineSeparator());
System.out.println("There are " + count + " descending primes.");
}

private static boolean isPrime(int aNumber) {
if ( aNumber < 2 || ( aNumber % 2 ) == 0 ) {
return aNumber == 2;
}

for ( int divisor = 3; divisor * divisor <= aNumber; divisor += 2 ) {
if ( aNumber % divisor == 0 ) {
return false;
}
}
return true;
}

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

## jq

Works with: jq

Also works with gojq and fq provided _nwise/1 is defined as in jq.

Preliminaries

```# Output: a stream of the powersets of the input array
def powersets:
if length == 0 then .
else .[-1] as \$x
| .[:-1] | powersets
| ., . + [\$x]
end;

def is_prime:
. as \$n
| if (\$n < 2)         then false
elif (\$n % 2 == 0)  then \$n == 2
elif (\$n % 3 == 0)  then \$n == 3
elif (\$n % 5 == 0)  then \$n == 5
elif (\$n % 7 == 0)  then \$n == 7
elif (\$n % 11 == 0) then \$n == 11
elif (\$n % 13 == 0) then \$n == 13
elif (\$n % 17 == 0) then \$n == 17
elif (\$n % 19 == 0) then \$n == 19
else 23
| until( (. * .) > \$n or (\$n % . == 0); .+2)
| . * . > \$n
end;

def lpad(\$len): tostring | (\$len - length) as \$l | (" " * \$l)[:\$l] + .;```

Descending primes

```[range(9;0;-1)]
| [powersets
| map(tostring)
| join("")
| select(length > 0)
| tonumber
| select(is_prime)]
| sort
| _nwise(10)
| join(" ")```
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
```

## Julia

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

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

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

## Nim

```import std/[strutils, sugar]

proc isPrime(n: int): bool =
assert n > 7
if n mod 2 == 0 or n mod 3 == 0: return false
var d = 5
var step = 2
while d * d <= n:
if n mod d == 0:
return false
inc d, step
step = 6 - step
result = true

iterator descendingPrimes(): int =

# Yield one digit primes.
for n in [2, 3, 5, 7]:
yield n

# Yield other primes by increasing length and in ascending order.
type Item = tuple[val, lastDigit: int]
var items: seq[Item] = collect(for n in 1..9: (n, n))
for ndigits in 2..9:
var nextItems: seq[Item]
for item in items:
for newDigit in 0..(item.lastDigit - 1):
let newVal = 10 * item.val + newDigit
if newVal.isPrime():
yield newVal
items = move(nextItems)

var rank = 0
for prime in descendingPrimes():
inc rank
stdout.write (\$prime).align(8)
stdout.write if rank mod 8 == 0: '\n' else: ' '
echo()
```
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

Library: ntheory
```use strict;
use warnings;
use ntheory '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```

## Prolog

Works with: swi-prolog
```isPrime(2).
isPrime(N):-
between(3, inf, N),
N /\ 1 > 0,             % odd
M is floor(sqrt(N)) - 1, % reverse 2*I+1
Max is M div 2,
forall(between(1, Max, I), N mod (2*I+1) > 0).

combi(0, _, []).
combi(N, [_|T], Comb):-
N > 0,
combi(N, T, Comb).
combi(N, [X|T], [X|Comb]):-
N > 0,
N1 is N - 1,
combi(N1, T, Comb).

descPrimes(Num):-
between(1, 9, N),
combi(N, [9, 8, 7, 6, 5, 4, 3, 2, 1], CList),
atomic_list_concat(CList, Tmp), % swi specific
atom_number(Tmp, Num),	 % int_list_to_number
isPrime(Num).

showList(List):-
findnsols(10, DPrim, (member(DPrim, List), writef('%9r', [DPrim])), _),
nl,
fail.
showList(_).

do:-findall(DPrim, descPrimes(DPrim), DList),
showList(DList).
```
Output:
```?- do.
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
true.
```

## Python

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

## Quackery

`powerset` is defined at Power set#Quackery, and `isprime` is defined at Primality by trial division#Quackery.

```  [ 0 swap witheach
[ swap 10 * + ] ]                 is digits->n ( [ --> n )

[]
' [ 9 8 7 6 5 4 3 2 1 ] powerset
witheach
[ digits->n dup isprime
iff join else drop ]
sort echo```
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

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

```show("decending primes", sort(cending_primes(seq(9, 1))))

func show(title, itm)
l = len(itm); ? "" + l + " " + title + ":"
for i = 1 to l
see fmt(itm[i], 9)
if i % 5 = 0 and i < l? "" ok
next : ? ""

func seq(b, e)
res = []; d = e - b
s = d / fabs(d)
for i = b to e step s add(res, i) next
return res

func ispr(n)
if n < 2 return 0 ok
if n & 1 = 0 return n = 2 ok
if n % 3 = 0 return n = 3 ok
l = sqrt(n)
for f = 5 to l
if n % f = 0 or n % (f + 2) = 0 return false ok
next : return 1

func cending_primes(digs)
cand = [0]
pr = []
for i in digs
lcand = cand
for j in lcand
v = j * 10 + i
next
next
return pr

func fmt(x, l)
res = "          " + x
return right(res, l)```
Output:
```87 decending 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```

## RPL

Translation of: C#
Works with: HP version 49g
```≪ { } → dprimes
≪ { 1 2 3 4 5 6 7 8 9 } DUP
DO
SWAP DROP { }
1 3 PICK SIZE FOR j
OVER j GET
IF DUP ISPRIME? THEN 'dprimes' OVER STO+ END
10 * LASTARG MOD OVER + → b l
≪ WHILE 'b' INCR l < REPEAT b + END ≫
NEXT
UNTIL DUP SIZE 1 ≤ END
DROP2 dprimes
≫ ≫ 'DPRIM' STO
```
Output:
```1: { 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 }
```

## Ruby

```require 'prime'

digits = [9,8,7,6,5,4,3,2,1].to_a
res = 1.upto(digits.size).flat_map do |n|
digits.combination(n).filter_map do |set|
candidate = set.join.to_i
candidate if candidate.prime?
end.reverse
end

puts res.join(",")
```
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
```

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

Library: Wren-perm
Library: Wren-math
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:")
Fmt.tprint("\$8s", descPrimes, 10)
```
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;
N:= N*10 + Digit;
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
```