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



Sample input:
3


Sample output:
4

Submission status: Accepted

Solution code:
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]
#print(FactFact)
ans=1
for i in range(L):
    ans=(ans*(FactFact[i]+1))%P
print(ans)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

# AtCoder Beginner Contest
# Problem C


# See:
# https://beta.atcoder.jp/contests/abc052/submissions/2246922
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()

    # See:
    # https://atcoder.jp/img/arc067/editorial.pdf
    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)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

# AtCoder Beginner Contest
# Problem C


# See:
# https://ja.wikipedia.org/wiki/%E3%82%A8%E3%83%A9%E3%83%88%E3%82%B9%E3%83%86%E3%83%8D%E3%82%B9%E3%81%AE%E7%AF%A9
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)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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))

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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))

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
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)

Submission status: Accepted

Solution code:
dissembly = {}
def factoring(N):
	from math import sqrt
	global dissembly
	search_maxval = sqrt(N) + 1
	i = 2
	while True:
		if N == 1 or i == search_maxval:
			break

		if N % i == 0:
			if i in dissembly:
				dissembly[i] += 1
			else:
				dissembly[i] = 1

			N /= i

		else:
			i += 1


n = int(input())
ans = 1
for i in range(2,n+1):
	factoring(i)


for val in dissembly.values():
	ans *= (val+1)
	ans %= ((10 ** 9) + 7)

print(ans)

Submission status: Accepted

Solution code:
N = int(input())
div = 10**9+7


# ある自然数未満までのエラトステネスの篩をつくる
def mark(s, x):
    for i in range(x + x, len(s), x):
        s[i] = False


def eratosthenes(n):
    s = [True] * n
    for x in range(2, int(n ** 0.5) + 1):
        if s[x]: mark(s, x)
    return [i for i in range(0, n) if s[i] and i > 1]


primes = eratosthenes(1000)
num_pow = [1] * (N+1)

for n in range(1, N+1):
    for p in primes:
        if p > n:
            break
        while True:
            if n % p == 0:
                n /= p
                num_pow[p] += 1
            else:
                break

ans = 1
for z in num_pow:
    ans *= z

print(ans % div)

Submission status: Accepted

Solution code:
def prime_decomposition(n):
    # nを素因数分解
    from collections import defaultdict
    i = 2
    table = defaultdict(int)
    while i**2 <= n:
        while n % i == 0:
            n //= i
            table[i]+=1
        i += 1
    if n > 1:
        table[n]+=1
    return table

import math
N = int(input())
c = prime_decomposition(math.factorial(N))
ans = 1
for k, v in c.items():
    ans = (ans * (v + 1)) % (10**9 + 7)
print(ans)

Submission status: Accepted

Solution code:
n = int(input())
ps = [0] * (n + 1)
for i in range(2, n + 1):
    x = i
    p = 2
    while x > 1:
        while x % p == 0:
            ps[p] += 1
            x //= p
        p += 1
ans = 1
for c in ps:
    ans = (ans * (c + 1)) % 1000000007
print (ans)

Submission status: Accepted

Solution code:
from collections import Counter


def main():
    """
    1 <= N <= 10 ** 3
    N! の正の約数の個数を10**9+7 で割った余り

    (10 ** 3)! => loopじゃ無理

    1000 * 999 * 998 * ... * 2 * 1
    →それぞれの約数を求める(1000以下なので問題なし)

    素因数分解:
    e.g. 72
        2^3 * 3^2 * 1 => 6つの要素
        6C1,6C2,6C3,6C4,6C5,6C6
        重複除外(どうする) => 6C2: 2_1,2_2と2_2,2_3

        71についても同様かつ、72の約数との組合せ => 膨大な数になる

    解説:
    ある整数 x が、素因数分解によって x = p^n × q^m × ... (p, q, ...は素数) と表せる時、
    x の約数の個数は(n + 1) × (m + 1) × ... となります。
    """
    N = int(input())

    if N == 1:
        print(1)
        return

    table = eratosthenes(N)
    factors = Counter()
    for i in range(2, N + 1):
        factors += factorize(i, table)

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


def factorize(N, table):
    factors = Counter()
    x = N
    for i in [2] + list(range(3, N + 1, 2)):
        if table[i]:
            while x % i == 0:
                if i in factors:
                    factors[i] += 1
                else:
                    factors[i] = 1
                x = x // i

    return factors


def eratosthenes(N):
    a = [True for _ in range(N + 1)]
    a[0] = False
    a[1] = False

    for i in range(2, N + 1):
        if a[i]:
            for j in range(i + 1, N + 1):
                if j % i == 0:
                    a[j] = False

    return a

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import collections
N=input()

a=[]
def soinsu_bunkai(x):
	if x==1:
		a.append(1)
		return a
	n=x
	flag=0
	while flag!=1:
		for i in range(2,x+1):
			if n%i==0:
				n=n/i
				if n==1:
					flag=1
				#print i
				a.append(i)
				break
	return a


for i in range(2,N+1):
	soinsu_bunkai(i)

#print a

b=collections.Counter(a)
#print b

ans=1
for i in b.values():
	ans*=(i+1)

print ans%(10**9+7)

Submission status: Accepted

Solution code:
import math


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


def main():
    n = int(input())

    prime = get_prime_list(n)
    d = dict()
    for i in prime:
        cnt = 0
        for j in range(2, n+1):
            while j>1:
                if j%i == 0:
                    cnt += 1
                    j //= i
                else:
                    j = 0
        d[i] = cnt

    ans = 1
    for key, value in d.items():
        if value != 0:
            ans = ans * (value+1) % (10**9+7)
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import math


def prime(n):
    p = list(range(n+1))
    p[1] = 0

    for x in p:
        if x == 0:
            continue
        if x > math.sqrt(n):
            break
        for y in range(2 * x, n+1, x):
            p[y] = 0

    return [x for x in p if x != 0]


n = int(input())

p = prime(n)
a = [1] * len(p)

for i in range(1, n+1):
    for j in range(len(p)):
        while i % p[j] == 0:
            a[j] += 1
            i //= p[j]

ans = 1

for x in a:
    ans = ans * x % (10**9+7)

print(ans)

Submission status: Accepted

Solution code:
import math

N = int(input())
gc = [0] * (N + 1)
ans = 1


def solve(n):
    num = 2
    while num <= n:
        while int(n % num) is 0:
            n /= num
            gc[num] += 1
        num += 1
        if n is 1:
            break
    return 0


for i in range(1, N + 1):
    solve(i)
for p in gc:
    if p is not 0:
        ans *= p + 1
print(ans % (10 ** 9 + 7))

Submission status: Accepted

Solution code:
n=int(input())
mod=10**9+7
ans=1
from math import factorial
f=factorial(n)
p=[2]
for i in range(2,1001):
    flag=0
    for j in p:
        if i%j==0:
            flag=1
            break
    if flag==1:
        continue
    p.append(i)
for i in p:
    k=0
    while f%i**k==0:
        k+=1
    ans=ans*k
print(ans%mod)

Submission status: Accepted

Solution code:
from collections import defaultdict

MOD = 10 ** 9 + 7

# nを素因数分解する(O(n ^ (1 / 2)))
# primeFactorDecomposition(12): {2: 2, 3: 1}
def prime_factor_decomposition(n):
    import math
    m = defaultdict(int)
    while n > 1:
        find_factor = False
        for i in range(2, int(math.sqrt(n)) + 1):

            if n % i == 0:
                m[i] += 1
                n //= i
                find_factor = True
                break

        if not find_factor:
            m[n] += 1
            break

    return m


def main():
    N = int(input())
    m = defaultdict(int)
    for i in range(1, N + 1):
        d = prime_factor_decomposition(i)
        for k, v in d.items():
            m[k] += v
    ans = 1
    for k, v in m.items():
        ans = (ans * (v + 1)) % MOD

    print(ans)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

# sys.stdin = open('c1.in')

M = 10 ** 9 + 7


def read_int_list():
    return list(map(int, input().split()))


def read_str_list():
    return input().split()


def read_int():
    return int(input())


def read_str():
    return input()


def is_prime(n):
    for d in range(2, n - 1):
        if n % d == 0:
            return False
    return True


def main():
    n = read_int()
    res = 1
    for p in range(2, n + 1):
        if is_prime(p):
            np = 0
            for i in range(1, n + 1):
                j = i
                while j % p == 0:
                    j //= p
                    np += 1
            res *= np + 1
            res %= M
    print(res)


main()

Submission status: Accepted

Solution code:
from collections import Counter
import math

N = input()
PRIMES = [2,3,5,7,11,13,17,19,23,27,29,31] # < sqrt(1000)
factors = []
for n in range(2,N+1):
  tmp = n
  for prime in PRIMES:
    while tmp % prime == 0:
      factors.append(prime)
      tmp /= prime
    if tmp == 1:
      break
  if tmp > math.sqrt(n):
    factors.append(tmp)

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

Submission status: Accepted

Solution code:
is_prime = [True for i in range(10**3+1)]
is_prime[0] = is_prime[1] = False
primes = []
for i in range(2, len(is_prime)):
    if is_prime[i]:
        primes.append(i)
        for j in range(i*2, len(is_prime), i):
            is_prime[j] = False

prime_num_mapping = {p: 0 for p in primes}
def count(x):
    for p in primes:
        while x % p == 0:
            prime_num_mapping[p] += 1
            x /= p
        if x == 1:
            break
ans = 1
N = int(raw_input())
for x in range(N, 0, -1):
    count(x)
for k, v in prime_num_mapping.items():
    ans = (ans * (v+1)) % (10**9+7)
print ans

Submission status: Accepted

Solution code:
N=int(input())
R=[0]*(N-1)
for i in range(1,N+1):
  for r in range (2,N+1):
    count=0
    while i%r==0:
      i=i/r
      count+=1
    R[r-2]+=count

count=1
for r in range(N-1):
  count=count*(R[r]+1)
print(count%(10**9+7))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-


N = input()
mod = 10**9+7
num = 1
cnt = 0
ans = 1
for i in range(N):
    num = num*(i+1)
for i in range(N-1):
    while(num%(i+2)==0):
        num = num/(i+2)
        cnt += 1
    ans *= (cnt+1)
    ans = ans % mod
    cnt = 0
    
print(ans)

Submission status: Accepted

Solution code:
def is_prime(n):
    for i in range(2,n):
        if n % i == 0:
            return False
    return True

if __name__ == "__main__":
    N = int(input())
    v = [0]*(N+1)
    for i in range(2, N+1):
        for j in range(2, i+1):
            ii = i
            while ii%j == 0:
                v[j] += 1
                ii = ii / j
    ans = 1
    for i, e in enumerate(v):
        if is_prime(i) == False: continue
        ans *= e+1
    print(ans % (10**9+7))

Submission status: Accepted

Solution code:
from collections import defaultdict


MOD = 10 ** 9 + 7

# nを素因数分解する(O(n ^ (1 / 2)))
# primeFactorDecomposition(12): {2: 2, 3: 1}
def prime_factor_decomposition(n):
    m = defaultdict(int)
    while n > 1:
        find_factor = False

        for i in range(2, int(n ** 1/2) + 1):
            if n % i == 0:
                m[i] += 1
                n //= i
                find_factor = True
                break

        if not find_factor:
            m[n] += 1
            break
    return m


def main():
    N = int(input())
    all_m = defaultdict(int)
    for i in range(1, N + 1):
        m = prime_factor_decomposition(i)

        for k, v in m.items():
            all_m[k] += v

    ans = 1
    for v in all_m.values():
        ans *= (v + 1)
        ans %= MOD

    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

INF = 1000000007

stdin = sys.stdin
def na(): return map(int, stdin.readline().split())
def ns(): return stdin.readline().strip()
def ni(): return int(stdin.readline())

n = ni()
x = 1

for i in range(2, n+1):
    x = x*i

c = 0
ans = 1
y = 2
while(x != 1):
    if(x%y == 0):
        x = x//y
        c = c+1
    else:
        ans = ans*(c+1)
        c = 0
        if(y == 2): y = 3
        else: y = y+2

print(ans*(c+1)%INF)

Submission status: Accepted

Solution code:
# -*- coding:utf-8 -*-

# input N
n = int(input())
a = [0] * (n+1)

s = 1
for i in range(2, n+1):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        for k in range(2, n+1):
            while k >= i:
                if k % i == 0:
                    a[i] += 1
                    k /= i
                else:
                    break

for i in range(2, n+1):
    if a[i] != 0:
        a[i] += 1
        s *= a[i]

print(s % (pow(10, 9) + 7))

Submission status: Accepted

Solution code:
import math

def primes(N):
    ps = []
    for i in range(2,N+1):
        flag = True
        for p in ps:
            if(i % p == 0):
                flag = False
        if(flag):
            ps.append(i)
    return ps

def p_counter(p, number):
    count = 0
    while True :
        if(number % p == 0):
            number = number//p
            count += 1
        else:
            break
    return count


if __name__=="__main__":
    N = int(input())
    ps = primes(1000)
    N = math.factorial(N)
    cs = [p_counter(p, N) for p in ps]
    pattern = 1
    for c in cs:
        pattern *= (c+1)
    ans = pattern % (10**9 + 7)
    print(ans)

Submission status: Accepted

Solution code:
from math import factorial as fact
from functools import reduce

def is_prime(n):
    if n < 2:
        return False
    else:
        for i in range(2, n):
            if i * i > n:
                break
            elif n % i == 0:
                return False
        return True

def divc(n, d):
    c = 0
    while n % d == 0:
        c = c + 1
        n = n // d
    return c

n = int(input())
pl = [p for p in range(1, 1001) if is_prime(p)]
cl = [divc(fact(n), d) for d in pl]
ans = reduce(lambda x, y: x * y, [c + 1 for c in cl]) % (10 ** 9 + 7)
print(ans)

Submission status: Accepted

Solution code:
def add_prime_factor(x, list_N):
    for i in range(2, x+1):
        count = 0
        while True:
            if x % i != 0:
                break
            count += 1
            x //= i
        list_N[i-1] += count
        if x == 1:
            break
    return list_N

if __name__ == '__main__':
    N = int(input())
    list_N = [0] * N
    for i in range(2, N+1):
        list_N = add_prime_factor(i, list_N)
    ans = 1
    for x in list_N:
        ans *= (x + 1)
    print(ans % (10**9 + 7))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Wed Feb  8 15:39:57 2017

@author: kes31
"""

#dicstra
import numpy as np

N = int(input())

orig = np.arange(1,N+1)
data = np.arange(1,N+1)
cont = np.zeros_like(data)
for m in range(2,N+1):
    while(True):
        ct = 0
        mask = (data%m)==0
        data[mask]=data[mask]//m
        ct = np.sum(mask)
        cont[m-1]+=ct
        if ct == 0:
            break
#print (data)
alcount = 1
for c in cont:
    alcount = alcount*int(c+1)
alcount = np.mod(alcount,1000000007)
print (alcount)

Submission status: Accepted

Solution code:
N = int(input())
ps = [0] * (N+1)
for i in range(2,N+1):
  x = i
  p = 2
  while x > 1 :
    while x % p == 0:
      ps[p] += 1
      x //= p
    p += 1
ans = 1
for c in ps:
  ans = (ans * (c+1)) % 1000000007
print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import math
def isPrime(n):
    i = 2
    while i*i <= n:
        if n%i == 0:
            return False
        i += 1
    return True

table = []
N = int(input())
for tmp in range(2,N+1):
    if isPrime(tmp):
        table.append(tmp)

table2 = [0 for i in range(len(table))]

factorial = 1
for num in range(2,N+1):
    factorial *= num
    factor = 0
    for i in table:
        while num >= i and num%i == 0:
            table2[factor] += 1
            num /= i
        factor += 1

ans = 1
for tmp2 in table2:
    ans *= tmp2+1

#for num in range (1, factorial+1):
#    if factorial % num == 0:
#       ans += 1 

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