Use a Library

Nice problem! I really enjoyed writing this solution. Although, I guess I missed the simpler approach (see my comment)

Denote by $\{p_i\}$ the sequence of primes that are $\leq n$ and by $\{t_i\}$ the sequence defined by $t_i=\max\{v\in\Bbb{Z^+}\mid p_i^v\leq n\}$ where $n$ is a positive integer. I make the following claim:

Claim: $\textrm{LCM}(1,\ldots,n)=\large\prod_i p_i^{t_i}$

Proof. Denote by $\{p_i\}$ the sequence of primes $\leq n$ . By the fundamental theorem of arithmetic, every positive integer $\leq n$ has a unique prime representation in the primes of $\{p_i\}$ . We consider the unique representation of $k$ in the primes of $\{p_i\}$ as $k=\large\prod\limits_i p_i^{q(k,i)}$ for all positive integers $k\leq n$ .

For the $q(k,i)$ 's, we have the obvious lower bound $0\leq q(k,i)~\forall~1\leq k\leq n$ since otherwise $k$ will not be an integer. Now, $p_i^{q(k,i)}\leq n$ if $q(k,i)\leq t_i$ but if $q(k,i)\gt t_i$ for some $k$ , then $k\gt n$ by definition of $t_i$ , so we also have the upper bound $q(k,i)\leq t_i~\forall~1\leq k\leq n$ . So, we have,

$0\leq q(i,k)\leq t_i~\forall~1\leq k\leq n\tag1$

Now, we use the definition of $\textrm{LCM}(a,b)$ for positive integers $a,b$ with prime representations $a=\prod\limits_i p_i^{a_i}$ and $b=\prod\limits_i p_i^{b_i}$ which is,

$\textrm{LCM}(a,b)=\large\prod_i p_i^{\max(a_i,b_i)}$

This definition easily extends to $\textrm{LCM}$ of first $n$ positive integers as,

$\textrm{LCM}(1,\ldots,n)=\large\prod_i p_i^{\displaystyle\max\limits_{1\leq k\leq n}q(k,i)}$

By $(1)$ , this reduces to,

$\textrm{LCM}(1,\ldots,n)=\large\prod_i p_i^{t_i}$

which proves the above claim, and we're done. $_\square$ .

Now that the above claim has been proved, we implement it in a python code to compute our required lcm. Here's the code in python 3 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

def lcm_upto_n(n):
    lcm=1
    mylist=[0]*(n+1)
    for i in range(2,n+1):
        if mylist[i]==0:
            tmp=i
            while(tmp*i<=n):
                tmp*=i
            lcm*=tmp
            for j in range(i,n+1,i):
                mylist[j]='n'
    return lcm



lcm=lcm_upto_n(int(input('LCM of first ? positive integers = ')))
print('\nRequired LCM modulo 10^9+7 is',lcm%(10**9+7))

Output of the above code (with input $n=1000$ ) :

LCM of first ? positive integers = 1000

Required LCM modulo 10^9+7 is 849686073

Explanation for the code : In the function lcm_upto_n() , I implemented the Sieve of Eratosthenes to find out the primes $\leq n$ and then, for each prime found, I compute the highest power of that prime that is $\leq n$ . After the highest power of a prime is found, I multiply it with the value of lcm stored before (starting out with lcm =1) and proceed onto finding the next prime. In this way, all the highest prime powers $\leq n$ are multiplied one by one till this is done for all the primes $\leq n$ .

This is the required LCM (according to the claim proved at the beginning of this solution) which is then returned by the function.

Here 's a copy of the above code written in Python 3 at Ideone, in case the solution reader wants to fork and test the code by themselves online.

Here 's the C++ equivalent of the above code at Ideone. Making a few technical changes would easily give the reader the C equivalent of this code too.