Problem:
 Score : 300 points    Problem Statement You are given an integer N .
Find the number of the positive divisors of N! , modulo 10^9+7 .      Constraints  1≤N≤10^3         Input The input is given from Standard Input in the following format:  N       Output Print the number of the positive divisors of N! , modulo 10^9+7 .        Sample Input 1 3      Sample Output 1 4  There are four divisors of 3!  =6 : 1 , 2 , 3 and 6 . Thus, the output should be 4 .       Sample Input 2 6      Sample Output 2 30       Sample Input 3 1000      Sample Output 3 972926972

Solution (Python):
N=int(input())
primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
def factorize(n,x):
    q,r=divmod(n,x)
    if r==0:
        return(1 + factorize(q,x))
    else:
        return(0)
def factors(n):
    ans=[]
    for p in primes:
        ans.append(factorize(n,p))
    return(ans)
def sumOflist(a,b):
    ans=[]
    for i in range(len(a)):
        ans.append(a[i]+b[i])
    return(ans)
numbers=[i for i in range(3,N+1)]
fTwo = factors(2)
import functools
answer = functools.reduce(lambda acc,b: sumOflist(acc,factors(b)),numbers,fTwo)
MOD=1000000007
ans = functools.reduce(lambda x,y: x*(y+1),answer,1)%MOD
if N==1:
    print(1)
else:
    print(ans)

Solution (Python):

n = input()
n = int(n)

i = n - 1
while i != 0:
	n = n * i
	i -= 1


def factorize(n):
	fct = list()
	base, exp = 2, 0
	while base * base <= n:
		while n % base == 0:
			n = n // base
			exp = exp + 1

		if exp > 0:
			fct.append((base, exp))
		
		base, exp = base + 1, 0
	if n > 1:
		fct.append((n, 1))
	return fct

fct = factorize(n)

x = 1
div_list = [exp + 1 for base, exp in fct]
for a in div_list:
	x = x * a

print(x % (10**9 + 7))

Solution (Python):
from functools import reduce
from copy import deepcopy

n = int(input())

def dadd(t, s): 
    for k,v in s.items():
        t[k] = t.get(k, 0) + v 
    return t

def pfd(c, i): 
    for j in range(2, i // 2 + 1): 
        if i % j == 0:
            d = i // j
            return dadd(deepcopy(c[j]), c.get(d, dict()))
    return { i: 1 } 

p,c = {},{}
for i in range(2, n + 1): 
    q = pfd(c, i)
    c[i] = q 
    dadd(p, q)

tot = reduce(lambda a,v: a * (v + 1), p.values(), 1)
print(tot % (10 ** 9 + 7))

Solution (Python):
n = int(input())
m = 10**9+7
primes = [2,3,5,7,11,13,17,19,23,29,31]
D = [0]*1001

for i in range(2, n+1):
    for p in primes:
        while(i % p == 0):
            D[p] += 1
            i //= p
    if i > 1:
        D[i] += 1

score = 1
for d in D:
    score = (score * (d + 1)) % m
print(score)

Solution (Python):
n = int(input())
m = 10**9+7
primes = [2,3,5,7,11,13,17,19,23,29,31]
D = [0]*1001


for i in range(2, n+1):
    v = i
    for p in range(2, 1000):
        while(v % p == 0):
            D[p] += 1
            v //= p
        if v == 1:
            break
    if(v == i):
        D[i] += 1

score = 1
for d in D:
    score = score * (d + 1)
print(score % m)

Solution (Python):
def main():
    N = input()
    N = int(N)

    k = 1
    s = []
    
    primes = prime(N+1)
    num = len(primes)

    
    lst = [0] * N
    if N ==1:
        print(1)
        exit()

    
    for i in range(2,N+1):
        b =[]
        b = bunkai(i)
        for i in b:
            lst[primes.index(i)] += 1

    ans = 1
    for i in lst:
        if i is not 0:
            ans = ans * (i+1)
    print(ans%1000000007)


def prime(n):
    primes = []
    for i in range(2,n):
        flag = True
        for j in range(2,i):
            if i%j == 0:
                flag = False
        if flag:
            primes.append(i)
    return primes

def bunkai(i):
    bunkai =[]
    s =0
    while s ==0:
        for j in range(2,i+1):
            if i % j ==0:
                bunkai.append(j)
                i = int(i/j)
                if i ==1:
                   s=1
                break
    return bunkai

if __name__ == "__main__":
        main()

Solution (Python):
from itertools import count
from math import factorial, fabs
from collections import Counter
N = int(input())

mod = 10**9 + 7

def prime_factors(n):
    i = 2
    factors = []
    while i * i <= n:
        if n % i:
            i += 1
        else:
            n //= i
            factors.append(i)
    if n > 1:
        factors.append(n)
    return factors

factors = prime_factors(factorial(N))
r = 1
for v in Counter(factors).values():
    r *= v + 1

print(r % mod)

Solution (Python):
from math import factorial
from collections import Counter

N = int(input())
mod = 10 ** 9 + 7


def prime_decomposition(n):
    i = 2
    table = []
    while i * i <= n:
        while n % i == 0:
            n //= i
            table.append(i)
        i += 1
    if n > 1:
        table.append(n)
    return table


x = factorial(N)
p = prime_decomposition(x)

ans = 1
for v in Counter(p).values():
    ans *= v + 1
print(ans % mod)

Solution (Python):
n=int(input())
d=dict()
for i in range(n+1):
    while i>1:
        for j in range(2,i+1):
            if i%j==0:
                d[j]=d.get(j,0)+1
                break
        i=i//j
ans=1
for i in d:
    ans=(ans*(d[i]+1))%(10**9+7)
print(ans)

Solution (Python):
N = int(input())
from math import sqrt,ceil
from collections import Counter

def is_prime(n):
    if n == 1: return False
    if n == 2: return True
    for i in range(2, ceil(sqrt(n))+1):
        if n % i == 0: return False
    return True

def prime_factorization(n):
    if is_prime(n):return [n]
    factor = []
    for i in range(2, ceil(sqrt(n))+1):
        if not is_prime(i): continue
        q,r = divmod(n, i)
        if r == 0:
            n = q
            factor.append(i)
            q,r = divmod(n, i)    
            while r == 0:
                n = q
                factor.append(i)
                q,r = divmod(n, i)
    if n != 1:
        factor.append(n)
    return factor


factor = []
for i in range(1, N+1):
    t = prime_factorization(i)
    if len(t): factor += t

c = Counter(factor)
ans = 1
for i in c.values():
    ans *= (i+1)
    ans %= 10**9 + 7
print(ans)

Solution (Python):
class Prime:
    def __init__(self,number):
        self.jud=[True]*(number+5)
        self.pri=[]
        self.jud[0]=False
        self.jud[1]=False
        for i in range(number):
            if self.jud[i]:
                self.pri.append(i)
                for j in range(2,(number-1)//i+1):
                    self.jud[i*j]=False
    
    def judge(self,x):
        return self.jud[x]
    
    def decom(self,x):
        s=x
        a =[]
        if s==1:
            return a
        while s>1:
            for p in self.pri:
                if s%p==0:
                    a.append(p)
                    s=s//p
                    break
        return a
            

from collections import defaultdict
dd=defaultdict(int)
N = int(input())
mod =10**9+7
P=Prime(10**3)
for i in range(1,N+1):
    for s in P.decom(i):
        dd[s]+=1
ans = 1
for i in dd.values():
    ans *= i+1
    ans %= mod
print(ans)

Solution (Python):
MOD = 10 ** 9 + 7

def get_prime_array(N):
    f = []
    for i in range(2, N + 1):
        flag = 0
        for j in f:
            if i % j == 0:
                flag = 1
                break
        if flag:
            continue
        f.append(i)
    return f


def m():
    n = int(input())
    d = dict()
    prime = get_prime_array(n)
    for i in range(2,n+1):
        tmp = i
        for p in prime:
            while not (tmp == 1):
                if tmp % p == 0:
                    tmp //= p
                    if d.get(p, 0) == 0:
                        d[p] = 1
                    else:
                        d[p] +=1
                else:
                    break
    ans = 1
    for k in d.keys():
        ans *= (d[k]+1)
    return ans % MOD
print(m())

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
n = int(input())

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)

num = factorial(n)

ans = 1
for i in range(2, n+1):
    count = 0
    while num % i == 0:
        count += 1
        num = num // i
    ans *= (count + 1)

print(ans % (10 ** 9 + 7))

Solution (Python):
from collections import Counter
N = int(input())

def factorize(n):
    d = Counter()
    m = 2
    while m*m <= n:
        while n%m == 0:
            n //= m
            d[m] += 1
        m += 1
    if n > 1:
        d[n] += 1
    return d

factors = Counter()
for n in range(1,N+1):
    factors += factorize(n)

ans = 1
MOD = 10**9+7
for v in factors.values():
    ans = (ans * (v+1))%MOD
print(ans)

Solution (Python):
from collections import Counter
N = int(input())
div = []
for i in range(2,N+1):
    while i != 1:
        for d in range(2,i+1):
            while i%d==0:
                i = i//d
                div.append(d)
C = Counter(div).most_common()
Ans = 1
for k,v in C:
    Ans = Ans*(v+1) % (10**9+7)

print(Ans)

Solution (Python):
def primes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]

primes = primes(1000)
counts = [1]*len(primes)

n = int(input())
for k in range(2, n+1):
    i = 0
    prime = primes[0]
    while k > 1:
        if k%prime == 0:
            k //= prime
            counts[i] += 1
        else:
            i += 1
            prime = primes[i]

counts = list(filter(lambda x: x > 1, counts))

ans = 1
MOD = 10**9+7
for c in counts:
    ans = ans*c%MOD
print(ans)

Solution (Python):
def is_prime(x):
    m = 2
    while m * m <= x:
        if x % m == 0:
            return False
        m += 1

    return True


def main():
    n = int(input())
    p = [i for i in range(2, n+1) if is_prime(i)]
    cnt = [0 for i in range(len(p))]

    for i in range(2, n+1):
        idx = 0
        while idx < len(p) and p[idx] <= i:
            a = i
            while a % p[idx] == 0:
                cnt[idx] += 1
                a //= p[idx]

            idx += 1

    factor = 1
    for i in cnt:
        if i == 0:
            continue

        factor *= i + 1
        if factor >= 10 ** 9 + 7:
            factor %= 10 ** 9 + 7

    print(factor)


if __name__ == '__main__':
    main()

Solution (Python):
import math

M = int(input())
L = [1 for k in range(M+1)]

P = [2]
for p in range(3,1001,2):
    f = 1
    for k in range(2,int(math.sqrt(p))+1):
        if p%k == 0:
            f = 0
    if f == 1:
        P.append(p)
S = [1 for k in range(168)]

for N in range(1,M+1):
    p = 2
    while N > 1:
        if N%p==0:
            S[P.index(p)] += 1
            N//=p
        else:
            p += 1

ans = 1
for p in S:
    ans *= p
    ans %= 10**9+7
print(ans)

Solution (Python):
import math
n = int(input())

def sosuuhantei(x):
    p = x
    if p < 2:
        return false
    elif  n == 2:
        return p
    else:
        for i in range(3,math.floor(math.sqrt(x)) + 1,2):
            if x % i == 0:
                return False
        else:
             return x

sosulist = []

if n < 2:
    None
elif n == 2:
    sosulist.append(2)
else:
    sosulist.append(2)
    for i in range(3,n+1,2):
        sosulist.append(sosuuhantei(i))

while False in sosulist:
    sosulist.remove(False)

wari_dict = {}
nn = 1
if n > 1:
    for i in range(1,n+1):
        nn = nn * i

for i in range(len(sosulist)):
    kaisuu = 0
    j = nn
    while j % sosulist[i] == 0:
        kaisuu = kaisuu + 1
        j = j // sosulist[i]
    wari_dict.update({sosulist[i]:kaisuu})
                


goal = 1
for y in wari_dict.values():
    goal = goal * (y + 1)
    if goal > (10 ** 9 + 7):
        goal = goal % (10 ** 9 + 7)
        
print(goal)

Solution (Python):
N = int(input())
prime = {2: 0}
def fact(m):
    flag = 0
    for p in list(prime):
        if m % p == 0:
            prime[p] += 1
            r = m // p
            flag = 1
            if r != 1:
                fact(r)
                break
    if flag == 0: prime[m] = 1
        

if N == 1:
    print(1)
else:
    for i in range(2, N+1): fact(i)
    res = 1
    for i in prime.values():
        res = (res * (i + 1)) % 1000000007
    print(res)

Solution (Python):
n = int(input())

prime = []
for i in range(2, n + 1):
    j = 2
    while j ** 2 <= i:
        if i % j == 0:
            break
        j += 1
    if j ** 2 > i:
        prime.append(i)
        
ans = 1

for p in prime:
    soinsu = 1
    for i in range(2, n + 1):
        while True:
            if i % p == 0:
                soinsu += 1
                i = int(i / p)
            else:
                break
    ans = (ans * soinsu) % (10 ** 9 + 7)
         
print(ans)

Solution (Python):
n = int(input())

prime = []
for i in range(2, 1000):
    j = 2
    while j ** 2 <= i:
        if i % j == 0:
            break
        j += 1
    if j ** 2 > i:
        prime.append(i)
        
ans = 1

for p in prime:
    soinsu = 1
    for i in range(2, n + 1):
        while True:
            if i % p == 0:
                soinsu += 1
                i = int(i / p)
            else:
                break
    ans = (ans * soinsu) % (10 ** 9 + 7)
         
print(ans)

Solution (Python):
n=int(input())
import math
mod=10**9+7
m=math.factorial(n)
fli=[]
ans=[0]*(n+1)
ans[0]=ans[1]=1
i=2
while i*i<=n:
    j=2
    while i*j<=n and ans[i]==0:
        ans[i*j]=1
        j+=1
    i+=1
for i in range(n+1):
    if ans[i]==0:
        fli.append(i)
total=1
for i in fli:
    cnt=0
    while m%i==0:
        cnt+=1
        m=m//i
    total*=(cnt+1)
print(total%mod)

Solution (Python):
N=int(input())
q=1
t=[0]*N
for i in range(2,N+1):
    s=1
    while i>1:
        s+=1
        while i%s==0:
            i=i//s
            t[s-2]+=1
for j in range(N):
    q=q*(t[j]+1)%(10**9+7)
print(q)

Solution (Python):
prime = []
for i in range(2, 1001):
	prime.append(i)

i = 0
while i < len(prime):
	if prime[i] < 32: break
	j = i + 1
	while j < len(prime):
		if prime[j] % prime[i] == 0:
			prime.pop(j)
		else:
			j = j + 1
	i = i + 1

primecount = []
for i in range(0, len(prime)):
	primecount.append(0)

N = int(raw_input())

for i in range(1, N+1):
	m = i
	j = 0
	while m >= prime[j]:
		if m % prime[j] == 0:
			primecount[j] = primecount[j]+1
			m = m / prime[j]
		else:
			j = j + 1

cnt = 1
for i in range(0, len(primecount)):
	cnt = cnt * (primecount[i]+1)

print cnt % 1000000007

Solution (Python):
def main():
    N = int(input())

    if N == 1:
        print(1)
        return

    lst = erastosthenes(N)
    plist = [i for i in range(3, N + 1, 2) if lst[i]]
    plist = [2] + plist

    mod = 1000000007
    ans = 1
    for p in plist:
        cnt = 0
        i = 1
        while 1:
            x = p ** i
            if x > N:
                break
            cnt += N // x
            i += 1
        ans = ans * (cnt + 1) % mod
    print(ans)

def erastosthenes(n):
    prime = [0, 1] * ((n + 1) // 2)
    if not n % 2:
        prime += [0]
    prime[1], prime[2] = 0, 1

    sqrt = n ** 0.5
    i = 3
    while i <= sqrt:
        for j in range(i ** 2, n + 1, i):
            prime[j] = 0
        i += 2
    return prime

main()

Solution (Python):
n = int(input())

a = [0] * (n+1)
for i in range(1, n+1):
    d = 2
    while d <= i:
        
        if i%d == 0:
            
            a[d] += 1
            i /= d
            d = 2
        else:
            
            d += 1

ans = 1
for i in range(n+1):
    ans *= (a[i]+1)
print(ans%(10**9+7))

Solution (Python):
n = int(input())
sum = 1
dict = {}
for i in range(2, n+1):
    j = 2
    while i > 1:
        if i%j == 0:
            i = i//j
            if j in dict:
                dict[j] += 1
            else:
                dict[j] = 1
            j -= 1
        j += 1
for i in dict.values():
    sum *= (i+1)
print(sum%1000000007)

Solution (Python):
n = int(input())
ans = 1
r = [1] * (n + 1)
s = n


for i in range(1, n + 1):
    p = i
    while p % 2 == 0:
        p = p // 2
        r[1] += 1

    for j in range(3, i + 1, 2):
        while p % j == 0:
            p = p // j
            r[j-1] += 1

for k in range(n+1):
    ans *= r[k]

ans = ans % (10 ** 9 + 7)
print(ans)

Solution (Python):
N=int(input())
P=10**9+7
Q=[1 for i in range(1001)]
Q[0]=0
Q[1]=0
for i in range(2,32):
    if Q[i]==1:
        k=2
        while(k*i<=1000):
            Q[k*i]=0
            k+=1
Prime=[]
for i in range(1001):
    if Q[i]==1:
        Prime.append(i)
L=len(Prime)
def PrimeFact(X):
    result=[0 for i in range(L)]
    for i in range(L):
        while(True):
            if X%Prime[i]==0:
                result[i]+=1
                X=X//Prime[i]
            else:
                break
        if X==1:
            break
    return result
FactFact=[0 for i in range(L)]
for i in range(1,N+1):
    O=PrimeFact(i)
    for j in range(L):
        FactFact[j]+=O[j]

ans=1
for i in range(L):
    ans=(ans*(FactFact[i]+1))%P
print(ans)

Solution (Python):
from collections import defaultdict
import math
n = math.factorial(int(input()))
i = 2
factors = defaultdict(int)
ans = 1
while i**2 <= n:
    while n%i==0:
        n //= i
        factors[i] += 1
    i += 1
if n > 1:
    factors[n] += 1
for k,v in factors.items():
    ans = (ans*(v+1))%(10**9+7)
print(ans)

Solution (Python):
def fact(m):
    u=1
    for i in range(2,m+1):
        u*=i
    return u

n=[0]
n[0]=int(input())
m=1000000007
l={  2,3,5,  7, 11, 13, 17, 19, 23, 29
, 31  ,37, 41, 43, 47, 53, 59, 61, 67, 71
, 73,  79, 83, 89, 97,101,103,107,109,113
,127,131,137,139,149,151,157,163,167,173 
,179,181,191,193,197,199,211,223,227,229 
,233 ,239,241,251,257,263,269,271,277,281
,283  ,  293,307,311,313,317,331,337,347,349 
,353, 359,367,373,379,383,389,397,401,409
,419,421,431,433,439,443,449,457,461,463 
,467 ,479,487,491,499,503,509,521,523,541
,547  ,  557,563,569,571,577,587,593,599,601 
,607, 613,617,619,631,641,643,647,653,659
,661,673,677,683,691,701,709,719,727,733 
,739 ,743,751,757,761,769,773,787,797,809
,811  ,  821,823,827,829,839,853,857,859,863 
,877, 881,883,887,907,911,919,929,937,941
,947,953,967,971,977,983,991,997,1009,1013 
,1019 ,  1021,1031,1033,1039,1049,1051,1061,1063,1069 
,1087  , 1091,1093,1097,1103,1109,1117,1123,1129,1151 
,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223
,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291
,1297 ,  1301,1303,1307,1319,1321,1327,1361,1367,1373 
,1381  , 1399,1409,1423,1427,1429,1433,1439,1447,1451 
,1453 ,  1459,1471,1481,1483,1487,1489,1493,1499,1511 
,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583
,1597 ,  1601,1607,1609,1613,1619,1621,1627,1637,1657 
,1663  , 1667,1669,1693,1697,1699,1709,1721,1723,1733 
,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811
,1823,1831,1847,1861,1867,1871,1873,1877,1879,1889
,1901 ,  1907,1913,1931,1933,1949,1951,1973,1979,1987 
,1993  , 1997,1999,2003,2011,2017,2027,2029,2039,2053 
,2063,2069,2081,2083,2087,2089,2099,2111,2113,2129
,2131,2137,2141,2143,2153,2161,2179,2203,2207,2213
,2221 ,  2237,2239,2243,2251,2267,2269,2273,2281,2287 
,2293  , 2297,2309,2311,2333,2339,2341,2347,2351,2357 
,2371,2377,2381,2383,2389,2393,2399,2411,2417,2423
,2437,2441,2447,2459,2467,2473,2477,2503,2521,2531 
,2539,2543,2549,2551,2557,2579,2591,2593,2609,2617 
,2621,2633,2647,2657,2659,2663,2671,2677,2683,2687 
,2689,2693,2699,2707,2711,2713,2719,2729,2731,2741 
,2749,2753,2767,2777,2789,2791,2797,2801,2803,2819 
,2833,2837,2843,2851,2857,2861,2879,2887,2897,2903 
,2909,2917,2927,2939,2953,2957,2963,2969,2971,2999 
,3001,3011,3019,3023,3037,3041,3049,3061,3067,3079 
,3083,3089,3109,3119,3121,3137,3163,3167,3169,3181 
,3187,3191,3203,3209,3217,3221,3229,3251,3253,3257 
,3259,3271,3299,3301,3307,3313,3319,3323,3329,3331 
,3343,3347,3359,3361,3371,3373,3389,3391,3407,3413 
,3433,3449,3457,3461,3463,3467,3469,3491,3499,3511 
,3517,3527,3529,3533,3539,3541,3547,3557,3559,3571 
,3581,3583,3593,3607,3613,3617,3623,3631,3637,3643 
,3659,3671,3673,3677,3691,3697,3701,3709,3719,3727 
,3733,3739,3761,3767,3769,3779,3793,3797,3803,3821 
,3823,3833,3847,3851,3853,3863,3877,3881,3889,3907 
,3911,3917,3919,3923,3929,3931,3943,3947,3967,3989 
,4001,4003,4007,4013,4019,4021,4027,4049,4051,4057 
,4073,4079,4091,4093,4099,4111,4127,4129,4133,4139 
,4153,4157,4159,4177,4201,4211,4217,4219,4229,4231 
,4241,4243,4253,4259,4261,4271,4273,4283,4289,4297 
,4327,4337,4339,4349,4357,4363,4373,4391,4397,4409 
,4421,4423,4441,4447,4451,4457,4463,4481,4483,4493 
,4507,4513,4517,4519,4523,4547,4549,4561,4567,4583 
,4591,4597,4603,4621,4637,4639,4643,4649,4651,4657 
,4663,4673,4679,4691,4703,4721,4723,4729,4733,4751 
,4759,4783,4787,4789,4793,4799,4801,4813,4817,4831 
,4861,4871,4877,4889,4903,4909,4919,4931,4933,4937 
,4943,4951,4957,4967,4969,4973,4987,4993,4999,5003 
,5009,5011,5021,5023,5039,5051,5059,5077,5081,5087 
,5099,5101,5107,5113,5119,5147,5153,5167,5171,5179 
,5189,5197,5209,5227,5231,5233,5237,5261,5273,5279 
,5281,5297,5303,5309,5323,5333,5347,5351,5381,5387 
,5393,5399,5407,5413,5417,5419,5431,5437,5441,5443 
,5449,5471,5477,5479,5483,5501,5503,5507,5519,5521 
,5527,5531,5557,5563,5569,5573,5581,5591,5623,5639 
,5641,5647,5651,5653,5657,5659,5669,5683,5689,5693 
,5701,5711,5717,5737,5741,5743,5749,5779,5783,5791 
,5801,5807,5813,5821,5827,5839,5843,5849,5851,5857 
,5861,5867,5869,5879,5881,5897,5903,5923,5927,5939 
,5953,5981,5987,6007,6011,6029,6037,6043,6047,6053 
,6067,6073,6079,6089,6091,6101,6113,6121,6131,6133 
,6143,6151,6163,6173,6197,6199,6203,6211,6217,6221 
,6229,6247,6257,6263,6269,6271,6277,6287,6299,6301 
,6311,6317,6323,6329,6337,6343,6353,6359,6361,6367 
,6373,6379,6389,6397,6421,6427,6449,6451,6469,6473 
,6481,6491,6521,6529,6547,6551,6553,6563,6569,6571 
,6577,6581,6599,6607,6619,6637,6653,6659,6661,6673 
,6679,6689,6691,6701,6703,6709,6719,6733,6737,6761 
,6763,6779,6781,6791,6793,6803,6823,6827,6829,6833 
,6841,6857,6863,6869,6871,6883,6899,6907,6911,6917 
,6947,6949,6959,6961,6967,6971,6977,6983,6991,6997 
,7001,7013,7019,7027,7039,7043,7057,7069,7079,7103 
,7109,7121,7127,7129,7151,7159,7177,7187,7193,7207 
,7211,7213,7219,7229,7237,7243,7247,7253,7283,7297 
,7307,7309,7321,7331,7333,7349,7351,7369,7393,7411 
,7417,7433,7451,7457,7459,7477,7481,7487,7489,7499 
,7507,7517,7523,7529,7537,7541,7547,7549,7559,7561 
,7573,7577,7583,7589,7591,7603,7607,7621,7639,7643 
,7649,7669,7673,7681,7687,7691,7699,7703,7717,7723 
,7727,7741,7753,7757,7759,7789,7793,7817,7823,7829 
,7841,7853,7867,7873,7877,7879,7883,7901,7907,7919 
,7927,7933,7937,7949,7951,7963,7993,8009,8011,8017 
,8039,8053,8059,8069,8081,8087,8089,8093,8101,8111 
,8117,8123,8147,8161,8167,8171,8179,8191,8209,8219 
,8221,8231,8233,8237,8243,8263,8269,8273,8287,8291 
,8293,8297,8311,8317,8329,8353,8363,8369,8377,8387 
,8389,8419,8423,8429,8431,8443,8447,8461,8467,8501 
,8513,8521,8527,8537,8539,8543,8563,8573,8581,8597 
,8599,8609,8623,8627,8629,8641,8647,8663,8669,8677 
,8681,8689,8693,8699,8707,8713,8719,8731,8737,8741 
,8747,8753,8761,8779,8783,8803,8807,8819,8821,8831 
,8837,8839,8849,8861,8863,8867,8887,8893,8923,8929 
,8933,8941,8951,8963,8969,8971,8999,9001,9007,9011 
,9013,9029,9041,9043,9049,9059,9067,9091,9103,9109 
,9127,9133,9137,9151,9157,9161,9173,9181,9187,9199 
,9203,9209,9221,9227,9239,9241,9257,9277,9281,9283 
,9293,9311,9319,9323,9337,9341,9343,9349,9371,9377 
,9391,9397,9403,9413,9419,9421,9431,9433,9437,9439 
,9461,9463,9467,9473,9479,9491,9497,9511,9521,9533 
,9539,9547,9551,9587,9601,9613,9619,9623,9629,9631 
,9643,9649,9661,9677,9679,9689,9697,9719,9721,9733 
,9739,9743,9749,9767,9769,9781,9787,9791,9803,9811 
,9817,9829,9833,9839,9851,9857,9859,9871,9883,9887 
,9901,9907,9923,9929,9931,9941,9949,9967,9973}
l=sorted(l)
class Stack:
     def __init__(self):
         self.items = []

     def isEmpty(self):
         return self.items == []

     def push(self, item):
         self.items.append(item)

     def pop(self):
         return self.items.pop()

     def peek(self):
         return self.items[len(self.items)-1]

     def size(self):
         return len(self.items)
s=Stack()
n[0]=fact(n[0])
for i in l:
    h=n[0]
    x=1
    if h<i:
        break
    while h%i==0:
        x+=1
        h//=i
    s.push(x)
sum=1
for i in range(s.size()):
    y=s.pop()
    sum*=y
print(sum%m)

Solution (Python):
N = int(input())
dp = [[0 for i in range(N+1)] for j in range(N+1)]
out = [0 for i in range(N+1)]
re = 1
for i in range(N+1):
    if i < 2:
        continue
    for j in range(i+1):
        if j<2:
            continue
        if i%j == 0:
            dp[i][j] = 1
            for k in range(int(i/j)+1):
                dp[i][k] += dp[int(i/j)][k]
            break

for i in range(N+1):
    for j in range(i+1):
        out[j] += dp[i][j]

for o in out:
    re*=(o+1)

print(re%(10**9+7))

Solution (Python):








def get_prime_dict(number: int) -> dict:
    ''' number: 2 or greater.
    '''
    from collections import OrderedDict

    prime_dict = OrderedDict()
    j = 2
    prime_dict[j] = 0

    for i in range(2, number + 1):
        if all(i % j != 0 for j in prime_dict.keys()):
            prime_dict[i] = 0
    return prime_dict


def execute_prime_factorization(primes: dict, number: int):
    for key in primes.keys():
        if number >= key:
            tmp = number

            while tmp >= key:
                if tmp % key == 0:
                    primes[key] += 1
                    tmp = int(tmp / key)
                else:
                    break
    return primes


if __name__ == '__main__':
    number = int(input())

    if number == 1:
        print(1)
        exit()

    
    
    primes = get_prime_dict(number)
    count = 1

    for i in range(2, number + 1):
        execute_prime_factorization(primes, i)

    for value in primes.values():
        count = ((value + 1) * count) % (10 ** 9 + 7)

    print(count)

Solution (Python):








def get_prime_dict(number: int) -> dict:
    ''' number: 2 or greater.
    '''
    from collections import OrderedDict
    from math import sqrt

    prime_dict = OrderedDict()
    j = 2
    prime_dict[j] = 0
    number_list = [int(i) for i in range(2, number + 1)]

    while number_list[0] <= int(sqrt(number)):
        for i in number_list:
            if i % j == 0:
                number_list.remove(i)

        j = number_list[0]
        prime_dict[j] = 0

    for prime in number_list:
        prime_dict[prime] = 0

    return prime_dict


def execute_prime_factorization(primes: dict, number: int):
    for key in primes.keys():
        if number >= key:
            tmp = number

            while tmp >= key:
                if tmp % key == 0:
                    primes[key] += 1
                    tmp = int(tmp / key)
                else:
                    break
    return primes


if __name__ == '__main__':
    number = int(input())

    if number == 1:
        print(1)
        exit()

    primes = get_prime_dict(number)
    count = 1

    for i in range(2, number + 1):
        execute_prime_factorization(primes, i)

    for value in primes.values():
        count = ((value + 1) * count) % (10 ** 9 + 7)

    print(count)

Solution (Python):
n = int(input())
x,answer = [2],1
if n != 1:
	for i in range(2,n+1):
		if all(i%j != 0 for j in x):
			x.append(i)
	for i in x:
		num,num2 = 1,0
		while i**num<=n:
			a = i**num
			num2 += (n-n%a)//a
			num += 1
		answer = answer*(num2+1)%(10**9+7)
print(answer)

Solution (Python):
from collections import Counter

def factors(num):
    f = []
    n = num
    i = 2
    while i * i <= n:
        while n % i == 0:
            f.append(i)
            n //= i
        i += 1
    if n > 1:
        f.append(n)
    return f


if __name__ == '__main__':
    n = int(input())
    d = Counter()
    for i in range(2, n+1):
        d.update(factors(i))
    result = 1
    for k, v in d.items():
        result = (result * (v + 1)) % (10 ** 9 + 7)
    print(result)

Solution (Python):
from functools import reduce

n = int(input())
p = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,43, 47, 53, 59, 61, 67,
     71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149,
     151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
     233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,
     317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
     419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499,
     503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
     607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691,
     701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
     811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907,
     911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
pp = []
for x in p:
    k = x
    c = 0
    while n // k:
        c += n // k
        k *= x
    pp.append(c + 1)
print(reduce(lambda x, y: x * y, pp)%(10**9+7))

Solution (Python):
def dict_count(dict, key):
	if key in dict:
		dict[key] = dict[key]+1
	else:
		dict[key] = 1
	return dict
 
N = int(input())
divs = {}
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
for n in range(2, N+1):
	for p in primes:
		while n%p==0:
			divs = dict_count(divs, p)
			n = n//p
		if p*p>n:
			break
	if n!=1:
		dict_count(divs, n)
result = 1
base = 10**9+7
for c in divs.values():
	result = (result*(c+1))%base
print(result)

Solution (Python):
N = int(input())
DIV = pow(10,9)+7
sum = 1
prime = []
for i in range(2,N+1):
  flg = True
  for j in range(2,i+1):
    if i != j and i%j == 0:
      flg = False
      break
  if flg:    
  	prime.append(i)
stock = [0]*len(prime)
ind = 0
for x in prime:
  work = 0
  for y in range(2,N+1):
    if y%x == 0:
      cnt = 1
      while y%pow(x,cnt)==0:
        cnt += 1
      work += (cnt-1)
  stock[ind] = work
  ind += 1
for z in stock:
  sum *= (z+1)
print(sum%DIV)

Solution (Python):
import sys
n=int(input())
lis=[0for i in range(n)]
for i in range(2,n+1):
  ib=i
  for j in range(2,ib+1):
    while(ib%j==0):
      lis[j-1]+=1
      ib=ib//j
pat=1
for i in lis:pat*=(i+1)
print(pat%(10**9+7))

Solution (Python):
N=int(input())
A=[0 for x in range(1001)]

def devPrime(a):
  cnt=2
  res=a
  while res>1:
    while res%cnt==0:
      res/=cnt
      A[cnt]+=1
    cnt+=1
for i in range(2,N+1):
  devPrime(i)
ans=1
for i in range(len(A)):
  ans*=(A[i]+1)
  ans%=1000000007
print(ans)

Solution (Python):
n=int(input())
import math
fac=math.factorial(n)
mod=10**9+7

ans=[0]*(n+1)
ans[0]=ans[1]=1
i=2
while i*i<=n:
    j=2
    while i*j<=n and ans[i]==0:
        ans[i*j]=1
        j+=1
    i+=1
v=[]
for i in range(n+1):
    if ans[i]==0:
        v.append(i)
total=1
count=0

for i in v:
    while fac%i==0:
        count+=1
        fac//=i
    total*=count+1
    count=0
print(total%mod)

Solution (Python):
n=int(input())
import math
fac=math.factorial(n)
mod=10**9+7
ans=[0]*(n+1)
ans[0]=ans[1]=1
i=2
while i*i<=n:
    j=2
    while i*j<=n and ans[i]==0:
        ans[i*j]=1
        j+=1
    i+=1
v=[]
for i in range(n+1):
    if ans[i]==0:
        v.append(i)
total=1
count=0
for i in v:
    while fac%i==0:
        count+=1
        fac//=i
    total*=count+1
    count=0
print(total%mod)