Sequence: smallest number greater than previous term with exactly n divisors: Difference between revisions
Sequence: smallest number greater than previous term with exactly n divisors (view source)
Revision as of 13:51, 28 August 2022
, 1 year agosyntax highlighting fixup automation
Drkameleon (talk | contribs) (Added Arturo implementation) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 22:
{{trans|Python}}
<
V divs = [1]
L(ii) 2 .< Int(n ^ 0.5) + 3
Line 49:
L(item) sequence(15)
print(item)</
{{out}}
Line 72:
=={{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.
<
CARD i,count
Line 105:
PrintC(a)
OD
RETURN</
{{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]
Line 114:
=={{header|Ada}}==
{{trans|Go}}
<
procedure Show_Sequence is
Line 153:
begin
Show (15);
end Show_Sequence;</
{{out}}
Line 161:
=={{header|ALGOL 68}}==
{{trans|Go}} with a small optimisation.
<
PROC count divisors = ( INT n )INT:
Line 183:
OD
END</
{{out}}
<pre>
Line 191:
=={{header|ALGOL W}}==
{{Trans|Go}}...via Algol 68 and with a small optimisation.
<
integer max, next, i;
Line 219:
end;
write()
end.</
{{out}}
<pre>
Line 227:
=={{header|Arturo}}==
<
next: new 1
MAX: 15
Line 237:
inc 'i
]
print ""</
{{out}}
Line 245:
=={{header|AutoHotkey}}==
{{trans|Go}}
<
next := 1, i := 1
while (next <= MAX)
Line 258:
count += (A_Index = n/A_Index) ? 1 : 2
return count
}</
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">
# syntax: GAWK -f SEQUENCE_SMALLEST_NUMBER_GREATER_THAN_PREVIOUS_TERM_WITH_EXACTLY_N_DIVISORS.AWK
# converted from Kotlin
Line 287:
return(count)
}
</syntaxhighlight>
{{out}}
<pre>
Line 295:
=={{header|C}}==
{{trans|Go}}
<
#define MAX 15
Line 323:
printf("\n");
return 0;
}</
{{out}}
Line 333:
=={{header|C++}}==
{{trans|C}}
<
#define MAX 15
Line 362:
cout << endl;
return 0;
}</
{{out}}
Line 371:
===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!]<
#include <chrono>
Line 392:
i = (1 << (nxt - 1)) - 1; } i++; } while (nxt <= MAX);
printf("%d ms", (int)(duration<double>(steady_clock::now() - st).count() * 1000));
}</
{{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>
Line 400:
{{trans|Go}}
<
var count = 0
var i = 1
Line 427:
}
print()</
{{out}}
Line 436:
=={{header|F_Sharp|F#}}==
===First 28 are easy with a Naive implementation===
<
// 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
Line 442:
A069654 |> Seq.take 28|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
{{out}}
<pre>
Line 448:
</pre>
=={{header|Factor}}==
<
: next ( n num -- n' num' )
Line 456:
[ 2 1 ] dip [ [ next ] keep ] replicate 2nip ;
"The first 15 terms of the sequence are:" print 15 A069654 .</
{{out}}
<pre>
Line 464:
=={{header|FreeBASIC}}==
<
function divisors(byval n as ulongint) as uinteger
Line 489:
wend
print
end</
{{out}}<pre> 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>
=={{header|Go}}==
<
import "fmt"
Line 521:
}
fmt.Println()
}</
{{out}}
Line 529:
</pre>
=={{header|Haskell}}==
<
sequence_A069654 :: [(Int,Int)]
Line 540:
main :: IO ()
main = mapM_ (uncurry $ printf "a(%2d)=%5d\n") $ take 15 sequence_A069654</
{{out}}
<pre>a( 1)= 1
Line 560:
=={{header|J}}==
<syntaxhighlight lang="j">
sieve=: 3 :0
NB. sieve y returns a vector of y boxes.
Line 578:
(</.~ {."1) (,. i.@:#)tally
)
</syntaxhighlight>
<pre>
Line 706:
=={{header|Java}}==
{{trans|C}}
<
static int count_divisors(int n) {
Line 732:
System.out.println();
}
}</
{{out}}
Line 744:
{{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:
Line 764:
"First 15 terms of OEIS sequence A069654: ",
[limit(15; A06954)]</
{{out}}
<pre>
Line 774:
=={{header|Julia}}==
{{trans|Perl}}
<
function numfactors(n)
Line 800:
A06954(15)
</
<pre>
First 15 terms of OEIS sequence A069654:
Line 808:
=={{header|Kotlin}}==
{{trans|Go}}
<
const val MAX = 15
Line 836:
}
println()
}</
{{output}}
Line 845:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
highest = 0;
filter = {};
Line 856:
{r, res}
]
Take[filter, 15]</
{{out}}
<pre>{1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624}</pre>
=={{header|Nim}}==
<
const MAX = 15
Line 884:
inc next
inc i
write(stdout, "\n")</
{{out}}
<pre>
Line 897:
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!]
<
{$IFDEF FPC}
{$MODE Delphi}
Line 967:
writeln;
writeln(GetTickCount64-T0,' ms');
end.</
{{out}}
<pre>The first 32 anti-primes plus are:
Line 975:
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use ntheory 'divisors';
Line 986:
print("$l "), $m = $l, last if $n == divisors($l);
}
}</
{{out}}
Line 994:
=={{header|Phix}}==
Uses the optimisation trick from pascal, of n:=power(2,next-1) when next is a prime>4.
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">15</span>
Line 1,012:
<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>
<!--</
{{out}}
<pre>
Line 1,032:
=={{header|PL/M}}==
{{Trans|Go}} via Algol 68
<
/* CP/M BDOS SYSTEM CALL */
Line 1,082:
END;
EOF</
{{out}}
<pre>
Line 1,097:
Note the use of text in column 81 onwards to hide the PL/I specifics from the PL/M compiler.
{{Trans|PL/M}}
<
sequence_100H: procedure options (main);
Line 1,177:
END;
EOF: end sequence_100H;</
{{out}}
<pre>
Line 1,184:
=={{header|Python}}==
<syntaxhighlight lang="python">
def divisors(n):
divs = [1]
Line 1,215:
for item in sequence(15):
print(item)
</syntaxhighlight>
<b>Output:</b>
<syntaxhighlight lang="python">
1
2
Line 1,233:
4288
4624
</syntaxhighlight>
=={{header|Quackery}}==
Line 1,239:
<code>factors</code> is defined at [[Factors of an integer#Quackery]].
<
[ temp put
Line 1,258:
dip 2drop ] is task ( n --> [ )
15 task echo</
{{out}}
Line 1,265:
=={{header|R}}==
<
divisorCount <- function(n) length(Filter(function(x) n %% x == 0, seq_len(n %/% 2))) + 1
A06954 <- function(terms)
Line 1,278:
out
}
print(A06954(15))</
{{out}}
<pre>[1] 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>
Line 1,286:
{{works with|Rakudo|2019.03}}
<syntaxhighlight lang="raku"
return 2 if x.is-prime;
+flat (1 .. x.sqrt.floor).map: -> \d {
Line 1,298:
put "First $limit terms of OEIS:A069654";
put (1..$limit).map: -> $n { my $ = $m = first { $n == .&div-count }, $m..Inf };
</syntaxhighlight>
{{out}}
<pre>
Line 1,311:
Optimization was included when examining ''even'' or ''odd'' index numbers (determine how much to increment the '''do''' loop).
<
parse arg N . /*obtain optional argument from the CL.*/
if N=='' | N=="," then N= 15 /*Not specified? Then use the default.*/
Line 1,344:
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".*/</
{{out|output|text= when using the default input:}}
<pre>
Line 1,366:
=={{header|Ring}}==
<
# Project : ANti-primes
Line 1,404:
next
return ansum
</syntaxhighlight>
{{out}}
<pre>
Line 1,418:
=={{header|Ruby}}==
<
def num_divisors(n)
Line 1,435:
p seq.take(15)
</syntaxhighlight>
{{out}}
<pre>[1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624]
Line 1,441:
=={{header|Sidef}}==
<
from..Inf -> first_by { .sigma0 == n }
}
Line 1,447:
with (1) { |from|
say 15.of { from = n_divisors(_+1, from) }
}</
{{out}}
<pre>
Line 1,455:
=={{header|Swift}}==
Includes an optimization borrowed from the Pascal example above.
<
func divisorCount(number: Int) -> Int {
var n = number
Line 1,495:
n += 1
}
print()</
{{out}}
Line 1,505:
{{trans|Phix}}
{{libheader|Wren-math}}
<
var limit = 24
Line 1,521:
}
System.print("The first %(limit) terms are:")
System.print(res)</
{{out}}
Line 1,530:
=={{header|XPL0}}==
<
int N, D, C;
[C:= 0;
Line 1,551:
An:= An+1;
];
]</
{{out}}
Line 1,559:
=={{header|zkl}}==
<
{ [1..(n).toFloat().sqrt()] .reduce('wrap(s,i){ s + (if(0==n%i) 1 + (i!=n/i)) },0) }</
<
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();</
{{out}}
<pre>
|