n-smooth   numbers are positive integers which have no prime factors  >  n.

The   n   (when using it in the expression)   n-smooth   is always prime,

there are   no   9-smooth numbers.

1   (unity)   is always included in n-smooth numbers.




2-smooth   numbers are non-negative powers of two.

5-smooth   numbers are also called   Hamming numbers.

7-smooth   numbers are also called    humble   numbers.



A way to express   11-smooth   numbers is:

  11-smooth  =  2i × 3j × 5k × 7m × 11p

           where     i, j, k, m, p ≥ 0  



Task

   calculate and show the first   25   n-smooth numbers   for   n=2   ───►   n=29
   calculate and show   three numbers starting with   3,000   n-smooth numbers   for   n=3   ───►   n=29
   calculate and show twenty numbers starting with  30,000   n-smooth numbers   for   n=503   ───►   n=521   (optional)


All ranges   (for   n)   are to be inclusive, and only prime numbers are to be used.

The (optional) n-smooth numbers for the third range are:   503,   509,   and   521.

Show all n-smooth numbers for any particular   n   in a horizontal list.

Show all output here on this page.



Related tasks

   Hamming numbers
   humble numbers


References

   Wikipedia entry:   Hamming numbers     (this link is re-directed to   Regular number).
   Wikipedia entry:   Smooth number
   OEIS entry:   A000079    2-smooth numbers or non-negative powers of two
   OEIS entry:   A003586    3-smooth numbers
   OEIS entry:   A051037    5-smooth numbers or Hamming numbers
   OEIS entry:   A002473    7-smooth numbers or humble numbers
   OEIS entry:   A051038   11-smooth numbers
   OEIS entry:   A080197   13-smooth numbers
   OEIS entry:   A080681   17-smooth numbers
   OEIS entry:   A080682   19-smooth numbers
   OEIS entry:   A080683   23-smooth numbers


V primes = [2, 3, 5, 7, 11, 13, 17, 19, 23]
 
F isPrime(n)
   I n < 2
      R 0B
 
   L(i) :primes
      I n == i
         R 1B
      I n % i == 0
         R 0B
      I i * i > n
         R 1B
   print(‘Oops, ’n‘  is too large’)
   R 0B
 
F init()
   V s = 24
   L s < 600
      I isPrime(s - 1) & s - 1 > :primes.last
         :primes.append(s - 1)
      I isPrime(s + 1) & s + 1 > :primes.last
         :primes.append(s + 1)
      s += 6
 
F nsmooth(n, size)
   assert(n C 2..521)
   assert(size >= 1)
 
   V bn = n
   V ok = 0B
   L(prime) :primes
      I bn == prime
         ok = 1B
         L.break
   assert(ok, ‘must be a prime number’)
 
   V ns = [BigInt(0)] * size
   ns[0] = 1
 
   [BigInt] next
   L(prime) :primes
      I prime > bn
         L.break
      next.append(prime)
 
   V indicies = [0] * next.len
   L(m) 1 .< size
      ns[m] = min(next)
      L(i) 0 .< indicies.len
         I ns[m] == next[i]
            indicies[i]++
            next[i] = :primes[i] * ns[indicies[i]]
 
   R ns
 
init()
 
L(p) primes
   I p >= 30
      L.break
   print(‘The first ’p‘ -smooth numbers are:’)
   print(nsmooth(p, 25))
   print()
 
L(p) primes[1..]
   I p >= 30
      L.break
   print(‘The 3000 to 3202 ’p‘ -smooth numbers are:’)
   print(nsmooth(p, 3002)[2999..])
   print()
 
L(p) [503, 509, 521]
   print(‘The 30000 to 3019 ’p‘ -smooth numbers are:’)
   print(nsmooth(p, 30019)[29999..])
   print()