Rosetta Code

Sequence: smallest number greater than previous term with exactly n divisors: Difference between revisions

Page Discussion

Sequence: smallest number greater than previous term with exactly n divisors (view source)

Revision as of 11:38, 4 February 2024

28,412 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(36 intermediate revisions by 26 users not shown)
Line 18:
:* [[Sequence: nth number with exactly n divisors‎‎]]
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">F divisors(n)
V divs = [1]
L(ii) 2 .< Int(n ^ 0.5) + 3
I n % ii == 0
divs.append(ii)
divs.append(Int(n / ii))
divs.append(n)
R Array(Set(divs))
 
F sequence(max_n)
V previous = 0
V n = 0
[Int] r
L
n++
V ii = previous
I n > max_n
L.break
L
ii++
I divisors(ii).len == n
r.append(ii)
previous = ii
L.break
R r
 
L(item) sequence(15)
print(item)</syntaxhighlight>
 
{{out}}
<pre>
1
2
4
6
16
18
64
66
100
112
1024
1035
4096
4288
4624
</pre>
 
=={{header|Action!}}==
Calculations on a real Atari 8-bit computer take quite long time. It is recommended to use an emulator capable with increasing speed of Atari CPU.
<syntaxhighlight lang="action!">CARD FUNC CountDivisors(CARD a)
CARD i,count
 
i=1 count=0
WHILE i*i<=a
DO
IF a MOD i=0 THEN
IF i=a/i THEN
count==+1
ELSE
count==+2
FI
FI
i==+1
OD
RETURN (count)
 
PROC Main()
CARD a
BYTE i
 
a=1
FOR i=1 TO 15
DO
WHILE CountDivisors(a)#i
DO
a==+1
OD
IF i>1 THEN
Print(", ")
FI
PrintC(a)
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sequence_smallest_number_greater_than_previous_term_with_exactly_n_divisors.png Screenshot from Atari 8-bit computer]
<pre>
1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624
</pre>
 
=={{header|Ada}}==
{{trans|Go}}
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
 
procedure Show_Sequence is
Line 60 ⟶ 153:
begin
Show (15);
end Show_Sequence;</langsyntaxhighlight>
 
{{out}}
Line 67 ⟶ 160:
 
=={{header|ALGOL 68}}==
{{trans|Go}} with a small optimisation.
<langsyntaxhighlight lang="algol68">BEGIN
 
PROC count divisors = ( INT n )INT:
BEGIN
INT i2, count := 0;
FOR i WHILE ( i2 := i * i ) <= n DO
IF n MOD i = 0 THEN count +:= 2 FI
count +:= IF i = n OVER i THEN 1 ELSE 2 FI
FI
OD;
IF i2 = n THEN count + 1 ELSE count FI
END # count divisors # ;
INT max = 15;
 
print( ( "The first ", whole( max, 0 ), " terms of the sequence are:", newline ) );
INT next := 1;
FOR i WHILE next <= max DO
IF next = count divisors( i ) THEN
print( ( " ", whole( i, 0 ), " " ) );
next +:= 1
FI
OD;
print( ( newline, newline ) )
 
END</langsyntaxhighlight>
{{out}}
<pre>
The first 15 terms of the sequence are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
 
=={{header|ALGOL W}}==
{{Trans|Go}}...via Algol 68 and with a small optimisation.
<syntaxhighlight lang="pascal">begin
integer max, next, i;
 
integer procedure countDivisors ( Integer value n ) ;
begin
integer count, i, i2;
count := 0;
i := 1;
while begin i2 := i * i;
i2 < n
end do begin
if n rem i = 0 then count := count + 2;
i := i + 1
end;
if i2 = n then count + 1 else count
end countDivisors ;
 
max := 15;
write( i_w := 1, s_w := 0, "The first ", max, " terms of the sequence are: " );
i := next := 1;
while next <= max do begin
if next = countDivisors( i ) then begin
writeon( i_w := 1, s_w := 0, " ", i );
next := next + 1
end;
i := i + 1
end;
write()
end.</syntaxhighlight>
{{out}}
<pre>
The first 15 terms of the sequence are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">i: new 0
next: new 1
MAX: 15
while [next =< MAX][
if next = size factors i [
prints ~"|i| "
inc 'next
]
inc 'i
]
print ""</syntaxhighlight>
 
{{out}}
 
<pre>1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>
 
=={{header|AutoHotkey}}==
{{trans|Go}}
<syntaxhighlight lang="autohotkey">MAX := 15
next := 1, i := 1
while (next <= MAX)
if (next = countDivisors(A_Index))
Res.= A_Index ", ", next++
MsgBox % "The first " MAX " terms of the sequence are:`n" Trim(res, ", ")
return
 
countDivisors(n){
while (A_Index**2 <= n)
if !Mod(n, A_Index)
count += (A_Index = n/A_Index) ? 1 : 2
return count
}</syntaxhighlight>
Outputs:<pre>The first 15 terms of the sequence are:
1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f SEQUENCE_SMALLEST_NUMBER_GREATER_THAN_PREVIOUS_TERM_WITH_EXACTLY_N_DIVISORS.AWK
# converted from Kotlin
Line 125 ⟶ 287:
return(count)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
first 15 terms: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
 
=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="vbnet">UPTO = 15
i = 2
nfound = 1
 
print 1; " "; #special case
 
while nfound < UPTO
n = divisors(i)
if n = nfound + 1 then
nfound += 1
print i; " ";
end if
i += 1
end while
end
 
function divisors(n)
#find the number of divisors of an integer
r = 2
for i = 2 to n\2
if n mod i = 0 then r += 1
next i
return r
end function</syntaxhighlight>
 
==={{header|Gambas}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="vbnet">Public Sub Main()
Dim UPTO As Integer = 15, i As Integer = 2
Dim n As Integer, nfound As Integer = 1
Print 1; " "; 'special case
While nfound < UPTO
n = divisors(i)
If n = nfound + 1 Then
nfound += 1
Print i; " ";
End If
i += 1
Wend
End Sub
 
Function divisors(n As Integer) As Integer
'find the number of divisors of an integer
 
Dim r As Integer = 2, i As Integer
For i = 2 To n \ 2
If n Mod i = 0 Then r += 1
Next
Return r
 
End Function</syntaxhighlight>
 
==={{header|PureBasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="purebasic">Procedure.i divisors(n)
;find the number of divisors of an integer
Define.i r, i
r = 2
For i = 2 To n/2
If n % i = 0: r + 1
EndIf
Next i
ProcedureReturn r
EndProcedure
 
 
OpenConsole()
Define.i UPTO, i, n, found
 
UPTO = 15
i = 2
nfound = 1
 
Print("1 ") ;special case
 
While nfound < UPTO
n = divisors(i)
If n = nfound + 1:
nfound + 1
Print(Str(i) + " ")
EndIf
i + 1
Wend
PrintN(#CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()</syntaxhighlight>
 
==={{header|QBasic}}===
{{trans|FreeBASIC}}
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">FUNCTION divisors (n)
'find the number of divisors of an integer
r = 2
FOR i = 2 TO n \ 2
IF n MOD i = 0 THEN r = r + 1
NEXT i
divisors = r
END FUNCTION
 
UPTO = 15
i = 2
nfound = 1
 
PRINT 1; 'special case
 
WHILE nfound < UPTO
n = divisors(i)
IF n = nfound + 1 THEN
nfound = nfound + 1
PRINT i;
END IF
i = i + 1
WEND</syntaxhighlight>
 
==={{header|Run BASIC}}===
{{trans|FreeBASIC}}
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
<syntaxhighlight lang="vb">UPTO = 15
i = 2
nfound = 1
 
print 1; " "; 'special case
 
while nfound < UPTO
n = divisors(i)
if n = nfound + 1 then
nfound = nfound + 1
print i; " ";
end if
i = i + 1
wend
print
end
 
function divisors(n)
'find the number of divisors of an integer
r = 2
for i = 2 to n / 2
if n mod i = 0 then r = r + 1
next i
divisors = r
end function</syntaxhighlight>
 
==={{header|XBasic}}===
{{trans|FreeBASIC}}
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "program name"
VERSION "0.0000"
 
DECLARE FUNCTION Entry ()
DECLARE FUNCTION divisors (n)
 
FUNCTION Entry ()
UPTO = 15
i = 2
nfound = 1
 
PRINT 1; 'special case
 
DO WHILE nfound < UPTO
n = divisors(i)
IF n = nfound + 1 THEN
INC nfound
PRINT i;
END IF
INC i
LOOP
END FUNCTION
 
FUNCTION divisors (n)
'find the number of divisors of an integer
r = 2
FOR i = 2 TO n / 2
IF n MOD i = 0 THEN INC r
NEXT i
RETURN r
END FUNCTION
END PROGRAM</syntaxhighlight>
 
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="vbnet">UPTO = 15
i = 2
nfound = 1
 
print 1, " "; //special case
 
while nfound < UPTO
n = divisors(i)
if n = nfound + 1 then
nfound = nfound + 1
print i, " ";
fi
i = i + 1
end while
print
end
 
sub divisors(n)
local r, i
//find the number of divisors of an integer
r = 2
for i = 2 to n / 2
if mod(n, i) = 0 r = r + 1
next i
return r
end sub</syntaxhighlight>
 
=={{header|C}}==
{{trans|Go}}
<langsyntaxhighlight lang="c">#include <stdio.h>
 
#define MAX 15
Line 161 ⟶ 540:
printf("\n");
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 171 ⟶ 550:
=={{header|C++}}==
{{trans|C}}
<langsyntaxhighlight lang="cpp">#include <iostream>
 
#define MAX 15
Line 200 ⟶ 579:
cout << endl;
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 207 ⟶ 586:
1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
===Alternative===
{{Trans|Pascal}}
More terms and quicker than the straightforward C version above. [https://tio.run/##bVJNb9NAFLz7V0yLGu1ihzopJ38EIbgiJMSBG3J3N84KZ@1417QI5a8T3tuQNqm42W/emxnPWA3DvFXqcHhlneombVApH7TtV8nZZDP2jibJ5K1r4Zqt8UOjDGizKI5omSSqdz7AuoBP77@hxt2yTJBMztvWGR2B1oSP9qfVZvQfXBAXmJP4nQAXM800GXYZ9BfjM4zG02RBvHjY2M5AXAmHGRaSjuGwWjHKa2laYv@8JjReQ0tUddTBjmgcbqFL2DWI44a1auQMshbhOcsAuj@N0pqZSzqssSuJ47Zmgv1J5IzleIpomM74nBc1vyz5aTRhGh1RXZFjvIuLVUWPxVFjnyQcwLaxTrCni1hsBvcYMlCWFCNrDSPN1@L668ZgbUfq4UajccHOCaG6MHSTRzOaAtcZ9xMdNlPoqUT6HB9Mo399V12vfhSF6x@EpGQ4pMcQE48xxI/ivMRRmZAXjVoqoj5eseuTLTJDsvYplsiRpry2wluJ2QziBRNhkWop5b8jRENiwTkxjHnsfc7u9rCx8acqCKauTx965mPryYmgVyn0NDbB9q7S/XTfmZX4TwpE74N8o/qJPEn6iRZ5nksi3R8Of9S6a1p/mH@@@ws Try It Online!]<syntaxhighlight lang="cpp">#include <cstdio>
#include <chrono>
 
using namespace std::chrono;
 
const int MAX = 32;
unsigned int getDividersCnt(unsigned int n) {
unsigned int d = 3, q, dRes, res = 1;
while (!(n & 1)) { n >>= 1; res++; }
while ((d * d) <= n) { q = n / d; if (n % d == 0) { dRes = 0;
do { dRes += res; n = q; q /= d; } while (n % d == 0);
res += dRes; } d += 2; } return n != 1 ? res << 1 : res; }
 
int main() { unsigned int i, nxt, DivCnt;
printf("The first %d anti-primes plus are: ", MAX);
auto st = steady_clock::now(); i = nxt = 1; do {
if ((DivCnt = getDividersCnt(i)) == nxt ) { printf("%d ", i);
if ((++nxt > 4) && (getDividersCnt(nxt) == 2))
i = (1 << (nxt - 1)) - 1; } i++; } while (nxt <= MAX);
printf("%d ms", (int)(duration<double>(steady_clock::now() - st).count() * 1000));
}</syntaxhighlight>
{{out}}
<pre>The first 32 anti-primes plus are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624 4632 65536 65572 262144 262192 263169 269312 4194304 4194306 4477456 4493312 4498641 4498752 268435456 268437200 1073741824 1073741830 223 ms</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
 
{These routines would normally be in a library, but the shown here for clarity}
 
function GetAllProperDivisors(N: Integer;var IA: TIntegerDynArray): integer;
{Make a list of all the "proper dividers" for N}
{Proper dividers are the of numbers the divide evenly into N}
var I: integer;
begin
SetLength(IA,0);
for I:=1 to N-1 do
if (N mod I)=0 then
begin
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=I;
end;
Result:=Length(IA);
end;
 
 
function GetAllDivisors(N: Integer;var IA: TIntegerDynArray): integer;
{Make a list of all the "proper dividers" for N, Plus N itself}
begin
Result:=GetAllProperDivisors(N,IA)+1;
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=N;
end;
 
 
procedure SmallestWithNDivisors(Memo: TMemo);
var N,Count: integer;
var IA: TIntegerDynArray;
begin
Count:=1;
for N:=1 to high(Integer) do
if Count=GetAllDivisors(N,IA) then
begin
Memo.Lines.Add(IntToStr(Count)+' - '+IntToStr(N));
Inc(Count);
if Count>15 then break;
end;
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
1 - 1
2 - 2
3 - 4
4 - 6
5 - 16
6 - 18
7 - 64
8 - 66
9 - 100
10 - 112
11 - 1024
12 - 1035
13 - 4096
14 - 4288
15 - 4624
 
Elapsed Time: 58.590 ms.
 
</pre>
 
 
=={{header|Dyalect}}==
Line 212 ⟶ 691:
{{trans|Go}}
 
<langsyntaxhighlight lang="dyalect">func countDivisors(n) {
var count = 0
var i = 1
Line 228 ⟶ 707:
}
constlet max = 15
print("The first \(max) terms of the sequence are:")
var (i, next) = (1, 1)
while next <= max {
if next == countDivisors(i) {
print("\(i) ", terminator =: "")
next += 1
}
Line 239 ⟶ 718:
}
 
print()</langsyntaxhighlight>
 
{{out}}
Line 245 ⟶ 724:
<pre>The first 15 terms of the sequence are:
1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>
 
=={{header|EasyLang}}==
{{trans|AWK}}
<syntaxhighlight>
func ndivs n .
i = 1
while i <= sqrt n
if n mod i = 0
cnt += 2
if i = n div i
cnt -= 1
.
.
i += 1
.
return cnt
.
n = 1
while n <= 15
i += 1
if n = ndivs i
write i & " "
n += 1
.
.
</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
===First 28 are easy with a Naive implementation===
<syntaxhighlight lang="fsharp">
// Nigel Galloway: November 19th., 2017
let fN g=[1..(float>>sqrt>>int)g]|>List.fold(fun Σ n->if g%n>0 then Σ else if g/n=n then Σ+1 else Σ+2) 0
let A069654=let rec fG n g=seq{match g-fN n with 0->yield n; yield! fG(n+1)(g+1) |_->yield! fG(n+1)g} in fG 1 1
 
A069654 |> Seq.take 28|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
{{out}}
<pre>
1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624 4632 65536 65572 262144 262192 263169 269312 4194304 4194306 4477456 4493312 4498641 4498752
</pre>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: io kernel math math.primes.factors prettyprint sequences ;
 
: next ( n num -- n' num' )
Line 255 ⟶ 774:
[ 2 1 ] dip [ [ next ] keep ] replicate 2nip ;
 
"The first 15 terms of the sequence are:" print 15 A069654 .</langsyntaxhighlight>
{{out}}
<pre>
Line 261 ⟶ 780:
{ 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624 }
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">#define UPTO 15
 
function divisors(byval n as ulongint) as uinteger
'find the number of divisors of an integer
dim as integer r = 2, i
for i = 2 to n\2
if n mod i = 0 then r += 1
next i
return r
end function
 
dim as ulongint i = 2
dim as integer n, nfound = 1
 
print 1;" "; 'special case
 
while nfound < UPTO
n = divisors(i)
if n = nfound + 1 then
nfound += 1
print i;" ";
end if
i+=1
wend
print
end</syntaxhighlight>
{{out}}<pre> 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 291 ⟶ 839:
}
fmt.Println()
}</langsyntaxhighlight>
 
{{out}}
Line 299 ⟶ 847:
</pre>
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Text.Printf (printf)
 
sequence_A069654 :: [(Int,Int)]
sequence_A069654 = go 1 $ (,) <*> countDivisors <$> [1..]
where go t ((n,c):xs) | c == t = (t,n):go (succ t) xs
where
| otherwise = go t xs
countDivisors n = foldr f 0 [1..floor (sqrt $ realToFrac n)]
countDivisors n = foldr f 0 [1..floor $ sqrt $ realToFrac n]
where
where f x r | n `mod` x == 0 = let y =if n `div` x in if x == yx then r+1 else r+2
| otherwise = r
go t ((n,c):xs) | c == t = (t,n):go (succ t) xs
| otherwise = go t xs
 
main :: IO ()
main = mapM_ (uncurry( $ printf "a(%2d)=%5d\n")) $ take 15 sequence_A069654</langsyntaxhighlight>
{{out}}
<pre>a( 1)= 1
Line 332 ⟶ 878:
 
=={{header|J}}==
<syntaxhighlight lang="j">
<lang j>
sieve=: 3 :0
NB. sieve y returns a vector of y boxes.
Line 350 ⟶ 896:
(</.~ {."1) (,. i.@:#)tally
)
</syntaxhighlight>
</lang>
 
<pre>
Line 478 ⟶ 1,024:
=={{header|Java}}==
{{trans|C}}
<langsyntaxhighlight lang="java">public class AntiPrimesPlus {
 
static int count_divisors(int n) {
Line 504 ⟶ 1,050:
System.out.println();
}
}</langsyntaxhighlight>
 
{{out}}
Line 511 ⟶ 1,057:
1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
 
=={{header|jq}}==
'''Adapted from [[Julia]]'''
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">
# The number of prime factors (as in prime factorization)
def numfactors:
. as $num
| reduce range(1; 1 + sqrt|floor) as $i (null;
if ($num % $i) == 0
then ($num / $i) as $r
| if $i == $r then .+1 else .+2 end
else .
end );
 
# Output: a stream
def A06954:
foreach range(1; infinite) as $i ({k: 0};
.j = .k + 1
| until( $i == (.j | numfactors); .j += 1)
| .k = .j ;
.j ) ;
 
"First 15 terms of OEIS sequence A069654: ",
[limit(15; A06954)]</syntaxhighlight>
{{out}}
<pre>
First 15 terms of OEIS sequence A069654:
[1,2,4,6,16,18,64,66,100,112,1024,1035,4096,4288,4624]
</pre>
 
 
=={{header|Julia}}==
{{trans|Perl}}
<langsyntaxhighlight lang="julia">using Primes
 
function numfactors(n)
Line 540 ⟶ 1,118:
 
A06954(15)
</langsyntaxhighlight>{{out}}
<pre>
First 15 terms of OEIS sequence A069654:
Line 548 ⟶ 1,126:
=={{header|Kotlin}}==
{{trans|Go}}
<langsyntaxhighlight lang="scala">// Version 1.3.21
 
const val MAX = 15
Line 576 ⟶ 1,154:
}
println()
}</langsyntaxhighlight>
 
{{output}}
Line 583 ⟶ 1,161:
1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">res = {#, DivisorSigma[0, #]} & /@ Range[100000];
highest = 0;
filter = {};
Do[
If[r[[2]] == highest + 1,
AppendTo[filter, r[[1]]];
highest = r[[2]]
]
,
{r, res}
]
Take[filter, 15]</syntaxhighlight>
{{out}}
<pre>{1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624}</pre>
 
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
sngptend(n):=block([i:1,count:1,result:[]],
while count<=n do (if length(listify(divisors(i)))=count then (result:endcons(i,result),count:count+1),i:i+1),
result)$
 
/* Test case */
sngptend(15);
</syntaxhighlight>
{{out}}
<pre>
[1,2,4,6,16,18,64,66,100,112,1024,1035,4096,4288,4624]
</pre>
 
=={{header|MiniScript}}==
This GUI implementation is for use with [http://miniscript.org/MiniMicro Mini Micro].
<syntaxhighlight lang="miniscript">
divisors = function(n)
divs = {1: 1}
divs[n] = 1
i = 2
while i * i <= n
if n % i == 0 then
divs[i] = 1
divs[n / i] = 1
end if
i += 1
end while
return divs.indexes
end function
 
counts = []
j = 1
for i in range(1, 15)
while divisors(j).len != i
j += 1
end while
counts.push(j)
end for
 
print "The first 15 terms in the sequence are:"
print counts.join(", ")
</syntaxhighlight>
{{out}}
<pre>
The first 15 terms in the sequence are:
1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">import strformat
 
const MAX = 15
Line 608 ⟶ 1,250:
inc next
inc i
write(stdout, "\n")</langsyntaxhighlight>
{{out}}
<pre>
Line 621 ⟶ 1,263:
I think of next = 33 aka 11*3 with the solution 1031^2 * 2^10=1,088,472,064 with a big distance to next= 32 => 1073741830.<BR>
[https://tio.run/##fVRdb9owFH3Pr7gPk0hYWCG0e2hKJcbHhtQCapm0vSCZxAGvwaa2U1ZV/PWxazsQ2k7jIeR@n3t8HLH4RRPd2BCVkLyRbZL9fiPFUpI1dLlmU8nWVE3zQsXey4fRsD8YwnDa23kALx9uJ/0B9Gm@WbEdRgc39wMX6E6ns5/TAfQm4/vJzWAHZ2eQ2jyTNu6PhjuvUFRhsnpWhWa5CtdEr2IvEVxpdN92f0CnHcUeeFnBE80EhyXVffbEUipVj2ufX35nXLejoPyPPZzyOgcWz5Aak/ElcMA0AUwr2JitICOJFlKZMvJAMN6BKLpomr95q96eR/WLeRtWRIHf@tgK6n5kn218Ysq564yDvCciEbIxw8dC6BBX1eSOqlBSpeESDvgWdMk4ZqK7yDHQgZZZEJAeUwzGE8VoKbohkmjYMr0ShbatFVKAqdsVyymMhfYnaerzIIBUoPtL2RpwDezC4f7bne2OP8YT340MjIPy9DA1k2INXGwB2RU8fwaRpsCL9cJs5TayoNrxcbKvHqVvAsFVh78bjtzfCoQVVmQYDoISSAaWkQ40Qa@oK6mKAQ7EmZnNuHRKuqFEl4bb5pRgu5YLHXMsB2b628D/8QEUKPncgby6riBUDB7PtixxZB5gmabRCclIMe6cE2znxAYiMzosFYgJoyHaOKpVEVKpw73VUTnlmTmhzZqoqRHXn8/NCBZy@luHuBkK/r3WtpJpmnO/Nluh4plEKLUQb1dYA4LLNiwQxIM3HIiklzULf9bE8V@pnrHkoSeK46yDZsHMPBonJ@RgmMib28pKwnBhl9NxPf6pAwvaZ4ixFpyegak4Oiy3tseBT9vMCdnaPnSuYS2URkcEwdzWN1qBKVAiL7S7UiUsG4VrOA@gO@6D//ZzY2abb0NQYba4LA2gVjkc@zdaMX5UmJmDsCVdU65pCiTTVG6JTNV77Th@nP7GDgieUlyd4Mmr//pkGrMmMrVWhivs@cnb7/8kWU6Wat@YRH8B Try it online!]
<langsyntaxhighlight lang="pascal">program AntiPrimesPlus;
{$IFDEF FPC}
{$MODE Delphi}
Line 691 ⟶ 1,333:
writeln;
writeln(GetTickCount64-T0,' ms');
end.</langsyntaxhighlight>
{{out}}
<pre>The first 32 anti-primes plus are:
Line 699 ⟶ 1,341:
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use ntheory 'divisors';
Line 710 ⟶ 1,352:
print("$l "), $m = $l, last if $n == divisors($l);
}
}</langsyntaxhighlight>
{{out}}
 
Line 718 ⟶ 1,360:
=={{header|Phix}}==
Uses the optimisation trick from pascal, of n:=power(2,next-1) when next is a prime>4.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>constant limit = 15
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
sequence res = repeat(0,limit)
<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">15</span>
integer next = 1
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">)</span>
atom n = 1
<span style="color: #004080;">integer</span> <span style="color: #000000;">next</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
while next<=limit do
<span style="color: #004080;">atom</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
integer k = length(factors(n,1))
<span style="color: #008080;">while</span> <span style="color: #000000;">next</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">limit</span> <span style="color: #008080;">do</span>
if k=next then
<span style="color: #004080;">integer</span> <span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">))</span>
res[k] = n
<span style="color: #008080;">if</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">next</span> <span style="color: #008080;">then</span>
next += 1
<span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span>
if next>4 and is_prime(next) then
<span style="color: #000000;">next</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
n := power(2,next-1)-1 -- (-1 for +=1 next)
<span style="color: #008080;">if</span> <span style="color: #000000;">next</span><span style="color: #0000FF;">></span><span style="color: #000000;">4</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">next</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
end if
<span style="color: #000000;">n</span> <span style="color: #0000FF;">:=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">next</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span> <span style="color: #000080;font-style:italic;">-- (-1 for +=1 next)</span>
end if
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
n += 1
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
end while
<span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
printf(1,"The first %d terms are: %v\n",{limit,res})</lang>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</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;">"The first %d terms are: %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
The first 15 terms are: {1,2,4,6,16,18,64,66,100,112,1024,1035,4096,4288,4624}
</pre>
You can raise the limit to 32, the 25th takes about 4s but the rest are all near-instant, however I lost patience waiting for the 33rd.<br>
<small>(The last two trailing .0 just mean "not a 31-bit integer" and don't appear when run on 64 bit.)</small>
<pre>
The first 32 terms are: {1,2,4,6,16,18,64,66,100,112,1024,1035,4096,4288,4624,
4632,65536,65572,262144,262192,263169,269312,4194304,
4194306,4477456,4493312,4498641,4498752,268435456,
268437200,1073741824.0,1073741830.0}
</pre>
 
=={{header|PL/I}}==
 
See [[#Polyglot:PL/I and PL/M]]
 
=={{header|PL/M}}==
{{Trans|Go}} via Algol 68
<syntaxhighlight lang="pli">100H: /* FIND THE SMALLEST NUMBER > THE PREVIOUS ONE WITH EXACTLY N DIVISORS */
 
/* CP/M BDOS SYSTEM CALL */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
/* CONSOLE OUTPUT ROUTINES */
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PR$NL: PROCEDURE; CALL PR$STRING( .( 0DH, 0AH, '$' ) ); END;
PR$NUMBER: PROCEDURE( N );
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR( 6 ) BYTE INITIAL( '.....$' ), W BYTE;
N$STR( W := LAST( N$STR ) - 1 ) = '0' + ( ( V := N ) MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL PR$STRING( .N$STR( W ) );
END PR$NUMBER;
 
/* TASK */
 
/* RETURNS THE DIVISOR COUNT OF N */
COUNT$DIVISORS: PROCEDURE( N )ADDRESS;
DECLARE N ADDRESS;
DECLARE ( I, I2, COUNT ) ADDRESS;
COUNT = 0;
I = 1;
DO WHILE( ( I2 := I * I ) < N );
IF N MOD I = 0 THEN COUNT = COUNT + 2;
I = I + 1;
END;
IF I2 = N THEN RETURN ( COUNT + 1 ); ELSE RETURN ( COUNT );
END COUNT$DIVISORS ;
DECLARE MAX LITERALLY '15';
DECLARE ( I, NEXT ) ADDRESS;
 
CALL PR$STRING( .'THE FIRST $' );
CALL PR$NUMBER( MAX );
CALL PR$STRING( .' TERMS OF THE SEQUENCE ARE:$' );
NEXT = 1;
I = 1;
DO WHILE( NEXT <= MAX );
IF NEXT = COUNT$DIVISORS( I ) THEN DO;
CALL PR$CHAR( ' ' );
CALL PR$NUMBER( I );
NEXT = NEXT + 1;
END;
I = I + 1;
END;
 
EOF</syntaxhighlight>
{{out}}
<pre>
THE FIRST 15 TERMS OF THE SEQUENCE ARE: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
 
See also [[#Polyglot:PL/I and PL/M]]
 
=={{header|Polyglot:PL/I and PL/M}}==
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
Should work with many PL/I implementations.
<br>
The PL/I include file "pg.inc" can be found on the [[Polyglot:PL/I and PL/M]] page.
Note the use of text in column 81 onwards to hide the PL/I specifics from the PL/M compiler.
{{Trans|PL/M}}
<syntaxhighlight lang="pli"> /* FIND THE SMALLEST NUMBER > THE PREVIOUS ONE WITH EXACTLY N DIVISORS */
 
sequence_100H: procedure options (main);
 
/* PROGRAM-SPECIFIC %REPLACE STATEMENTS MUST APPEAR BEFORE THE %INCLUDE AS */
/* E.G. THE CP/M PL/I COMPILER DOESN'T LIKE THEM TO FOLLOW PROCEDURES */
/* PL/I */
%replace maxnumber by 15;
/* PL/M */ /*
DECLARE MAXNUMBER LITERALLY '15';
/* */
 
/* PL/I DEFINITIONS */
%include 'pg.inc';
/* PL/M DEFINITIONS: CP/M BDOS SYSTEM CALL AND CONSOLE I/O ROUTINES, ETC. */ /*
DECLARE BINARY LITERALLY 'ADDRESS', CHARACTER LITERALLY 'BYTE';
DECLARE FIXED LITERALLY ' ', BIT LITERALLY 'BYTE';
DECLARE STATIC LITERALLY ' ', RETURNS LITERALLY ' ';
DECLARE FALSE LITERALLY '0', TRUE LITERALLY '1';
DECLARE HBOUND LITERALLY 'LAST', SADDR LITERALLY '.';
BDOSF: PROCEDURE( FN, ARG )BYTE;
DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
PRCHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PRSTRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PRNL: PROCEDURE; CALL PRCHAR( 0DH ); CALL PRCHAR( 0AH ); END;
PRNUMBER: PROCEDURE( N );
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR( 6 ) BYTE, W BYTE;
N$STR( W := LAST( N$STR ) ) = '$';
N$STR( W := W - 1 ) = '0' + ( ( V := N ) MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL BDOS( 9, .N$STR( W ) );
END PRNUMBER;
MODF: PROCEDURE( A, B )ADDRESS;
DECLARE ( A, B )ADDRESS;
RETURN( A MOD B );
END MODF;
MIN: PROCEDURE( A, B ) ADDRESS;
DECLARE ( A, B ) ADDRESS;
IF A < B THEN RETURN( A ); ELSE RETURN( B );
END MIN;
/* END LANGUAGE DEFINITIONS */
 
/* TASK */
 
COUNTDIVISORS: PROCEDURE( N )RETURNS /* THE DIVISOR COUNT OF N */ (
FIXED BINARY )
;
DECLARE N FIXED BINARY;
DECLARE ( I, I2, COUNT ) FIXED BINARY;
COUNT = 0;
I = 1;
I2 = 1;
DO WHILE( I2 < N );
IF MODF( N, I ) = 0 THEN COUNT = COUNT + 2;
I = I + 1;
I2 = I * I;
END;
IF I2 = N THEN RETURN ( COUNT + 1 ); ELSE RETURN ( COUNT );
END COUNTDIVISORS ;
DECLARE ( I, NEXT ) FIXED BINARY;
 
CALL PRSTRING( SADDR( 'THE FIRST $' ) );
CALL PRNUMBER( MAXNUMBER );
CALL PRSTRING( SADDR( ' TERMS OF THE SEQUENCE ARE:$' ) );
NEXT = 1;
I = 1;
DO WHILE( NEXT <= MAXNUMBER );
IF NEXT = COUNTDIVISORS( I ) THEN DO;
CALL PRCHAR( ' ' );
CALL PRNUMBER( I );
NEXT = NEXT + 1;
END;
I = I + 1;
END;
 
EOF: end sequence_100H;</syntaxhighlight>
{{out}}
<pre>
THE FIRST 15 TERMS OF THE SEQUENCE ARE: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
 
=={{header|Python}}==
<syntaxhighlight lang="python">
<lang Python>
def divisors(n):
divs = [1]
Line 771 ⟶ 1,581:
for item in sequence(15):
print(item)
</syntaxhighlight>
</lang>
<b>Output:</b>
<syntaxhighlight lang="python">
<lang Python>
1
2
Line 789 ⟶ 1,599:
4288
4624
</syntaxhighlight>
</lang>
 
=={{header|Quackery}}==
 
<code>factors</code> is defined at [[Factors of an integer#Quackery]].
 
<syntaxhighlight lang="quackery"> [ stack ] is terms ( --> s )
 
[ temp put
[] terms put
0 1
[ dip 1+
over factors size
over = if
[ over
terms take
swap join
terms put
1+ ]
terms share size
temp share = until ]
terms take
temp release
dip 2drop ] is task ( n --> [ )
 
15 task echo</syntaxhighlight>
 
{{out}}
 
<pre>[ 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624 ]</pre>
 
=={{header|R}}==
<syntaxhighlight lang="rsplus">#Need to add 1 to account for skipping n. Not the most efficient way to count divisors, but quite clear.
divisorCount <- function(n) length(Filter(function(x) n %% x == 0, seq_len(n %/% 2))) + 1
A06954 <- function(terms)
{
out <- 1
while((resultCount <- length(out)) != terms)
{
n <- resultCount + 1
out[n] <- out[resultCount]
while(divisorCount(out[n]) != n) out[n] <- out[n] + 1
}
out
}
print(A06954(15))</syntaxhighlight>
{{out}}
<pre>[1] 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>
 
=={{header|Raku}}==
Line 795 ⟶ 1,652:
{{works with|Rakudo|2019.03}}
 
<syntaxhighlight lang="raku" perl6line>sub div-count (\x) {
return 2 if x.is-prime;
+flat (1 .. x.sqrt.floor).map: -> \d {
Line 807 ⟶ 1,664:
put "First $limit terms of OEIS:A069654";
put (1..$limit).map: -> $n { my $ = $m = first { $n == .&div-count }, $m..Inf };
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 820 ⟶ 1,677:
 
Optimization was included when examining &nbsp; ''even'' &nbsp; or &nbsp; ''odd'' &nbsp; index numbers &nbsp; (determine how much to increment the &nbsp; '''do''' &nbsp; loop).
<langsyntaxhighlight lang="rexx">/*REXX program finds and displays N numbers of the "anti─primes plus" sequence. */
parse arg N . /*obtain optional argument from the CL.*/
if N=='' | N=="," then N= 15 /*Not specified? Then use the default.*/
Line 831 ⟶ 1,688:
say center(#, 8) right(i, 15) /*display the index and the anti─prime.*/
end /*i*/
exit 0 /*stick a fork in it, we're all done. */
 
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
#divs: procedure; parse arg x 1 y /*X and Y: both set from 1st argument.*/
Line 854 ⟶ 1,710:
else if k*k>x then leave /*only divide up to the √ x */
end /*k*/ /* [↑] this form of DO loop is faster.*/
return # + 1 /*bump "proper divisors" to "divisors".*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 876 ⟶ 1,732:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : ANti-primes
 
Line 914 ⟶ 1,770:
next
return ansum
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 926 ⟶ 1,782:
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49g}}
≪ {1}
2 ROT '''FOR''' j
DUP DUP SIZE GET
'''DO''' 1 + '''UNTIL''' DUP DIVIS SIZE j == '''END'''
+
'''NEXT '''
≫ '<span style="color:blue">TASK</span>' STO
 
15 <span style="color:blue">TASK</span>
{{out}}
<pre>
1: {1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624}
</pre>
Runs in 10 minutes 55 on a HP-50g.
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'prime'
def num_divisors(n)
Line 945 ⟶ 1,818:
 
p seq.take(15)
</syntaxhighlight>
</lang>
{{out}}
<pre>[1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624]
Line 951 ⟶ 1,824:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func n_divisors(n, from=1) {
from..Inf -> first_by { .sigma0 == n }
}
Line 957 ⟶ 1,830:
with (1) { |from|
say 15.of { from = n_divisors(_+1, from) }
}</langsyntaxhighlight>
{{out}}
<pre>
[1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624]
</pre>
 
=={{header|Swift}}==
Includes an optimization borrowed from the Pascal example above.
<syntaxhighlight lang="swift">// See https://en.wikipedia.org/wiki/Divisor_function
func divisorCount(number: Int) -> Int {
var n = number
var total = 1
// Deal with powers of 2 first
while n % 2 == 0 {
total += 1
n /= 2
}
// Odd prime factors up to the square root
var p = 3
while p * p <= n {
var count = 1
while n % p == 0 {
count += 1
n /= p
}
total *= count
p += 2
}
// If n > 1 then it's prime
if n > 1 {
total *= 2
}
return total
}
 
let limit = 32
var n = 1
var next = 1
while next <= limit {
if next == divisorCount(number: n) {
print(n, terminator: " ")
next += 1
if next > 4 && divisorCount(number: next) == 2 {
n = 1 << (next - 1) - 1;
}
}
n += 1
}
print()</syntaxhighlight>
 
{{out}}
<pre>
1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624 4632 65536 65572 262144 262192 263169 269312 4194304 4194306 4477456 4493312 4498641 4498752 268435456 268437200 1073741824 1073741830
</pre>
 
=={{header|Wren}}==
{{trans|Phix}}
{{libheader|Wren-math}}
<syntaxhighlight lang="wren">import "./math" for Int
 
var limit = 24
var res = List.filled(limit, 0)
var next = 1
var n = 1
while (next <= limit) {
var k = Int.divisors(n).count
if (k == next) {
res[k-1] = n
next = next + 1
if (next > 4 && Int.isPrime(next)) n = 2.pow(next-1) - 1
}
n = n + 1
}
System.print("The first %(limit) terms are:")
System.print(res)</syntaxhighlight>
 
{{out}}
<pre>
The first 24 terms are:
[1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624, 4632, 65536, 65572, 262144, 262192, 263169, 269312, 4194304, 4194306]
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">func Divs(N); \Count divisors of N
int N, D, C;
[C:= 0;
if N > 1 then
[D:= 1;
repeat if rem(N/D) = 0 then C:= C+1;
D:= D+1;
until D >= N;
];
return C;
];
 
int An, N;
[An:= 1; N:= 0;
loop [if Divs(An) = N then
[IntOut(0, An); ChOut(0, ^ );
N:= N+1;
if N >= 15 then quit;
];
An:= An+1;
];
]</syntaxhighlight>
 
{{out}}
<pre>
1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
</pre>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn countDivisors(n)
{ [1..(n).toFloat().sqrt()] .reduce('wrap(s,i){ s + (if(0==n%i) 1 + (i!=n/i)) },0) }</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">n:=15;
println("The first %d anti-primes plus are:".fmt(n));
(1).walker(*).tweak(
fcn(n,rn){ if(rn.value==countDivisors(n)){ rn.inc(); n } else Void.Skip }.fp1(Ref(1)))
.walk(n).concat(" ").println();</langsyntaxhighlight>
{{out}}
<pre>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/289476...353782"