Rosetta Code

Descending primes: Difference between revisions

Page Discussion

Descending primes (view source)

Revision as of 09:00, 23 December 2023

22,568 bytes added ,  4 months ago
m
→‎Prolog
(Added C++ version)
 
(31 intermediate revisions by 16 users not shown)
Line 8:
*[[Ascending primes]]
 
 
=={{header|11l}}==
{{trans|C#}}
 
<syntaxhighlight lang="11l">
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’)
</syntaxhighlight>
 
{{out}}
<pre>
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
</pre>
 
Alternative solution:
<syntaxhighlight lang="11l">
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’)
</syntaxhighlight>
 
=={{header|ALGOL 68}}==
Line 14 ⟶ 101:
{{libheader|ALGOL 68-primes}}
{{libheader|ALGOL 68-rows}}
<langsyntaxhighlight lang="algol68">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 #
Line 58 ⟶ 145:
IF i MOD 10 = 0 THEN print( ( newline ) ) FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 71 ⟶ 158:
8764321 8765321 9754321 9875321 97654321 98764321 98765431
</pre>
 
=={{header|ALGOL W}}==
{{Trans|Lua}}
...and only a few characters different from the Algol W [[Ascending primes]] sample.
<syntaxhighlight lang="algolw">
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.
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|Arturo}}==
{{trans|ALGOL 68}}
<langsyntaxhighlight lang="rebol">descending: @[
loop 1..9 'a [
loop 1..dec a 'b [
Line 99 ⟶ 287:
loop split.every:10 select descending => prime? 'row [
print map to [:string] row 'item -> pad item 8
]</langsyntaxhighlight>
 
{{out}}
Line 114 ⟶ 302:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f DESCENDING_PRIMES.AWK
BEGIN {
Line 150 ⟶ 338:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 164 ⟶ 352:
1-99999999: 87 descending primes
</pre>
 
=={{header|C}}==
{{trans|C#}}
<syntaxhighlight lang="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);
}</syntaxhighlight>
{{out}}
Same as C#
 
=={{header|C#|CSharp}}==
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.
 
<langsyntaxhighlight lang="csharp">using System;
 
class Program {
Line 195 ⟶ 412:
Console.WriteLine("\n{0} descending primes found", c);
}
}</langsyntaxhighlight>
{{out}}
<pre> 2 3 5 7 31
Line 219 ⟶ 436:
=={{header|C++}}==
{{trans|C#}}
<langsyntaxhighlight lang="cpp">#include <iostream>
 
bool ispr(unsigned int n) {
Line 241 ⟶ 458:
}
printf("\n%d descending primes found", c);
}</langsyntaxhighlight>
{{out}}
Same as C#
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
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;
 
 
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|EasyLang}}==
<syntaxhighlight lang=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
.
</syntaxhighlight>
 
 
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<langsyntaxhighlight lang="fsharp">
// 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 ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
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
</pre>
 
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">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.</langsyntaxhighlight>
{{out}}
<pre>
Line 280 ⟶ 618:
=={{header|FreeBASIC}}==
{{trans|XPL0}}
<langsyntaxhighlight lang="freebasic">#include "isprime.bas"
#include "sort.bas"
 
Line 310 ⟶ 648:
Next i
Print Using !"\n\nThere are & descending primes."; cant
Sleep</langsyntaxhighlight>
{{out}}
<pre> 2 3 5 7 31 41 43 53 61 71
Line 327 ⟶ 665:
Tested on vfxforth and GForth.
 
<langsyntaxhighlight lang="forth">: is-prime? \ n -- f ; \ Fast enough for this application
DUP 1 AND IF \ n is odd
DUP 3 DO
Line 365 ⟶ 703:
: descending-primes
\ Print the descending primes. Call digits with increasing #digits
CR 9 1 DO I 0 10 digits LOOP ;</langsyntaxhighlight>
<pre>
descending-primes
Line 379 ⟶ 717:
</pre>
 
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="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
</syntaxhighlight>
{{output}}
<pre>
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
</pre>
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 444 ⟶ 849:
}
fmt.Println()
}</langsyntaxhighlight>
 
{{out}}
Line 461 ⟶ 866:
 
=={{header|J}}==
Compare with [[Ascending_primes#J|Ascending primes]].
<syntaxhighlight lang="j"> NB. increase maximum output line length
9!:37 (512) 1} 9!:36 ''
 
(#~ 1&p:) (#: }. i. 512) 10&#.@# >: i. _9
Compare with [[Ascending_primes#J|Ascending primes]] (focusing on the computational details, rather than the presentation).
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</syntaxhighlight>
 
=={{header|Java}}==
<lang J> extend=: {{ y;y,L:0(1+each i.1-{:y)}}
<syntaxhighlight lang="java">
($~ q:@$)(#~ 1 p: ])10#.&>([:~.@;extend each)^:# >:i.9
 
2 3 31 43 41 431 421 5 53 541 521 5431 61 653 643 641 631 6521 6421 7 73 71 761 751 743 7643 7621 7541 7321
import java.util.ArrayList;
76543 76541 76421 75431 764321 83 863 853 821 8761 8753 8741 8731 8641 8543 8521 8431 87643 87641 87631 87541 87421 86531 876431 865321 8765321 8764321 97 983
import java.util.Collections;
971 953 941 9871 9851 9743 9721 9643 9631 9521 9431 9421 98731 98641 98621 98543 98321 97651 96431 94321 987631 987541 986543 975421 9875321 9754321 98765431 98764321 97654321</lang>
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;
}
 
}
</syntaxhighlight>
{{ out }}
<pre>
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.
</pre>
 
=={{header|jq}}==
{{works with|jq}}
''Also works with gojq and fq'' provided _nwise/1 is defined as in jq.
 
'''Preliminaries'''
<syntaxhighlight lang=jq>
# 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] + .;
</syntaxhighlight>
'''Descending primes'''
<syntaxhighlight lang=jq>
[range(9;0;-1)]
| [powersets
| map(tostring)
| join("")
| select(length > 0)
| tonumber
| select(is_prime)]
| sort
| _nwise(10)
| map(lpad(9))
| join(" ")
</syntaxhighlight>
{{output}}
<pre>
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
</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Combinatorics
using Primes
Line 480 ⟶ 1,009:
foreach(p -> print(rpad(p[2], 10), p[1] % 10 == 0 ? "\n" : ""), enumerate(descendingprimes()))
</langsyntaxhighlight>{{out}}
<pre>
2 3 5 7 31 41 43 53 61 71
Line 495 ⟶ 1,024:
=={{header|Lua}}==
Identical to [[Ascending_primes#Lua]] except for the order of <code>digits</code> list.
<langsyntaxhighlight lang="lua">local function is_prime(n)
if n < 2 then return false end
if n % 2 == 0 then return n==2 end
Line 518 ⟶ 1,047:
end
 
print(table.concat(descending_primes(), ", "))</langsyntaxhighlight>
{{out}}
<pre>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</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">Sort[Select[FromDigits/@Subsets[Range[9,1,-1],{1,\[Infinity]}],PrimeQ]]</langsyntaxhighlight>
{{out}}
<pre>{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}</pre>
 
=={{header|PerlNim}}==
<syntaxhighlight lang="Nim">import std/[strutils, sugar]
<lang perl>#!/usr/bin/perl
 
proc isPrime(n: int): bool =
use strict; # https://rosettacode.org/wiki/Descending_primes
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()
</syntaxhighlight>
{{out}}
<pre> 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
</pre>
 
=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl">
use strict;
use warnings;
use ntheory qw( 'is_prime )';
 
print join( '',
print join('', sort map { sprintf "%9d", $_ } grep /./ && is_prime($_),
sort
glob join '', map "{$_,}", reverse 1 .. 9) =~ s/.{45}\K/\n/gr;</lang>
map { sprintf '%9d', $_ }
grep /./ && is_prime $_,
glob join '', map "{$_,}", reverse 1..9
) =~ s/.{45}\K/\n/gr;
</syntaxhighlight>
{{out}}
<pre>
Line 559 ⟶ 1,149:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">descending_primes</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">max_digit</span><span style="color: #0000FF;">=</span><span style="color: #000000;">9</span><span style="color: #0000FF;">)</span>
Line 574 ⟶ 1,164:
<span style="color: #000000;">j</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">11</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%8d"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"There are %,d descending primes:\n%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">),</span><span style="color: #000000;">j</span><span style="color: #0000FF;">})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 600 ⟶ 1,190:
</pre>
=== powerset ===
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">descending_primes</span><span style="color: #0000FF;">()</span>
Line 621 ⟶ 1,211:
<span style="color: #000000;">j</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">11</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%8d"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"There are %,d descending primes:\n%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">),</span><span style="color: #000000;">j</span><span style="color: #0000FF;">})</span>
<!--</langsyntaxhighlight>-->
Output same as the sorted output above, without requiring a sort.
 
=={{header|Picat}}==
<langsyntaxhighlight Picatlang="picat">import util.
 
main =>
Line 633 ⟶ 1,223:
end,
nl,
println(len=DP.len).</langsyntaxhighlight>
 
{{out}}
Line 646 ⟶ 1,236:
8764321 8765321 9754321 9875321 97654321 98764321 98765431
len = 87</pre>
=={{header|Prolog}}==
{{works with|swi-prolog}}© 2023<syntaxhighlight lang="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).
</syntaxhighlight>
{{out}}
<pre>
?- 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.
</pre>
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">from sympy import isprime
 
def descending(xs=range(10)):
Line 658 ⟶ 1,297:
print(f'{p:9d}', end=' ' if (1 + i)%8 else '\n')
 
print()</langsyntaxhighlight>
{{out}}
<pre> 2 3 5 7 31 41 43 53
Line 672 ⟶ 1,311:
8764321 8765321 9754321 9875321 97654321 98764321 98765431</pre>
 
=={{header|Quackery}}==
 
<code>powerset</code> is defined at [[Power set#Quackery]], and <code>isprime</code> is defined at [[Primality by trial division#Quackery]].
 
<syntaxhighlight lang="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</syntaxhighlight>
 
{{out}}
 
<pre>[ 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 ]</pre>
 
=={{header|Raku}}==
Trivial variation of [[Ascending primes]] task.
 
<syntaxhighlight lang="raku" perl6line>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;
}</langsyntaxhighlight>
{{out}}
<pre> 2 3 5 7 31 41 43 53 61 71
Line 694 ⟶ 1,350:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">show("decending primes", sort(cending_primes(seq(9, 1))))
 
func show(title, itm)
Line 733 ⟶ 1,389:
func fmt(x, l)
res = " " + x
return right(res, l)</langsyntaxhighlight>
{{out}}
<pre>87 decending primes:
Line 754 ⟶ 1,410:
8764321 8765321 9754321 9875321 97654321
98764321 98765431</pre>
 
=={{header|RPL}}==
{{trans|C#}}
{{works with|HP|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
≫ ≫ '<span style="color:blue">DPRIM</span>' STO
{{out}}
<pre>
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 }
</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'prime'
 
digits = [9,8,7,6,5,4,3,2,1].to_a
Line 766 ⟶ 1,443:
end
 
puts res.join(",")</langsyntaxhighlight>
{{out}}
<pre>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
Line 772 ⟶ 1,449:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func primes_with_descending_digits(base = 10) {
 
var list = []
Line 801 ⟶ 1,478:
arr.each_slice(8, {|*a|
say a.map { '%9s' % _ }.join(' ')
})</langsyntaxhighlight>
{{out}}
<pre>
Line 822 ⟶ 1,499:
{{libheader|Wren-perm}}
{{libheader|Wren-math}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./perm" for Powerset
import "./math" for Int
import "./seq" for Lst
Line 835 ⟶ 1,511:
.sort()
System.print("There are %(descPrimes.count) descending primes, namely:")
Fmt.tprint("$8s", descPrimes, 10)</syntaxhighlight>
for (chunk in Lst.chunks(descPrimes, 10)) Fmt.print("$8s", chunk)</lang>
 
{{out}}
Line 852 ⟶ 1,528:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">include xpllib; \provides IsPrime and Sort
 
int I, N, Mask, Digit, A(512), Cnt;
Line 876 ⟶ 1,552:
];
];
]</langsyntaxhighlight>
 
{{out}}
Achim
51

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/320387...355554"