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. 


# This method for sieving turns out to be the fastest in jq.
# Input: an array to be sieved.
# Output: if the array length is less then $n then empty, else the sieved array.
def sieve($n):
  if length<$n then empty
  else . as $in
  | reduce range(0;length) as $i ([]; if $i % $n == 0 then . else . + [$in[$i]]  end)
  end;
 
# Generate a stream of ludic numbers based on sieving range(2; $nmax+1)
def ludic($nmax):
  def l:
    .[0] as $next
    | $next, (sieve($next)|l);
  1, ([range(2; $nmax+1)] | l);
 
# Output: an array of the first . ludic primes (including 1)
def first_ludic_primes:
  . as $n
  | def l:
      . as $k
      | [ludic(10*$k)] as $a
      | if ($a|length) >= $n then $a[:$n]
        else (10*$k) | l
        end;
   l;
 
# Output: an array of the ludic numbers less than .
def ludic_primes:
  . as $n
  | def l:
      . as $k
      | [ludic(10*$k)] as $a
      | if $a[-1] >= $n then $a | map(select(. < $n))
        else (10*$k) | l
        end;
   l;
 
# Output; a stream of triplets of ludic numbers, where each member of the triplet is less than .
def triplets:
  ludic_primes as $primes
  | $primes[] as $p
  | $primes
  | bsearch($p) as $i
  | if $i >= 0
    then $primes[$i+1:]
    | select( bsearch($p+2) >= 0 and
              bsearch($p+6) >= 0)
    | [$p, $p+2, $p+6]
    else empty
    end;
 
 
"First 25 ludic primes:", (25|first_ludic_primes),
"\nThere are \(1000|ludic_primes|length) ludic numbers <= 1000",
( "The \n2000th to 2005th ludic primes are:",
 (2005|first_ludic_primes)[2000:]),
( [250 | triplets] 
  | "\nThere are \(length) triplets less than 250:",
    .[] )