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

=={{header|C}}==

{{trans|C++}}

#include <stdbool.h>

#include <stdint.h>

return 0;

{{out}}

<pre>A073916(1) = 1

=={{header|C++}}==

{{trans|Java}}

#include <vector>

return 0;

{{out}}

<pre>A073916(1) = 1

=={{header|D}}==

{{trans|Java}}

import std.math;

import std.stdio;

writeln("A073916(", n, ") = ", OEISA073916(n));

}

{{out}}

<pre>A073916(1) = 1

=={{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>

=={{header|FreeBASIC}}==

But it takes an "eternity" to resolve.

Dim As Ulongint m, p

Dim As Ulongint limit = 18446744073709551615

Next m

Next n

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)

Implementation:

A073916=: {{

if.1 p: y do. (p:^x:)y-1 return.

(y-1){r

}}"0

Task example:

(,. A073916) 1+i.20

1 1

19 740195513856780056217081017732809

20 1520

=={{header|Java}}==

Replace translation with Java native implementation.

import java.math.BigInteger;

import java.util.ArrayList;

}

{{out}}

'''Preliminaries'''

# To maintain precision:

end

end;

'''The Task'''

def nth_with_n_divisors:

| [limit( .; primes)] as $primes

"The first 33 terms in the sequence are:",

{{out}}

<pre>

=={{header|Julia}}==

function countdivisors(n)

nthwithndivisors(35)

<pre>

1 : 1

=={{header|Kotlin}}==

{{trans|Go}}

import java.math.BigInteger

}

}

{{output}}

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Length[Divisors[n]], {n,

200000}]; t = {}; n = 0; ok = True; While[ok, n++;

c = Flatten[Position[d, n, 1, n]];

If[Length[c] >= n, AppendTo[t, c[[n]]], ok = False]]];

{{out}}

<pre>{1,3,25,14,14641,44,24137569,70,1089,405,819628286980801,160,22563490300366186081,2752,9801,462,21559177407076402401757871041,1044,740195513856780056217081017732809,1520,141376,84992,1658509762573818415340429240403156732495289,1170}</pre>

{{libheader|bignum}}

This is a translation of the fast Go version. It runs in about 23s on our laptop.

import bignum

k > records[cd].num and (d == 1 or d == 2 and not cd.isOdd):

records[cd].num = k

{{out}}

{{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.

<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;">24</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{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).

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"completed in %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)})</span>

{{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>

=={{header|Ruby}}==

{{trans|Java}}

return false if n < 2

return n == 2 if n % 2 == 0

print "A073916(", n, ") = ", OEISA073916(n), "\n"

n = n + 1

{{out}}

<pre>A073916(1) = 1

=={{header|Sidef}}==

n.prime**(n-1)

}

}

{{out}}

<pre>

{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

import "/big" for BigInt

import "/fmt" for Fmt

}

}

{{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>