Sequence: nth number with exactly n divisors: Difference between revisions

:*[[Sequence: smallest number greater than previous term with exactly n divisors]]

:*[[Sequence: smallest number with exactly n divisors]]

 

=={{header|Factor}}==

This makes use of most of the optimizations discussed in the Go example.

lists.lazy.examples literals math math.functions math.primes

math.primes.factors math.ranges sequences ;

: main ( -- ) 45 [1,b] [ dup fn "%2d : %d\n" printf ] each ;

 

{{out}}

<pre>

45 : 327184

</pre>

 

=={{header|Go}}==

 

The remaining terms (up to the 33rd) are not particularly large and so are calculated by brute force.

 

import (

}

}

 

{{out}}

3. While searching for the nth number with exactly n divisors, where feasible a record is kept of any numbers found to have exactly k divisors (k > n) so that the search for these numbers can start from a higher base.

 

 

import (

}

}

 

{{out}}

</pre>

=={{header|Haskell}}==

import Math.NumberTheory.ArithmeticFunctions (divisorCount)

import Math.NumberTheory.Primes (Prime, unPrime)

 

main :: IO ()

{{out}}

<pre>(1,1)

(34,9764864)

(35,446265625)</pre>

 

=={{header|Java}}==

Replace translation with Java native implementation.

 

import java.math.BigInteger;

import java.util.ArrayList;

 

}

 

{{out}}

A073916(44) = 240640

A073916(45) = 327184

</pre>

 

=={{header|Julia}}==

 

function countdivisors(n)

 

nthwithndivisors(35)

<pre>

1 : 1

=={{header|Kotlin}}==

{{trans|Go}}

 

import java.math.BigInteger

}

}

 

{{output}}

33 : 12166144

</pre>

 

=={{header|Perl}}==

{{libheader|ntheory}}

{{trans|Raku}}

use warnings;

use bigint;

}

}

{{out}}

<pre>First 20 terms of OEIS:A073916

Certainly not the fastest way to do it, hence the relatively small limit of 24, which takes less than 0.4s,<br>

whereas a limit of 25 would need to invoke factors() 52 million times which would no doubt take a fair while.

{{out}}

<pre>

===cheating slightly===

No real patterns that I could see here, but you can still identify and single out the troublemakers (of which there are about 30).

{{out}}

<pre>

=={{header|Python}}==

This implementation exploits the fact that terms corresponding to a prime value for n are always the nth prime to the (n-1)th power.

def divisors(n):

divs = [1]

for item in sequence(15):

print(item)

<b>Output:</b>

1

3

2752

9801

 

=={{header|Raku}}==

[https://tio.run/##dVLbTsJAEH3nKw4IpgW6ATQY2QAao4kvmsijEFPoVpr05nZr2hh@yk/wx@p0CwUf3JfuzJwzc/ZMYyH9cVEk6RqO92ltojRUMJaZia8G6EihUhliBM9FxrzEiqUXCK5rPde3CTwEY1RLPqRirh9F0mSBHU9gzbB09m3Kk4a@SBJk6IDSCHIsc0wppsFwOCiYUmU@p1uzCSPvwzGx0/xdg74NorR9L/AU0UYDXmVutKKEUu9SxNS4VoldH0PGuryxx7xW7BXHGSqE2grYUto5w@Lu6YU6xqlC68GTiTrMUkIGCSIXz/ePi8nt4OriejhucY00qH8FM9k2j4U0JqO1rTbbowftcO@BQbcZLmGHDiVrlSa9WNdFFpcQC8M@asE6XplkiMY40YmhpR0evXvA/6ZIsK0iSRWidzq0PPK0VNo1tbH6Vunr/nwfyTWTueX7JyejyhOKTB2WSI1pWey8/mf4v9BerxRZavmLab/VYb1jXhS/ Try it online!]

 

return 2 if x.is-prime;

+flat (1 .. x.sqrt.floor).map: -> \d {

}

}

 

<pre>First 20 terms of OEIS:A073916

Programming note: &nbsp; this REXX version has minor optimization, and all terms of the sequence are determined (found) in order.

===little optimization===

parse arg N . /*obtain optional argument from the CL.*/

if N=='' | N=="," then N= 15 /*Not specified? Then use the default.*/

do j=11 by 6 until j*j>#; if # // j==0 | # // (J+2)==0 then return 0

end /*j*/ /* ___ */

{{out|output|text=&nbsp; when using the input: &nbsp; &nbsp; <tt> 45 </tt>}}

 

This REXX version (unlike the 1^st version), &nbsp; only goes through the numbers once, instead

of looking for numbers that have specific number of divisors.

parse arg N . /*obtain optional argument from the CL.*/

if N=='' | N=="," then N= 15 /*Not specified? Then use the default.*/

if #//(i+2)==0 then return 0

end /*i*/ /* ___ */

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

=={{header|Ring}}==

load "stdlib.ring"

 

 

see nl + "done..." + nl

{{out}}

<pre>

done...

</pre>

 

=={{header|Sidef}}==

n.prime**(n-1)

}

}

 

{{out}}

<pre>

{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

 

var MAX = 33

}

}

 

{{out}}

 

[[Extensible prime generator#zkl]] could be used instead.

p:=BI(1);

primes:=pmax.pump(List(0), p.nextPrime, "copy"); //-->(0,3,5,7,11,13,17,19,...)

}

}

{{out}}

<pre>