Rosetta Code

Descending primes: Difference between revisions

Page Discussion

Descending primes (view source)

Revision as of 09:00, 23 December 2023

25,512 bytes added ,  4 months ago
m
→‎Prolog
 
(35 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.
 
<syntaxhighlight lang="csharp">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);
}
}</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>
 
=={{header|C++}}==
{{trans|C#}}
<syntaxhighlight lang="cpp">#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);
}</syntaxhighlight>
{{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 200 ⟶ 618:
=={{header|FreeBASIC}}==
{{trans|XPL0}}
<langsyntaxhighlight lang="freebasic">#include "isprime.bas"
#include "sort.bas"
 
Line 230 ⟶ 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 247 ⟶ 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 285 ⟶ 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 299 ⟶ 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 364 ⟶ 849:
}
fmt.Println()
}</langsyntaxhighlight>
 
{{out}}
Line 381 ⟶ 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 400 ⟶ 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 415 ⟶ 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 438 ⟶ 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 479 ⟶ 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 494 ⟶ 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 520 ⟶ 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 541 ⟶ 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 553 ⟶ 1,223:
end,
nl,
println(len=DP.len).</langsyntaxhighlight>
 
{{out}}
Line 566 ⟶ 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 578 ⟶ 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 592 ⟶ 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 614 ⟶ 1,350:
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">show("decending primes", sort(cending_primes(seq(9, 1))))
{{incorrect|Ring| <br> Many of the numbers shown do not have strictly descending digits, e.g. all the ones starting with 2 (except 2 itself). <br> Largest is much larger than 1000. }}
<lang ring>
load "stdlibcore.ring"
 
func show(title, itm)
limit = 1000
l = len(itm); ? "" + l + " " + title + ":"
row = 0
for i = 1 to l
see fmt(itm[i], 9)
if i % 5 = 0 and i < l? "" ok
next : ? ""
 
func seq(b, e)
for n = 1 to limit
res = flag[]; d = 0e - b
s = strnd =/ stringfabs(nd)
for i = b to e step s add(res, i) next
if isprime(n) = 1
return res
for m = 1 to len(strn)-1
 
if number(substr(strn,m)) < number(substr(strn,m+1))
func ispr(n)
flag = 1
if n < 2 return 0 ok
if n & 1 = next0 return n = 2 ok
if n % 3 = if0 flagreturn n = 13 ok
l = row++sqrt(n)
for f = 5 to see "" + n + " "l
if n % f = 0 or n % (f + 2) = 0 return false ok
ok
next : return 1
if row % 10 = 0
 
see nl
func cending_primes(digs)
ok
cand = ok[0]
pr = []
next
for i in digs
</lang>
lcand = cand
Output:
for j in lcand
<br>
2 3 5 7 11 13 17v 19= 23j 29* 10 + i
31 37 41 43 47 53 59if 61ispr(v) 67add(pr, 71v) ok
add(cand, v)
73 79 83 89 97 101 103 107 109 113
next
127 131 137 139 149 151 157 163 167 173
next
179 181 191 193 197 199 211 223 227 229
return pr
233 239 241 251 257 263 269 271 277 281
 
283 293 307 311 313 317 331 337 347 349
func fmt(x, l)
353 359 367 373 379 383 389 397 401 409
419 421 431res 433= 439" 443 449 457 461 463 " + x
return right(res, l)</syntaxhighlight>
467 479 487 491 499 503 509 521 523 541
{{out}}
547 557 563 569 571 577 587 593 599 601
<pre>87 decending primes:
607 613 617 619 631 641 643 647 653 659
2 3 5 7 31
661 673 677 683 691 701 709 719 727 733
41 43 53 61 71
739 743 751 757 761 769 773 787 797 809
73 83 97 421 431
811 821 823 827 829 839 853 857 859 863
521 541 631 641 643
877 881 883 887 907 911 919 929 937 941
653 743 751 761 821
947 953 967 971 977 983 991 997
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|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 671 ⟶ 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 677 ⟶ 1,449:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func primes_with_descending_digits(base = 10) {
 
var list = []
Line 706 ⟶ 1,478:
arr.each_slice(8, {|*a|
say a.map { '%9s' % _ }.join(' ')
})</langsyntaxhighlight>
{{out}}
<pre>
Line 727 ⟶ 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 740 ⟶ 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 757 ⟶ 1,528:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">include xpllib; \provides IsPrime and Sort
 
int I, N, Mask, Digit, A(512), Cnt;
Line 781 ⟶ 1,552:
];
];
]</langsyntaxhighlight>
 
{{out}}
Achim
51

edits

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