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

{{trans|Python}}

 

V divs = [1]

L(ii) 2 .< Int(n ^ 0.5) + 3

 

L(item) sequence(15)

 

{{out}}

192

144

</pre>

 

=={{header|ALGOL 68}}==

{{Trans|C}}

 

PROC count divisors = ( INT n )INT:

print( ( newline ) )

{{out}}

<pre>

1 2 4 6 16 12 64 24 36 48 1024 60 4096 192 144

</pre>

 

=={{header|AutoHotkey}}==

{{trans|Go}}

seq := [], n := 0

while (n < max)

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, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f SEQUENCE_SMALLEST_NUMBER_WITH_EXACTLY_N_DIVISORS.AWK

# converted from Kotlin

return(count)

}

{{out}}

<pre>

first 15 terms: 1 2 4 6 16 12 64 24 36 48 1024 60 4096 192 144

</pre>

 

=={{header|C}}==

{{trans|Go}}

 

#define MAX 15

printf("\n");

return 0;

 

{{out}}

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

{{trans|C}}

 

#define MAX 15

cout << endl;

return 0;

 

{{out}}

1 2 4 6 16 12 64 24 36 48 1024 60 0 192 144

</pre>

 

=={{header|F_Sharp|F#}}==

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]

// Find Antı-Primes plus. Nigel Galloway: April 9th., 2019

// Increasing the value 14 will increase the number of anti-primes plus found

let n=Seq.concat(Seq.scan(fun n g->fE n (fG g)) (seq[(2147483647,1,1I)]) fI)|>List.ofSeq|>List.groupBy(fun(_,n,_)->n)|>List.sortBy(fun(n,_)->n)|>List.takeWhile(fun(n,_)->fL n)

for n,g in n do printfn "%d->%A" n (g|>List.map(fun(_,_,n)->n)|>List.min)

{{out}}

<pre>

 

=={{header|Factor}}==

prettyprint sequences ;

 

] lmap-lazy ;

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

function divisors(byval n as ulongint) as uinteger

next i

print

{{out}}<pre> 1 2 4 6 16 12 64 24 36 48 1024 60 4096 192 144</pre>

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println(seq)

 

{{out}}

=={{header|Haskell}}==

Without any subtlety or optimisation, but still fast at this modest scale:

 

a005179 :: [Int]

a005179 =

 

properDivisors :: Int -> [Int]

properDivisors =

{{Out}}

<pre>[1,2,4,6,16,12,64,24,36,48,1024,60,4096,192,144]</pre>

Defining a generator in terms of re-usable generic functions, and taking the first 15 terms:

 

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>[1,2,4,6,16,12,64,24,36,48,1024,60,4096,192,144]</pre>

=={{header|J}}==

Rather than factoring by division, this algorithm uses a sieve to tally the factors. Of the whole numbers below ten thousand these are the smallest with n divisors. The list is fully populated through the first 15.

sieve=: 3 :0

range=. <. + i.@:|@:-

/:~({./.~ {."1) tally,.i.#tally

)

<pre>

|: sieve 10000

=={{header|Java}}==

{{trans|C}}

 

public class OEIS_A005179 {

System.out.println(Arrays.toString(seq));

}

 

{{out}}

[1, 2, 4, 6, 16, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144]

</pre>

 

=={{header|Julia}}==

{{works with|Julia|1.2}}

 

numfactors(n) = reduce(*, e+1 for (_,e) in factor(n); init=1)

println("The first 15 terms of the sequence are:")

println(map(A005179, 1:15))

<pre>

First 15 terms of OEIS sequence A005179:

=={{header|Kotlin}}==

{{trans|Go}}

 

const val MAX = 15

}

println(seq.asList())

 

{{output}}

 

=={{header|Maple}}==

with(NumberTheory):

 

seq(sequenceValue(number), number = 1..15);

 

{{out}}<pre>

1, 2, 4, 6, 16, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144

</pre>

 

=={{header|Nanoquery}}==

{{trans|Java}}

count = 0

for (i = 1) ((i * i) <= n) (i += 1)

end

end

{{out}}

<pre>The first 15 terms of the sequence are:

=={{header|Nim}}==

{{trans|Kotlin}}

 

const MAX = 15

inc n

inc i

{{out}}

<pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use ntheory 'divisors';

print "$l " and last if $n == divisors($l);

}

{{out}}

<pre>First 15 terms of OEIS: A005179

=={{header|Phix}}==

===naive===

{{out}}

<pre>

Using the various formula from the OEIS:A005179 link above.<br>

get_primes() and product() have recently been added as new builtins, if necessary see [[Extensible_prime_generator#Phix|Extensible_prime_generator]] and [[Deconvolution/2D%2B#Phix]].

Note: the f[2]>2 test should really be something more like >log(get_primes(-(lf-1))[$])/log(2),

apparently, but everything seems ok within the IEEE 754 53/64 bit limits this imposes.

and adj are not exactly, um, scientific. Completes in about 0.1s

{{libheader|Phix/mpfr}}

{{out}}

<pre>

2^k*3^4*p (made up rule):4

1440 (complete fudge):1

</pre>

 

=={{header|Python}}==

===Procedural===

divs = [1]

for ii in range(2, int(n ** 0.5) + 3):

if __name__ == '__main__':

for item in sequence(15):

{{Out}}

<pre>1

 

Not optimized, but still fast at this modest scale.

 

from itertools import accumulate, chain, count, groupby, islice, product

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>[1, 2, 4, 6, 16, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144]</pre>

 

=={{header|Raku}}==

{{works with|Rakudo|2019.03}}

 

return 2 if x.is-prime;

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

put (1..$limit).map: -> $n { first { $n == .&div-count }, 1..Inf };

 

{{out}}

<pre>First 15 terms of OEIS:A005179

=={{header|REXX}}==

===some optimization===

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

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

else if k*k>x then leave /*only divide up to √ x */

end /*k*/ /* [↑] this form of DO loop is faster.*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

===with memorization===

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

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

else if k*k>x then leave /*only divide up to √ x */

end /*k*/ /* [↑] this form of DO loop is faster.*/

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

def num_divisors(n)

 

p (1..15).map{|n| first_with_num_divs(n) }

{{out}}

<pre>

[1, 2, 4, 6, 16, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144]

</pre>

 

=={{header|Sidef}}==

1..Inf -> first_by { .sigma0 == n }

}

 

 

{{out}}

[1, 2, 4, 6, 16, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144]

</pre>

 

=={{header|Swift}}==

func divisorCount(number: Int) -> Int {

var n = number

print(n, terminator: " ")

}

 

{{out}}

 

=={{header|Tcl}}==

set cnt 0

for {set d 1} {($d * $d) <= $n} {incr d} {

 

show A005179 1 15

{{out}}

<pre>A005179(1..15) =

=={{header|Wren}}==

{{libheader|Wren-math}}

 

var limit = 22

}

System.print("The first %(limit) terms are:")

 

{{out}}

The first 22 terms are:

[1, 2, 4, 6, 16, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144, 120, 65536, 180, 262144, 240, 576, 3072]

</pre>

 

=={{header|zkl}}==

{ [1.. n.toFloat().sqrt()].reduce('wrap(s,i){ s + (if(0==n%i) 1 + (i!=n/i)) },0) }

A005179w:=(1).walker(*).tweak(fcn(n){

if(n<d and not cache.find(d)) cache[d]=N;

}

println("First %d terms of OEIS:A005179".fmt(N));

{{out}}

<pre>