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())


import math
import random


class Prime:
    seed_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]

    def is_prime(self, n):
        """
        prime test (hybrid)

        see also: https://qiita.com/gushwell/items/ff9ed83ba55350aaa369

        :param n:
        :return: boolean
        """
        is_prime_common = self.is_prime_common(n)
        if is_prime_common is not None:
            return is_prime_common

        if n < 2000000:
            return self.is_prime_brute_force(n)
        else:
            return self.is_prime_miller_rabin(n)

    def is_prime_common(self, n):
        if n == 1: return False
        if n in Prime.seed_primes: return True
        if any(map(lambda x: n % x == 0, self.seed_primes)): return False

    def is_prime_brute_force(self, n):
        """
        brute force prime test
        use with is_prime_common if you want to skip seed_primes

        :param n:
        :return: boolean
        """
        for k in range(2, int(math.sqrt(n)) + 1):
            if n % k == 0:
                return False
        return True

    def is_prime_miller_rabin(self, n):
        """
        miller rabin prime test
        use with is_prime_common if you want to skip seed_primes

        see also
            algorithm: https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
            implementation: https://qiita.com/srtk86/items/609737d50c9ef5f5dc59
            improvement: https://qiita.com/gushwell/items/ff9ed83ba55350aaa369

        :param n:
        :return: boolean
        """

        d = n - 1
        while d & 1 == 0:
            d >>= 1

        
        witnesses = self.get_witnesses(n)
        

        for w in witnesses:
            y = pow(w, d, n)

            while d != n - 1 and y != 1 and y != n - 1:
                y = (y * y) % n
                d <<= 1

            if y != n - 1 and d & 1 == 0:
                return False

        return True

    def get_witnesses(self, num):
        def _get_range(num):
            if num < 2047:
                return 1
            if num < 1373653:
                return 2
            if num < 25326001:
                return 3
            if num < 3215031751:
                return 4
            if num < 2152302898747:
                return 5
            if num < 3474749660383:
                return 6
            if num < 341550071728321:
                return 7
            if num < 3825123056546413051:
                return 9
            return 12

        return self.seed_primes[:_get_range(num)]

    def gcd(self, a, b):
        if a < b:
            return self.gcd(b, a)
        if b == 0:
            return a
        while b:
            a, b = b, a % b
        return a

    @staticmethod
    def f(x, n, seed):
        """
        pseudo prime generator
        :param x:
        :param n:
        :param seed:
        :return: pseudo prime
        """
        p = Prime.seed_primes[seed % len(Prime.seed_primes)]
        return (p * x + seed) % n

    def find_factor(self, n, seed=1):
        """
        find one of factor of n
        this function is based to Pollard's rho algorithm

        see also
            algorithm: https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm
            implementation: https://qiita.com/gushwell/items/561afde2e00bf3380c98

        :param n:
        :param seed:
        :return: factor
        """
        if self.is_prime(n):
            return n

        x, y, d = 2, 2, 1
        count = 0
        while d == 1:
            count += 1
            x = self.f(x, n, seed)
            y = self.f(self.f(y, n, seed), n, seed)
            d = self.gcd(abs(x - y), n)

        if d == n:
            return self.find_factor(n, seed+1)
        return self.find_factor(d)

    def find_factors(self, n):
        primes = {}
        if self.is_prime(n):
            primes[n] = 1
            return primes

        while n > 1:
            factor = self.find_factor(n)

            primes.setdefault(factor, 0)
            primes[factor] += 1

            n //= factor

        return primes


prime = Prime()
cnt = [0]*(n+1)
for i in range(2,n+1):
    for x,c in prime.find_factors(i).items():
        cnt[x] += c
    
res = 1
for x in cnt:
    res *= (x+1)

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

Solution (Python):
from collections import Counter

n = int(input())
prime = []

def P(x):
	i = 2
	while x != 1:
		if x%i == 0:
			prime.append(i)
			x //= i
		else:
			i += 1

for j in range(1,n+1):
	P(j)


D = Counter(prime)
ans = 1 
for v in D.values():
	ans = ans*(v+1)%(10**9+7)
print(ans)

Solution (Python):
N = int(input())
prime = [2]
Res = 1

for i in range(3, N+1, 2):
    flag = True
    for j in prime:
        if i % j == 0:
            flag = False
            break
    if flag:
        prime.append(i)

div = [0]*len(prime)

for i in range(2, N+1):
    for j in range(len(prime)):
        while i % prime[j] == 0:
            div[j] += 1
            i = i//prime[j]

for i in div:
    Res *= i+1
    Res %= 10**9+7

print(Res)

Solution (Python):
import math
from collections import Counter

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

mod=10**9+7
n=int(input())
num=math.factorial(n)
factors=prime_factors(num)
indices=Counter(factors)

ans=1

for i in indices.values():
  ans*=i+1
print(ans%mod)

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


def calc_primes(N):
    is_prime = {i: True for i in range(2, N+1)}
    primes = []
    for i in range(2, N+1):
        if is_prime[i]:
            primes.append(i)
            if i**2 <= N:
                for j in range(i**2, N+1, i):
                    is_prime[j] = False
    return primes


def main():
    N = int(input())
    primes = calc_primes(N)
    dp = [[0] * (N+1) for _ in range(N+1)]
    for i in range(1, N+1):
        x = i
        for p in primes:
            cnt = 0
            while x % p == 0:
                x //= p
                cnt += 1
            dp[i][p] = dp[i-1][p] + cnt
    ans = 1
    for p in primes:
        ans = (ans * (dp[N][p] + 1)) % MOD
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import math
N = int(input())
N = math.factorial(N)
seed = [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]
_sum = 1

for i in seed:
    if N % i == 0:
        cnt = 1
        for j in range(1,N // i + 1):
            if N % i ** j == 0:
                cnt += 1
            else:
                _sum *= cnt
                _sum %= (1e9 + 7)
                break
            if j == N // i:
                _sum *= cnt
                _sum %= (1e9+7)
print(int(_sum % (1e9+7)))

Solution (Python):
def division(n):
    if n < 2:
        return []
    prime_factors = []
    for p in prime_sieve(int(n ** 0.5)):
        if p * p > n: break
        while n % p == 0:
            prime_factors.append(p)
            n //= p
    if n > 1:
        prime_factors.append(n)
    return prime_factors


def prime_sieve(m):
    prime = list(map(int, "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".split()))
    for x in reversed(range(0, len(prime))):
        if prime[x] > m:
            del prime[x]
    return prime


N = int(input())
prime_dict = {}
primea = prime_sieve(1000)
ans = 1
for t in primea:
    prime_dict[t] = 0
for q in range(2, N + 1):
    for r in division(q):
        prime_dict[r] += 1
for r in prime_dict.values():
    ans *= (r + 1)
print(ans % (10 ** 9 + 7))

Solution (Python):


































l=[1,2,4,8,16,30,60,96,160,270,540,792,1584,2592,4032,5376,10752,14688,29376,41040,60800,96000,192000,242880,340032,532224,677376,917280,1834560,2332800,4665600,5529600,7864320,12165120,16422912,19595520,39191040,60466176,85100544,102435840,204871680,258048000,516096000,677376000,819624960,258709753,517419506,876670706,698576619,464046052,210846678,87039944,174079888,559756674,984916319,217548604,16857327,609087587,218175167,106431041,212862082,535421074,139926156,50952999,105219839,195900610,391801220,889436190,472974756,845412639,690825271,891132264,782264521,316684054,31280490,665186745,252135966,764748573,529497139,790600338,524719291,999573608,999147209,522112609,37861883,417241520,775916997,997830958,995661909,729407917,321723976,871170030,520705814,149385219,41956001,988486370,976972733,516785610,158924226,583951250,167902493,687346296,374692585,229757313,549263416,890796057,781592107,875619122,751238237,277966376,130571620,574892396,149784785,921692445,813661707,582700142,400726352,358621292,318642155,250091916,386472265,174406757,151737975,260683867,184202887,320817301,641634602,125034947,201660251,962210566,924421125,489345615,320577061,637208078,196761361,626955546,253911085,389481998,778963996,576273102,309075370,619146484,295106277,464103226,498550267,627180822,788686761,989134263,978268519,902509248,805018489,112903872,32995287,295406792,974343106,721660051,443320095,316385239,778274799,190780502,633014225,727670045,455340083,498164792,15588548,97601235,195202470,569355054,118486597,342752204,135661810,90769804,181539608,519303442,515842850,84989549,696032419,231083385,462166770,150280772,300561544,884472740,641985713,569378318,591770736,690140664,249252882,677627271,850771381,851099110,702198213,111350575,222701150,859360900,670197303,177520684,355041368,643925245,287850483,323688011,476804260,749121574,436195097,100916105,763521317,852472431,566135419,817481112,609114726,316546467,633092934,400461490,516478899,802348580,904410955,621677199,257318500,176522245,676814987,463688019,296329114,264099706,528199412,36178948,424547801,768068647,536137287,180929498,361858996,212858280,424867383,432882564,865765128,720594700,90410365,461821767,203725504,114020002,228040004,637601848,275203689,996048794,816392758,827385828,501246906,502796187,283931071,433357175,368415063,694773670,389547333,672209469,929924926,339805954,823423911,430631131,861262262,912999218,775754185,248442642,92860619,47164638,94329276,560810218,901787221,979102645,727649351,20618968,41237936,409407748,818815496,105871481,565828513,733793480,775394695,826327221,652654435,644963335,70964339,34934197,69868394,21321430,42642860,308165968,66236679,863975191,474703946,965050168,372703124,98935522,622346998,724308287,448616567,387250563,521154852,757291985,756807708,98256492,802531326,949720885,885971876,131412209,981761360,661149918,619958299,331028217,662056434,807561987,320675293,914129701,828259395,37073206,74146412,402841690,54637455,617124544,234249081,751443813,937109749,192721498,402972372,453564416,21903965,219196964,711481873,513083746,252120578,510728243,686346634,854955589,709911171,78596230,269965951,409219288,248271231,873383775,746767543,509852147,174891499,984879786,197881406,237525166,359571994,592280493,443047391,387927598,775855196,487579371,975158742,351882153,147029129,237093507,474187014,233169083,703708683,126101010,198878663,367151757,734303514,558855498,196629758,161317030,573722496,327882255,869789706,71204994,142409988,519330677,658916599,820221123,589765049,882787662,765575317,237538730,765336752,111906311,970555905,547616857,95233707,919602856,913510209,325919347,651838694,787773019,168803670,875276542,263468393,816727867,633455727,500272724,140006678,171663917,920917448,754148927,547298078,412984678,825969356,89434825,653930388,136393590,272787180,276924235,570666519,590968903,696916544,114558109,209914977,987646996,975293985,732105167,207549775,590764498,239710087,413342719,606756472,119222007,227695505,450857281,901714562,192653364,385306728,234022344,31755833,752787939,682129837,972238124,563737250,589527825,729854221,873389836,746779665,973964734,947929461,5202400,320558679,402562062,651932087,438747311,877494622,851938578,595655182,953260474,906520941,610950283,501334286,115901200,458267670,725708035,451416063,34629651,443595068,292992687,984336996,352845142,600659252,738086132,476172257,146298687,742115388,685981689,371963371,5238701,10477402,766426619,741060152,215953758,431907516,900346034,302070357,669584758,46053147,500531147,269366731,835955289,753764439,748101695,586666665,340467085,680934170,993066655,337509515,702294178,689317659,610110893,855932510,718959729,437919451,162052266,591444463,937285062,874570117,577640930,690830665,441136051,234385594,995953016,490091986,701529803,403059599,173749087,571309264,670816347,341632687,12414678,656616799,110230917,555093018,326641735,653283470,841517232,299713801,790165940,55645384,857068605,957840454,891206655,734604192,144312526,317679024,396371648,792743296,423188008,846376016,985116058,646955723,952177710,502929334,92150358,447989522,924790847,549384151,424045976,984526166,194912796,17485470,655375515,480905089,910910739,771660846,177055119,354110238,487461754,533406064,889925808,672895377,471803466,943606932,363992147,457850989,337082821,559633947,903886732,428980584,430095367,52327251,636880607,273761207,706305042,890884144,393016175,748347757,949802139,899604271,310566618,130756774,816805638,605028078,169610267,339220534,575779053,151558099,779861186,564602992,437157814,502964081,478103459,956206918,385872385,383885002,125139522,606176173,727381953,8385703,189534611,657264353,809755457,619510907,607320752,922420555,310951652,461684174,548921957,97843907,729671781,620980721,857109915,25052446,275170024,550340048,495401987,990803974,362448559,60904426,929227965,120741193,257409647,514819294,969108899,560048584,985073824,700527244,680852420,361704833,819310219,589014097,1398831,2797662,533149213,66298419,177289968,605590036,607911651,709970869,953992856,619456719,655319030,644362951,232480867,745680583,590594926,181189845,520817003,742434671,899661005,364907082,733053610,13738009,433804341,236387921,508481622,16963237,232316619,464633238,221314587,887788178,285824818,571649636,737224462,55447552,88454246,798654422,982084080,964168153,247453861,1833862,99268162,659694667,466104507,932209014,864422567,728845127,537854091,599199290,264178678,250863989,574407941,732405085,314042625,489474931,176295562,914244677,852693813,705387619,193242738,892738773,352048555,704097110,771025308,753975129,927527314,542054326,2994361,5988722,142029115,324378674,100232612,267369886,945624300,882384522,416443431,832886862,784668659,985124309,298874953,102595581,589967510,536599545,782218536,77865166,65277123,130554246,660510295,877005583,275946488,615306711,199915845,893431699,154588775,309177550,504746854,864753530,291783330,553114672,78102633,511352330,753667006,152737422,966787467,933574927,743434691,300957143,206901132,971318792,551792353,641951914,887092590,774185173,324319767,296313969,419748261,736668708,125202855,250405710,860306792,120041519,287948500,772974185,72505984,145011968,197340762,319569601,29058411,58116822,503961279,97170670,855412437,719283733,922189282,610817142,981054324,962108641,555626129,721425306,8695797,867937276,204728691,409457382,327387384,796008217,623487493,246974979,808073302,987531151,661621379,619686012,885900428,182865420,604993928,209987849,112149920,982821831,436804698,873609396,249429664,35442337,542946067,435717873,357909594,663354277,349837771,172902187,725024195,626724406,951883201,898886813,611894793,223789579,156249711,953762374,941520348,627312415,732152146,626637375,697801379,928373167,467201812,934403624,300174312,940164327,768557112,666818604,430052749,769678528,637336196,471510530,884736131,405930623,88523589,177047178,741193266,482386525,959636069,420122608,870743513,206500587,931686480,949884867,256838150,936095622,169293108,338586216,20108011,40216022,515421399,752804022,39087839,78175678,170102,340204,946184524,167781729,835787762,903545720,642497069,768924002,848555995,948817436,408127979,816255958,800214847,62298624,211839153,598162116,649248474,550398359,199342730,466361673,327607418,129788111,60519012,181516929,291695327,583390654,933077030,384594463,248685267,497370534,574889090,149778173,508531933,813332884,744233240,488466473,623778584,4368568,996107508,578055173,827804465,735970254,633530545,296440400,68756126,969743180,876576330,723047882,284529056,569058112,955600472,546169433,803429308,606858609,391311257,782622514,544679226,242364688,879318989,758637971,578342645,882174629,300235757,203149792,186638455,197248609,4796039,513889283,888015602,188499605,180716688,503135262,412392718,986465265,744612799,335327753,188776829,910205676,736820167,473640327,438152515,953148782,574653619,149307231,898195178,851342559,30893933,76564644,524487579,530536325,132326487,264652974,436939730,343683655,215324089,564898148,437093697,270599954,464012989,329405798,476278405,952556810,152525842,639543549,539816971,508927499,355269900,826589616,330452844,660905688,53392193,5534060,69632488,139264976,254644395,744092152,539703029,555053484,899170215,798340423,422351818,444892614,151256959,504363114,893778023,787556039,802071847,381737209,85245710,493128509,945208231,475863350,279284954,813432374,905487747,730092313,198445481,573858992,640307357,280614707,780620191,211244466,611704170,223408333,494598748,968788563,176505672,286582450,993252097,986504187,529362547,560946912,386341399,989315317,14725758,29451516,215685422,95948827,463209666,847826556,571585155,357027634,71359521,142719042,128278247,45877819,700894880,39614801,668371163,336742319,338115610,570799830,972926972]
n=int(input())
print(l[n-1])

Solution (Python):
N = input()

T = [0]*1000
for i in range(1, N+1):
  f = 2
  while i>1:
    if i%f==0:
      T[f] += 1
      i /= f
    else:
      f += 1
ans = 1
for t in T:
  ans *= t+1
  ans %= 10**9+7
print ans

Solution (Python):

N=int(input())
c={}
for i in range(1,N+1):
	t=0
	for k in range(2,i+1):
		t=0
		if i%k==0:
			while i%k==0:
				i//=k
				t+=1
			c[k]=c.get(k,0)+t
ans=1
for k in c.keys():
	ans*=(c[k]+1)
print(ans%(10**9+7))

Solution (Python):
from collections import defaultdict
import sys

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

if N == 1:
    print(1)
    sys.exit()

dic = defaultdict(int)

for i in range(2, N+1):
    for j in range(2, i+1):
        num = 0
        while i%j == 0:
            num += 1
            i = i//j
        if num != 0:
            dic[j] += num

ans = 1
for i in dic.values():
    ans *= (i+1)
    ans %= mod
print(ans)

Solution (Python):
from collections import defaultdict
import math

n = math.factorial(int(input()))
i = 2
f = defaultdict(int)
a = 1
while i ** 2 <= n:
    while n%i==0:
        n //= i
        f[i] += 1
    i += 1
if n > 1:
    f[n] += 1
for n,m in f.items():
    a = (a*(m+1)) % (10**9+7)
print(a)

Solution (Python):
M = 1000000007

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

def solve(n):
    d = dict()
    for i in range(2, n + 1):
        for f, c in factors(i):
            d[f] = d.get(f, 0) + c
    
    r = 1
    for c in d.values():
        r = (r * (c + 1)) % M
    
    return r

def factors(n):
    i = 2
    
    while i * i <= n:
        c = 0
        while n % i == 0:
            c += 1
            n //= i
        if c != 0:
            yield (i, c)
        
        i += 1
    
    if n != 1:
        yield (n, 1)

main()

Solution (Python):
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy

def j(q):
    if q==1: print("YES")
    else:print("NO")
    exit(0)


def ct(x,y):
    if (x>y):print("GREATER")
    elif (x<y): print("LESS")
    else: print("EQUAL")

def ip():
    return int(input())


def calculate(a):
    s = 0
    for i in range(len(a)):
        for k in range(i+1,len(a)):
            s+=(a[i]*a[k])
    return s

n = ip()                              











if n == 1:
    print(1)
elif n==2:
    print(2)
else:
    l = [0]* ( n + 1 )

    for i in range(n+1):
        s = []
        value = i
        search = 1
        while value != 1 and search <= math.sqrt(value):
            search+=1
            if value%search == 0:
                s.append(search)
                value = value//search
                search = 1
        if search > math.sqrt(value) and value > 1:
            s.append(value)

        for p in range(len(s)):
            l[s[p]]+=1
    ans = 1
    for i in range(2,n+1):
        if l[i]:ans*=(l[i]+1)
    print(ans%(pow(10,9)+7))

Solution (Python):
N=int(input())
soinsu=[]
ans = 1

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

for i in range(2,N+1):
    num_tmp = i
    for j in range(2,i+1):
        while num_tmp%j==0 and num_tmp!=1:
            num_tmp /= j
            soinsu.append(j)

for i in range(2,N+1):
    cnt_tmp = soinsu.count(i)
    if cnt_tmp>0:
        ans *= cnt_tmp+1

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

Solution (Python):
import math
from collections import Counter

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

if __name__ == "__main__":
    N = int(input())
    num = math.factorial(N)
    pf = prime_factors(num)
    c = Counter(pf)
    
    res = 1

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

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

def nprf(n):
    E = [0] * (n + 1)
    for i in range(2, n + 1):
        for j in range(2, i + 1):
            while i % j == 0:
                E[j] += 1
                i //= j
    return E

ans = 1
for i in nprf(n):
    ans *= i + 1
    
print(ans % mod)

Solution (Python):

from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007






def factor(n):
    i = 2
    m = n
    while m >= i:
        while m%i == 0:
            m //= i
            d[i] += 1
            d[i] %= mod
            if m < i:break
        i += 1
n = I()
d = defaultdict(int)
for i in range(2,n+1):
    factor(i)
ans = 1
for i in d.values():
    ans *= i+1
    ans %= mod
print(ans)

Solution (Python):
n=int(input())
from collections import defaultdict
data=defaultdict(int)
ans=1
mod=10**9+7
for i in range(1,1+n):
    target=i
    now=1
    while target>1:
        now+=1
        while target>1:
            if target%now==0:
                data[now]+=1
                target//=now
            elif target%now!=0:
                break
for x in data.keys():
    ans=(ans*(data[x]+1))%mod
print(ans)

Solution (Python):
import math 
insu=[[0]*1001 for i in range(1001)]
for i in range(1, 1001):
    n=i
    for j in range(2, 1001):
        while n%j==0:
            n=n//j
            insu[i][j]+=1
n=int(input())
new=[1]*1001
for i in range(1,n+1):
    for j in range(1001):
        new[j]+=insu[i][j]
ans=1
for n in new:
    ans*=n
print(ans%(10**9+7))

Solution (Python):
import numpy as np
from collections import Counter


def calc_prime_factors(n):
    
    """ Returns a array of primes, p < n """
    
    sieve = np.ones(n // 2, dtype=np.bool)
    for i in range(3, int(n ** 0.5) + 1, 2):
        if sieve[i // 2]:
            sieve[i * i // 2::i] = False
    return np.r_[2, 2 * np.nonzero(sieve)[0][1::] + 1]


n = int(input())
primes_smaller_than_1000 = [x for x in calc_prime_factors(1000)]
primes = []
for num in range(1, n + 1):
    for prime_number in primes_smaller_than_1000:
        while num % prime_number == 0:
            num /= prime_number
            primes.append(prime_number)
counter_primes = Counter(primes)
res = 1
for i in counter_primes.values():
    res *= (i + 1)
    res %= 1000000007
print(res)

Solution (Python):
n = int(input())
mod = 1000000007
fact = [i+1 for i in range(1,n)]
ans = []
exp = 0
for base in range(2,n+1):
  exp = 0
  for i,num in enumerate(fact):
    while True:
      if num % base == 0:
        num = num // base
        exp += 1
      else:
        fact[i] = num
        break
  if exp>0:
    ans.append([base,exp])

ans_ans=1
for i in range(len(ans)):
  ans_ans *= (ans[i][1]+1)
  ans_ans %= mod

print(ans_ans)

Solution (Python):
import bisect
N=int(input())
M=10**9+7
ans=1
prime=[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]
k=bisect.bisect(prime,N)
for i in range(k-1,-1,-1):
  x=0
  j=1
  while N//(prime[i]**j)>0:
    x+=N//(prime[i]**j)
    j+=1
  ans*=x+1
  ans%=M
print(ans)

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



def prime_factor(n):
    ass = []
    for i in range(2,int(n**0.5)+1):
        while n % i==0:
            ass.append(i)
            n = n//i
    if n != 1:
        ass.append(n)
    return ass

nd = {i:0 for i in range(n+1)}
for i in range(1, n+1):
    for j in prime_factor(i):
        nd[j] += 1
ans = 1
for i in nd.values():
    if i != 0:
        ans *= (i + 1)
        ans %= 10**9 + 7
print(ans)

Solution (Python):
N = int(input())
mod = 10**9+7
prime = [2]
for i in range(3,N+1):
  if(all(i%p for p in prime)):
    prime.append(i)

ans = 1
for p in prime:
  tmp = N
  cnt = 0
  while tmp != 0:
    cnt += tmp//p
    tmp //= p
  ans = ans*(cnt+1) % mod
print(ans)

Solution (Python):
N = int(input())
r = [0 for i in range(N+1)]
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

for i in range(2, N+1):
    L = prime_decomposition(i)
    for j  in range(len(L)):
        r[L[j]] += 1
        
count = 1      
for a in r:
    if a != 0:
        count *= a+1
        count = count%(10**9+7)
        
print(count)

Solution (Python):

'''Snippets for factorization.
Available functions:
- run_prime_factorization: Run prime factorization.
'''


def run_prime_factorization(max_number: int) -> dict:
    '''Run prime factorization.
    Args:
        max_number: Int of number (greater than 1).
    Returns:
        A dictionary's items ((base, exponent) pairs).
    Landau notation: O(log n)
    '''

    from math import sqrt

    ans = dict()
    remain = max_number

    for base in range(2, int(sqrt(max_number)) + 1):
        if remain % base == 0:
            exponent_count = 0

            while remain % base == 0:
                exponent_count += 1
                remain //= base

            ans[base] = exponent_count

    if remain != 1:
        ans[remain] = 1

    return ans


def main():
    n = int(input())
    mod = 10 ** 9 + 7
    ans = 1
    d = dict()

    for i in range(2, n + 1):
        f = run_prime_factorization(i)

        for fi in f.keys():
            if fi not in d.keys():
                d[fi] = 1
            else:
                d[fi] += f[fi]

    for value in d.values():
        ans *= value + 1
        ans %= mod

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
from collections import defaultdict
MOD = 10 ** 9 + 7

n = int(input())

prime_cnt = defaultdict(int)
for num in range(2, n + 1):
    i = 2
    while i * i <= num:
        if num % i == 0:
            cnt = 0
            while num % i == 0:
                cnt += 1
                num //= i
            prime_cnt[i] += cnt
        i += 1

    if num != 1:
        prime_cnt[num] += 1

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

print(ans)

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

def prime_factor(n):
    table = [0 for i in range(1000)]
    
    for x in range(2, N+1):
        for i in range(2, x+1):
            if i * i > x:
                break
            while x%i == 0:
                table[i] += 1
                x = x // i

        if x > 1:
            table[x] += 1
    return table
    
count = 1
    
res = prime_factor(N)

for r in res:
    count *= (r + 1)
    count %= 10**9+7
    
print(count)