user
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 {\displaystyle x,}}
     

  x
  +
  2
  ,
  {\displaystyle {\displaystyle x+2,}}
     

  x
  +
  6
  {\displaystyle {\displaystyle x+6}}
        where all three numbers are also ludic numbers.
assistant
(formerly Perl 6)

**Works with**: rakudo version 2015-09-18

This implementation has no arbitrary upper limit, since it can keep adding new rotors on the fly. It just gets slower and slower instead... :-)

```
constant @ludic = gather {
        my @taken = take 1;
        my @rotor;
 
        for 2..* -> $i {
            loop (my $j = 0; $j < @rotor; $j++) {
                --@rotor[$j] or last;
            }
            if $j < @rotor {
                @rotor[$j] = @taken[$j+1];
            }
            else {
                push @taken, take $i;
                push @rotor, @taken[$j+1];
            }
        }
    }
 
say @ludic[^25];
say "Number of Ludic numbers <= 1000: ", +(@ludic ...^ * > 1000);
say "Ludic numbers 2000..2005: ", @ludic[1999..2004];
 
my \l250 = set @ludic ...^ * > 250;
say "Ludic triples < 250: ", gather
    for l250.keys.sort -> $a {
        my $b = $a + 2;
        my $c = $a + 6;
        take "<$a $b $c>" if $b ∈ l250 and $c ∈ l250;
    }

```

Output:

```
(1 2 3 5 7 11 13 17 23 25 29 37 41 43 47 53 61 67 71 77 83 89 91 97 107)
Number of Ludic numbers <= 1000: 142
Ludic numbers 2000..2005: (21475 21481 21487 21493 21503 21511)
Ludic triples < 250: (<1 3 7> <5 7 11> <11 13 17> <23 25 29> <41 43 47> <173 175 179> <221 223 227> <233 235 239>)
```