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

The Anti-primes Plus sequence are the natural numbers in which each nth term has n divisors, including 1 and itself.

Sequence: smallest number greater than previous term with exactly n divisors is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Task

Show the first 15 terms of this sequence.

C

Translation of: Go

<lang c>#include <stdio.h>

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

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 

Kotlin

Translation of: Go

<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 

Ring

<lang ring>

1. 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]