Sequence: smallest number greater than previous term with exactly n divisors: Difference between revisions
Thundergnat (talk | contribs) (→{{header|Perl 6}}: Add another interpretation of the task) |
(Realize in F#) |
||
Line 84: | Line 84: | ||
</pre> |
</pre> |
||
=={{header|F_Sharp|F#}}== |
|||
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)] |
|||
<lang fsharp> |
|||
// Find Antı-Primes plus. Nigel Galloway: April 9th., 2019 |
|||
// Increasing the value 14 will increase the number of anti-primes plus found |
|||
let fI=primes|>Seq.take 14|>Seq.map bigint|>List.ofSeq |
|||
let N=Seq.reduce(*) fI |
|||
let fG g=Seq.unfold(fun ((n,i,e) as z)->Some(z,(n+1,i+1,(e*g)))) (1,2,g) |
|||
let fE n i=n|>Seq.collect(fun(n,e,g)->Seq.map(fun(a,c,b)->(a,c*e,g*b)) (i|>Seq.takeWhile(fun(g,_,_)->g<=n))|> Seq.takeWhile(fun(_,_,n)->n<N)) |
|||
let fL=let mutable g=0 in (fun n->g<-g+1; n=g) |
|||
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) |
|||
</lang> |
|||
{{out}} |
|||
<pre> |
|||
1->1 |
|||
2->2 |
|||
3->4 |
|||
4->6 |
|||
5->16 |
|||
6->12 |
|||
7->64 |
|||
8->24 |
|||
9->36 |
|||
10->48 |
|||
11->1024 |
|||
12->60 |
|||
13->4096 |
|||
14->192 |
|||
15->144 |
|||
16->120 |
|||
17->65536 |
|||
18->180 |
|||
19->262144 |
|||
20->240 |
|||
21->576 |
|||
22->3072 |
|||
23->4194304 |
|||
24->360 |
|||
25->1296 |
|||
26->12288 |
|||
27->900 |
|||
28->960 |
|||
29->268435456 |
|||
30->720 |
|||
31->1073741824 |
|||
32->840 |
|||
33->9216 |
|||
34->196608 |
|||
35->5184 |
|||
36->1260 |
|||
37->68719476736 |
|||
38->786432 |
|||
39->36864 |
|||
40->1680 |
|||
41->1099511627776 |
|||
42->2880 |
|||
43->4398046511104 |
|||
44->15360 |
|||
45->3600 |
|||
46->12582912 |
|||
47->70368744177664 |
|||
48->2520 |
|||
49->46656 |
|||
50->6480 |
|||
51->589824 |
|||
52->61440 |
|||
53->4503599627370496 |
|||
54->6300 |
|||
55->82944 |
|||
56->6720 |
|||
57->2359296 |
|||
58->805306368 |
|||
Real: 00:00:01.079, CPU: 00:00:01.080, GC gen0: 47, gen1: 0 |
|||
</pre> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
<lang go>package main |
<lang go>package main |
Revision as of 16:17, 9 April 2019
The Anti-primes Plus sequence are the natural numbers in which each nth term has n divisors, including 1 and itself.
Task
Show the first 15 terms of this sequence.
C
<lang c>#include <stdio.h>
- define MAX 15
int count_divisors(int n) {
int i, count = 0; for (i = 1; i * i <= n; ++i) { if (!(n % i)) { if (i == n / i) count++; else count += 2; } } return count;
}
int main() {
int i, next = 1; printf("The first %d anti-primes plus are:\n", MAX); for (i = 1; next <= MAX; ++i) { if (next == count_divisors(i)) { printf("%d ", i); next++; } } printf("\n"); return 0;
}</lang>
- Output:
The first 15 anti-primes plus are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
C++
<lang cpp>#include <iostream>
- define MAX 15
using namespace std;
int count_divisors(int n) {
int count = 0; for (int i = 1; i * i <= n; ++i) { if (!(n % i)) { if (i == n / i) count++; else count += 2; } } return count;
}
int main() {
cout << "The first " << MAX << " anti-primes plus are:" << endl; for (int i = 1, next = 1; next <= MAX; ++i) { if (next == count_divisors(i)) { cout << i << " "; next++; } } cout << endl; return 0;
}</lang>
- Output:
The first 15 anti-primes plus are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
F#
This task uses Extensible Prime Generator (F#) <lang fsharp> // Find Antı-Primes plus. Nigel Galloway: April 9th., 2019 // Increasing the value 14 will increase the number of anti-primes plus found let fI=primes|>Seq.take 14|>Seq.map bigint|>List.ofSeq let N=Seq.reduce(*) fI let fG g=Seq.unfold(fun ((n,i,e) as z)->Some(z,(n+1,i+1,(e*g)))) (1,2,g) let fE n i=n|>Seq.collect(fun(n,e,g)->Seq.map(fun(a,c,b)->(a,c*e,g*b)) (i|>Seq.takeWhile(fun(g,_,_)->g<=n))|> Seq.takeWhile(fun(_,_,n)->n<N)) let fL=let mutable g=0 in (fun n->g<-g+1; n=g) 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) </lang>
- Output:
1->1 2->2 3->4 4->6 5->16 6->12 7->64 8->24 9->36 10->48 11->1024 12->60 13->4096 14->192 15->144 16->120 17->65536 18->180 19->262144 20->240 21->576 22->3072 23->4194304 24->360 25->1296 26->12288 27->900 28->960 29->268435456 30->720 31->1073741824 32->840 33->9216 34->196608 35->5184 36->1260 37->68719476736 38->786432 39->36864 40->1680 41->1099511627776 42->2880 43->4398046511104 44->15360 45->3600 46->12582912 47->70368744177664 48->2520 49->46656 50->6480 51->589824 52->61440 53->4503599627370496 54->6300 55->82944 56->6720 57->2359296 58->805306368 Real: 00:00:01.079, CPU: 00:00:01.080, GC gen0: 47, gen1: 0
Go
<lang go>package main
import "fmt"
func countDivisors(n int) int {
count := 0 for i := 1; i*i <= n; i++ { if n%i == 0 { if i == n/i { count++ } else { count += 2 } } } return count
}
func main() {
const max = 15 fmt.Println("The first", max, "anti-primes plus are:") for i, next := 1, 1; next <= max; i++ { if next == countDivisors(i) { fmt.Printf("%d ", i) next++ } } fmt.Println()
}</lang>
- Output:
The first 15 anti-primes plus are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
Java
<lang java>public class AntiPrimesPlus {
static int count_divisors(int n) { int count = 0; for (int i = 1; i * i <= n; ++i) { if (n % i == 0) { if (i == n / i) count++; else count += 2; } } return count; }
public static void main(String[] args) { final int max = 15; System.out.printf("The first %d anti-primes plus are:\n", max); for (int i = 1, next = 1; next <= max; ++i) { if (next == count_divisors(i)) { System.out.printf("%d ", i); next++; } } System.out.println(); }
}</lang>
- Output:
The first 15 anti-primes plus are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
Kotlin
<lang scala>// Version 1.3.21
const val MAX = 15
fun countDivisors(n: Int): Int {
var count = 0 var i = 1 while (i * i <= n) { if (n % i == 0) { count += if (i == n / i) 1 else 2 } i++ } return count
}
fun main() {
println("The first $MAX anti-primes plus are:") var i = 1 var next = 1 while (next <= MAX) { if (next == countDivisors(i)) { print("$i ") next++ } i++ } println()
}</lang>
- Output:
The first 15 anti-primes plus are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624
Perl 6
This task could be interpreted in a few ways.
Could be the sequence of the smallest natural numbers such that each an has n divisors: OEIS: A005179.
Or, could be the sequence where each term an is the smallest natural number > an-1 that has n divisors: OEIS: A069654.
Or, it could be something else entirely.
Whichever, here are a few possibilities.
<lang perl6>sub div-count (\x) {
return 2 if x.is-prime; +flat (1 .. x.sqrt.floor).map: -> \d { unless x % d { my \y = x div d; y == d ?? y !! (y, d) } }
}
put 'First 15 terms of OEIS: A005179'; put (1..15).map: -> $n { first { $n == .&div-count }, 1..Inf };
my $m = 1; put "\nFirst 15 terms of OEIS: A69654"; put (1..15).map: -> $n { my $r = $m = first { $n == .&div-count }, $m..Inf };
- Actually, since there is no verbiage in the task description about
- choosing the _smallest_ integer, for each term, this complies with
- a strict interpretation of the task requirements.
put "\nTechnically correct is the best kind of correct:"; my $antipp = (1..5000).race.classify: { .&div-count }; put (1..15).map: { $antipp{$_}.pick };</lang>
- Output:
First 15 terms of OEIS: A005179 1 2 4 6 16 12 64 24 36 48 1024 60 4096 192 144 First 15 terms of OEIS: A69654 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624 Technically correct is the best kind of correct: 1 1669 2209 4627 2401 1348 64 3070 3025 496 1024 2144 4096 1472 1936
Ring
<lang ring>
- Project : ANti-primes
see "working..." + nl see "wait for done..." + nl + nl see "the first 15 Anti-primes Plus are:" + nl + nl num = 1 n = 0 result = list(15) while num < 16
n = n + 1 div = factors(n) if div = num result[num] = n num = num + 1 ok
end see "[" for n = 1 to len(result)
if n < len(result) see string(result[n]) + "," else see string(result[n]) + "]" + nl + nl ok
next see "done..." + nl
func factors(an)
ansum = 2 if an < 2 return(1) ok for nr = 2 to an/2 if an%nr = 0 ansum = ansum+1 ok next return ansum
</lang>
- Output:
working... wait for done... the first 15 Anti-primes Plus are: [1,2,4,6,16,18,64,66,100,112,1024,1035,4096,4288,4624] done...
Sidef
a(n) is the smallest number with exactly n divisors (A005179). <lang ruby>func n_divisors(n) {
1..Inf -> first_by { .sigma0 == n }
}
say 15.of { n_divisors(_+1) }</lang>
- Output:
[1, 2, 4, 6, 16, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144]
a(n) is the smallest number > a(n-1) with exactly n divisors (A069654).
<lang ruby>func n_divisors(n, from=1) {
from..Inf -> first_by { .sigma0 == n }
}
with (1) { |from|
say 15.of { from = n_divisors(_+1, from) }
}</lang>
- Output:
[1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624]