Generate and show all primes with strictly descending decimal digits.

Task
Descending primes
You are encouraged to solve this task according to the task description, using any language you may know.
See also
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
			Memo.Lines.Add(S);
			S:='';
			end;
		end;
	end;
if S<>'' then Memo.Lines.Add(S);
Memo.Lines.Add('Descending Primes Found: '+IntToStr(Cnt));
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
    while ( mask )
      if mask & 1 then n = n * 10 + num
      mask = mask >> 1
      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) {
		List<Integer> allNumbersStrictlyDescendingDigits = new ArrayList<Integer>(512);
		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;
		    }
		    allNumbersStrictlyDescendingDigits.add(number);
		}

		Collections.sort(allNumbersStrictlyDescendingDigits);
		
		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)
| map(lpad(9))
| 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
        nextItems.add (val: newVal, lastDigit: 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
© 2023
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
      if ispr(v) add(pr, v) ok
      add(cand, v)
    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 + ENDNEXT       
      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;
    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