Ludic numbers   are related to prime numbers as they are generated by a sieve quite like the Sieve of Eratosthenes is used to generate prime numbers.

The first ludic number is   1.

To generate succeeding ludic numbers create an array of increasing integers starting from   2.

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...
(Loop)

 Take the first member of the resultant array as the next ludic number   2.
 Remove every   2nd   indexed item from the array (including the first).
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...
 (Unrolling a few loops...)
 Take the first member of the resultant array as the next ludic number   3.
 Remove every   3rd   indexed item from the array (including the first).
3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 ...
 Take the first member of the resultant array as the next ludic number   5.
 Remove every   5th   indexed item from the array (including the first).
5 7 11 13 17 19 23 25 29 31 35 37 41 43 47 49 53 55 59 61 65 67 71 73 77 ...
 Take the first member of the resultant array as the next ludic number   7.
 Remove every   7th   indexed item from the array (including the first).
7 11 13 17 23 25 29 31 37 41 43 47 53 55 59 61 67 71 73 77 83 85 89 91 97 ...
  ... 
 Take the first member of the current array as the next ludic number   L.
 Remove every   Lth   indexed item from the array (including the first).
  ... 


Task

 Generate and show here the first 25 ludic numbers.
 How many ludic numbers are there less than or equal to 1000?
 Show the 2000..2005th ludic numbers.


Stretch goal

Show all triplets of ludic numbers < 250.

 A triplet is any three numbers     



x
,


{\displaystyle x,}

   



x
+
2
,


{\displaystyle x+2,}

   



x
+
6


{\displaystyle x+6}

      where all three numbers are also ludic numbers. 


// version 1.0.6
 
/* Rather than remove elements from a MutableList which would be a relatively expensive operation
   we instead use two arrays:
 
   1. An array of the Ludic numbers to be returned.
   2. A 'working' array of a suitable size whose elements are set to 0 to denote removal. */
 
fun ludic(n: Int): IntArray {
    if (n < 1) return IntArray(0)
    val lu = IntArray(n)  // array of Ludic numbers required
    lu[0] = 1
    if (n == 1) return lu
    var count = 1
    var count2: Int
    var j: Int
    var k = 1
    var ub = n * 11  // big enough to deal with up to 2005 ludic numbers
    val a = IntArray(ub) { it }  // working array
    while (true) {
        k += 1
        for (i in k until ub) {
            if (a[i] > 0) {
                count +=1
                lu[count - 1] = a[i]
                if (n == count) return lu
                a[i] = 0
                k = i
                break
            }
        }
        count2 = 0
        j = k + 1
        while (j < ub) {
            if (a[j] > 0) {
                count2 +=1
                if (count2 == k) {
                    a[j] = 0
                    count2 = 0
                }
            }
            j += 1
        }
    }
} 
 
fun main(args: Array<String>) {
    val lu: IntArray = ludic(2005)
    println("The first 25 Ludic numbers are :")  
    for (i in 0 .. 24) print("%4d".format(lu[i]))
 
    val count = lu.count { it <= 1000 }
    println("\n\nThere are $count Ludic numbers <= 1000" )
 
    println("\nThe 2000th to 2005th Ludics are :")
    for (i in 1999 .. 2004) print("${lu[i]}  ")
 
    println("\n\nThe Ludic triplets below 250 are : ")
    var k: Int = 0
    var ldc: Int
    var b: Boolean
    for (i in 0 .. 247) {
        ldc = lu[i]
        if (ldc >= 244) break
        b = false
        for (j in i + 1 .. 248) {
             if (lu[j] == ldc + 2) {
                 b = true
                 k = j
                 break
             }
             else if (lu[j] > ldc + 2) break
        }
        if (!b) continue
        for (j in k + 1 .. 249) {
            if (lu[j] == ldc + 6) {
                println("($ldc, ${ldc + 2}, ${ldc + 6})")
                break
            }
            else if (lu[j] > ldc + 6) break
        }
    }    
}