Problem:


Score : 400 points

Problem Statement

Given is a positive integer N. Consider repeatedly applying the operation below on N:

First, choose a positive integer z satisfying all of the conditions below:

z can be represented as z=p^e, where p is a prime number and e is a positive integer;

z divides N;

z is different from all integers chosen in previous operations.

Then, replace N with N/z.

Find the maximum number of times the operation can be applied.

Constraints

All values in input are integers.

1 \leq N \leq 10^{12}

Input

Input is given from Standard Input in the following format:

N

Output

Print the maximum number of times the operation can be applied.

Sample Input 1

24

Sample Output 1

3

We can apply the operation three times by, for example, making the following choices:

Choose z=2 (=2^1). (Now we have N=12.)

Choose z=3 (=3^1). (Now we have N=4.)

Choose z=4 (=2^2). (Now we have N=1.)

Sample Input 2

1

Sample Output 2

0

We cannot apply the operation at all.

Sample Input 3

64

Sample Output 3

3

We can apply the operation three times by, for example, making the following choices:

Choose z=2 (=2^1). (Now we have N=32.)

Choose z=4 (=2^2). (Now we have N=8.)

Choose z=8 (=2^3). (Now we have N=1.)

Sample Input 4

1000000007

Sample Output 4

1

We can apply the operation once by, for example, making the following choice:

z=1000000007 (=1000000007^1). (Now we have N=1.)

Sample Input 5

997764507000

Sample Output 5

7



Sample input:
24


Sample output:
3

Submission status: Runtime Error

Solution code:
import sys
N = int(input())
fact = factorization(N)
if fact[0][0] == 1:
    print(0)
    sys.exit()
print(fact)
ans = 0
for f, num in fact:
    print(f'{f=}, {num=}')
    for i in range(1, num+1):
        print(f'{i=}')
        if num < i:
            break
        num -= i
        ans += 1
print(ans)

Submission status: Runtime Error

Solution code:
def soinsu(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

n=int(input())
a=soinsu(n)
c=[]
if n>=2:
    for i in range(max(a)):
        c.append(0)
for i in a:
    c[i-1]+=1
z=0
f=max(c)
g=[1]
d=1
e=1
while e<=f:
    d+=1
    e=d*(d+1)/2
    g.append(e)

for i in c:
    for j in g:
        if i>=j:
            z+=1
        else:
            break
print(z)

Submission status: Runtime Error

Solution code:
def is_prime(n):
    if(n<=1):
        ans=False
    elif(n==2):
        ans=True
    else:
        for i in range(2,n):
            if(n%i==0):
                ans=False
                break
            if(i**2>n):
                ans=True
                break
    return ans
N = int(input())
z=2
recode={}
count=0
if isprime(N):
    print(1)
else:
    while N!=1:
        if isprime(N):
            count=count+1
            break
        if N%z==0:
            if z not in recode.keys():
                recode[z]=1
                N=int(N/z)
                z=2
                count+=1
                if isprime(N):
                    count=count+1
                    break
            else:
                z+=1
        else:
            z+=1
    print(len(recode.keys()))

Submission status: Runtime Error

Solution code:
import sys                          
import sympy                        
                                    
n = int(sys.stdin.readline())       
                                    
def isPrime(n):                     
    if n < 2:                       
        return False                
    for i in range(2,int(n**0.5)+1):
        if n%i==0:                  
            return False            
    return True                     
                                    
def calc(n):                        
    used = set()                    
    a = 0                           
    c = True                        
    c1 = []                         
    ds = sympy.divisors(n)          
    m = max(ds)                     
    for d in sympy.divisors(n):     
        if not isPrime(d):          
            continue                
        v = d                       
        i = 1                       
        while v <= m:               
            c1.append(v)            
            i += 1                  
            v = d ** i              
    c1.sort()                       
    while c:                        
        c = False                   
        for d in c1:                
            if d in used:           
                continue            
            if n % d != 0:          
                continue            
            #print(n, d)            
            n //= d                 
            a += 1                  
            c = True                
            used.add(d)             
            break                   
    return a                        
                                    
print(calc(n))

Submission status: Runtime Error

Solution code:
N = int(input())

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

dividers = []

N_MAX = 10 ** 12

for p in u1000primes:
    for m in range(1, 50):
        dividers.append(p ** m)

dividers = sorted([d for d in list(set(dividers)) if d <= N_MAX])


def isprime(n):
    '''check if integer n is a prime'''

    # make sure n is a positive integer
    n = abs(int(n))

    # 0 and 1 are not primes
    if n < 2:
        return False

    # 2 is the only even prime number
    if n == 2:
        return True

    # all other even numbers are not primes
    if not n & 1:
        return False

    # range starts with 3 and only needs to go up
    # the square root of n for all odd numbers
    for x in range(3, int(n ** 0.5) + 1, 2):
        if n % x == 0:
            return False

    return True


e_MAX = 50

used_numbers = []

if N == 1:
    used_numbers = []
elif isprime(N):
    used_numbers.append(N)
else:
    idx = 0
    while True:
        z = dividers[idx]

        if z > N:
            break

        if N % z == 0 and z not in used_numbers:
            N = int(N / z)
            used_numbers.append(z)

            # print('div success:' + str(z))
            # print(N)

            if N == 1:
                break
        else:
            pass
            # print('div failed:' + str(z))
        idx += 1

# print(used_numbers)
print(len(used_numbers))

Submission status: Runtime Error

Solution code:
import math

def f(n):
    arr = list()
    temp = n
    for i in range(2, int(math.sqrt(n)) + 1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //= i
            arr.append(tuple([i, cnt]))

    if temp != 1:
        tup = tuple([temp, 1])
        arr.append(tup)

    if len(arr) == 0:
        tup = tuple([n, 1])
        arr.append(tup)

    return arr

N = int(input())
if N == 1:
    print(0)
    exit()

t = f(N)
res = 0
A = [0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6]
for a in t:
    res += int(A[a[1]])
print(res)

Submission status: Runtime Error

Solution code:
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

t=int(input())
if t==1:
  print(0)
  exit()

fac=factorization(t)

def pcount(a):
  p=1
  cout=0
  while a>0:
    a=a-p
    p+=1
    if a<0:break
    cout+=1
  return cout

tt=0
for po in range(len(fac)):
  cc=pconut(po[i][1])
  tt+=cc

print(cc)

Submission status: Runtime Error

Solution code:

def resolve():
  N = int(input())
  prime_factors = factorization(N)
  tri_dict = {
    1 :  1,
    2 :  1,
    3 :  2 ,
    4 :  2 ,
    5 :  2 ,
    6 :  3 ,
    7 :  3 ,
    8 :  3 ,
    9 :  3 ,
    10 :  4 ,
    11 :  4 ,
    12 :  4 ,
    13 :  4 ,
    14 :  4 ,
    15 :  5 ,
    16 :  5 ,
    17 :  5 ,
    18 :  5 ,
    19 :  5 ,
    20 :  5 ,
    21 :  6 ,
    22 :  6 ,
    23 :  6 ,
    24 :  6 ,
    25 :  6 ,
    26 :  6 ,
    27 :  6 ,
    28 :  7 ,
    29 :  7 ,
    30 :  7 ,
    31 :  7 ,
    32 :  7 ,
    33 :  7 ,
    34 :  7 ,
    35 :  7 ,
    36 :  8 ,
    37 :  8 ,
    38 :  8 ,
    39 :  8 ,
    40 :  8
  }
  result = 0

  for prime_factor in prime_factors:
    if prime_factor[0] > 1:
      result += tri_dict[prime_factor[1]]

  print(result)
 
if __name__ == "__main__":
    resolve()

Submission status: Runtime Error

Solution code:
n = int(input())

ans = 0
rest = []

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr
A = factorization(n)

if A != [[1, 1]]:
    for i in range(len(A)):
        j = 1
        count = 1
        while A[i][1] >= j:
            ans = ans + 1
            if A[i][1] == j:
                break
            count = count + 1
            j = j + count
        rest.append(j - A[i][1])

if len(rest) > 1:
    rest.sort(reverse = True)
    i = 0
    while rest[i] != 0:
        for j in range(i + 1, rest[i] + 1):
            if rest[j] >= 1:
                rest[i] = rest[i] - 1
                rest[j] = rest[j] - 1
                ans = ans + 1
            else:
                break
        i = i + 1

print(ans)

Submission status: Runtime Error

Solution code:
N = int(input())

def factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

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



facts = factorize(N)
fs = set(facts)

from collections import Counter
fc = Counter(facts)
# divisiors = make_divisors(N)
fms = max([v for k,v in fc.items()])
fm = max(max(facts), fms) 
ans = 0

# print(facts)
# print(divisiors)

# for d in divisiors:
#     if d

for f in fs:
    i = 1
    for j in range(fm):
        if N % f == 0:
            x = f * i
            if N % x == 0:
                ans += 1
                N //= x
            i += 1
        else:
            break

print(ans)

Submission status: Runtime Error

Solution code:
n = int(input())

if n < 4:
  print(0)

t = int(n**0.5)+1
flag = [True]*(n+1)
flag[0] = False

for i in range(4,n+1,2):
  flag[i] = False
for i in range(3,t,2):
  for j in range(i+i, n+1, i):
    flag[j] = False

ans = 0
for i in range(2, t):
  if n%i == 0:
    for j in range(2,t+1):
      if i%j == 0:
        ans += 1
        break
    else:
      continue
    n //= i
print(ans)

Submission status: Runtime Error

Solution code:
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;

//  n を素因数分解した場合の素数の数
vector<pair<ll,ll>> factorize(ll n) {
  ll p = 2;
  vector<pair<ll, ll>> res;
  while (p * p < n) {
    if (n % p == 0) {
      ll cnt = 0;
      while (n % p == 0) {
        n /= p;
        cnt++;
      }
      res.push_back(make_pair(p, cnt));
    }
    p++;
  }

  if(n != 1) res.push_back(make_pair(n, 1));

  return res;
}

int main() {
    ll n;
    cin >> n;

    if (n==1){
      cout << 0 << endl;
      return 0;
    }

    vector<pair<ll,ll>> f = factorize(n);

    vector<ll> a;
    a.push_back(1);
    ll i = 2;
    while(true){
      ll tmp = a[i-2] + i;
      if (tmp > 100) break;
      a.push_back(tmp);
      i++;
    }

    ll ans = 0;
    for(pair<ll,ll> p : f){
      ll k = p.second;
      auto iter = lower_bound(a.begin(),a.end(), k);
      int ind = iter - a.begin();
      if(k < a[ind]){
        ind--;
      }

      ans += ind + 1;
    }
     

    cout << ans << endl;
    return 0;
}

Submission status: Runtime Error

Solution code:
N = int(input())
z=2
recode={}
count=0
from sympy import isprime
if isprime(N):
    print(1)
else:
    while N!=1:
        if isprime(N):
            count=count+1
            break
        if N%z==0:
            if z not in recode.keys():
                recode[z]=1
                N=int(N/z)
                z=2
                count+=1
                if isprime(N):
                    count=count+1
                    break
            else:
                z+=1
        else:
            z+=1
    print(len(recode.keys()))

Submission status: Runtime Error

Solution code:
def conv_v(x):
  if x <= 2 : return 1
  if x <= 5 : return 2
  if x <= 9 : return 3
  if x <= 14 : return 4
  if x <= 20 : return 5
  if x <= 27 : return 6
  if x <= 35 : return 7


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


N = int(input())
li = factorization(N)
answer = 0
for i in range(len(li)):
  answer += conv_v(li[i][1])

print(int(answer))

Submission status: Runtime Error

Solution code:
import sympy

n = int(input())
ans = 1

dic = sympy.factorint(n)

cnt  = 1
ans = 0
flag = False
while True:
  for k in dic.keys():
    if dic[k] >= cnt:
      dic[k] -= cnt
      ans += 1
      flag = True
  if not flag:
    break
  cnt += 1
  flag = False

print(ans)

Submission status: Runtime Error

Solution code:
import math

def f(n):
    arr = list()
    temp = n
    for i in range(2, int(math.sqrt(n)) + 1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //= i
            arr.append(tuple(i, cnt))

    if temp != 1:
        tup = tuple(temp, 1)
        arr.append(tup)

    if len(arr) == 0:
        tup = tuple(n, 1)
        arr.append(tup)

    return arr

N = int(input())
if N == 1:
    print(0)
    exit()

t = f(N)
res = 0
A = [0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6]
for a in t:
    res += int(A[a[1]])
print(res)

Submission status: Runtime Error

Solution code:
N = int(input())

# 約数列挙
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

# 素因数分解
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

def div_game(N, ans, LIST):
  if N == 1:
    print(ans)
    return ans
  
  num = make_divisors(N)
  for i in num:
    if i == 1:
      continue
    elif i in LIST:
      continue
    A = prime_decomposition(i)
    if len(set(A)) == 1:
      z = i
      LIST.append(z)
      break
    
  N = int(N/z)
  div_game(N, ans+1, LIST)

LIST = []
last = div_game(N, 0, LIST)

Submission status: Runtime Error

Solution code:
import sympy

N = int(input())
divi = sympy.divisors(N)
imp_factor = [
    sympy.factorint(i) for i in divi
]
imp_factor = [i for i in imp_factor if len(i) == 1]

known = dict()
ret = 0
while True:
    if len(imp_factor) == 0:
        break
    cnt = 0
    while True:
        if len(imp_factor) == 0:
            break
        factor_d = imp_factor.pop(0)
        factor = list(factor_d.keys())[0]
        factor_v = factor_d[factor]
        if factor**factor_v not in known:
            known[factor] = 1
            ret += 1
            break
    for i in range(len(imp_factor)):
        if list(imp_factor[i].keys())[0] == factor:
            imp_factor[i][factor] -= 1

print(ret)
pass

Submission status: Runtime Error

Solution code:
n = raw_input()
ans=1
for i in range(n):
  tmp = raw_input()
  ans= ans * tmp
if ans>1000000000000000000:
  print("-1")
else:
  print(ans)

Submission status: Runtime Error

Solution code:
import math
A, B = input().split()

print(int(math.floor(float(A) * float(B))))

Submission status: Runtime Error

Solution code:
import sympy

def func(n, history):
    l = sympy.divisors(n)
    if len(l) == 1:
        history.append(l[0])
        return history
    for i in l[1:]:
        if n == i:
            history.append(i)
            return history
        if i in history:
            continue
        history.append(i)
        _ = n // i
        func(_, history)
        break
    return history

N = int(input())
if N == 0:
    print(0)
else:
    h = func(N, [])
    print(len(set(h)))

Submission status: Runtime Error

Solution code:
def conv_v(x):
  if x <= 2 : return 1
  if x <= 5 : return 2
  if x <= 9 : return 3
  if x <= 14 : return 4
  if x <= 20 : return 5
  if x <= 27 : return 6
  if x <= 35 : return 7

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

N = int(input())
li = factorization(N)
answer = 0
for i in range(len(li)):
  answer += conv_v(li[i][1])
print(int(answer))

Submission status: Runtime Error

Solution code:
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=[]
            count = 1
            while temp%i==0:
                if(count not in cnt):
                  cnt.append(count)
                  count = 0 
                count += 1
                temp //= i
            arr.append(len(cnt))

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

n = int(input())
num = factorization(n)
if(n == 1):
  num = [1]

print(sum(num))

Submission status: Runtime Error

Solution code:
import collections
import math
def wa(n):
    m=int (math.sqrt(2*n))
   
    if m*(m+1)>2*n:
        return m-1
    else:
        return m
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a
N = int(input().strip())
n=prime_factorize(N)
l=len(n)
c = collections.Counter(n)
m=n[l-1]
x=0
for i in range (m+1):
    x+=int(wa(c[i]))
    

print(x)

Submission status: Runtime Error

Solution code:

def q4():
    N = int(input())
    arr = prime_factorize(N)
    if not arr:
        print(0)
        return

    ans_count = 0
    count = 1

    min_val = min(arr)
    while arr:
        if arr.count(min_val) < count:
            arr = list(filter(lambda a: a != min_val, arr))
            count = 1
            if not arr:
                break
            min_val = min(arr)
            continue
        arr = arr[count:]
        ans_count += 1
        count += 1
    print(ans_count)


q4()

Submission status: Runtime Error

Solution code:
n = int(input())
from collections import Counter
#a,b = map(int,input().split())
#L = list(map(int,input().split()))
def pr(n):
    L = []
    for i in range(2,int(n**0.5)+1):
        while n % i==0:
            L.append(i)
            n = n//i
    if n != 1:
        L.append(n)
    return L
dic = {1:1,2:1,3:2,4:2,5:2,6:3,7:3,8:3,9:3,10:4,11:4,12:4,13:4,14:4,15:5,16:5,17:5,18:5,19:5,20:5}
L = pr(n)
#(L)
L = Counter(L)
num = 0
for k,v in L.items():
    if v%2 == 1:
        num +=dic[v]
    else:
        num +=dic[v]
print(num)

Submission status: Runtime Error

Solution code:
import collections
N = int(input())
counter = 0
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

def cc(n):
    ans = 0
    i = 1
    while True:
        n = n - i
        ans += 1
        i += 1
        if n < i:
            break
    return ans

s_list = prime_factorize(N)
c = collections.Counter(s_list)
values,counts = zip(*c.most_common())
j = 0
for i in range(len(counts)):
    counter += cc(counts[i])
print(counter)

Submission status: Runtime Error

Solution code:
import math

is_prime = [True for i in range(10 ** 6 + 1)]
primes = []
def SieveOfEratosthenes(n):
    p = 2
    while (p * p <= n):
        if (is_prime[p] == True):
            # Update all multiples of p
            for i in range(p * p, n + 1, p):
                is_prime[i] = False
        p += 1
    for i in range(2, n + 1):
        if is_prime[i]:
            primes.append(i)
def prime(n):

    for i in range(2,int(math.sqrt(n))+1):
        if n%i==0:
            return 0
    return 1

def power_of_prime(n):
    for i in primes:
        if n % i == 0:
            c = 0
            while n % i == 0:
                n//= i
                c += 1
            if n == 1:
                return 1
            else:
                return 0


n=int(input())
k=0

SieveOfEratosthenes(int((math.sqrt(n)))+1)
t=prime(n)
if t==1:
    print(1)
else:
    for i in range(2,int(math.sqrt(n))+1):
        if n>1 and n%i==0 and power_of_prime(i)==1:
            k+=1
            n=n//i
        else:
            break

    print(k)

Submission status: Runtime Error

Solution code:
import sympy

n = int(input())
a = sympy.divisors(n)

s = n
cnt = 0

if sympy.isprime(n) == True:
    print("1")
    exit(0)
if n == 1:
    print("0")
    exit(0)

for i in range(1,len(a)):
    if sympy.isprime(a[i]) == True or len(sympy.factorint(a[i])) == 1:
        if s % a[i] == 0:
            s = s/a[i]
            cnt += 1
    if s == 1:
        print(cnt)
        exit(0)

print(cnt)

Submission status: Runtime Error

Solution code:
import sympy
n = int(input())
i = 0
remove_nums = [1]
while True:
    divisors = sympy.divisors(int(n))
    z_cand = [d for d in divisors if d not in remove_nums]
    if z_cand == []:
        break
    z = min(z_cand)
    remove_nums.append(z)
    n = n/z
    i += 1
print(i)

Submission status: Runtime Error

Solution code:

import sympy

def func(n, history):
    l = sympy.divisors(n)
    for i in l[1:]:
        if n == i:
            history.append(i)
            return history
        if i in history:
            continue
        history.append(i)
        try:
            _ = n // i
        except:
            return history
        func(_, history)
        break
    return history

N = int(input())
if N == 0:
    print(0)
else:
    h = func(N, [])
    print(len(set(h)))

Submission status: Runtime Error

Solution code:
def conv_v(x):
  if x <= 2 : return 1
  if x <= 5 : return 2
  if x <= 9 : return 3
  if x <= 14 : return 4
  if x <= 20 : return 5
  if x <= 27 : return 6
  if x <= 35 : return 7

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

N = int(input())
li = factorization(N)
answer = 0
for i in range(len(li)):
  answer += conv_v(li[i][1])
print(answer)

Submission status: Runtime Error

Solution code:

import math

n = int(input())

faccs = [0 for i in range(int(n**0.5))]


def isPrime(n) : 
  
    # Corner cases 
    if (n <= 1) : 
        return False
    if (n <= 3) : 
        return True

    if (n % 2 == 0 or n % 3 == 0) : 
        return False
  
    i = 5
    while(i * i <= n) : 
        if (n % i == 0 or n % (i + 2) == 0) : 
            return False
        i = i + 6
  
    return True

if isPrime(n):
    print(1)
else:

    while n % 2 == 0: 
        faccs[2] += 1
        n = n / 2

    for i in range(3,int(math.sqrt(n))+1,2): 
          

        while n % i== 0: 
            faccs[i] += 1 
            n = n / i 

    if n > 2: 
        faccs[int(n)] += 1 

    count = 0

    for i in faccs:
        if i > 0:
            temp = 1
            while (i-temp)>=0:
                i -= temp
                temp +=1
                count += 1
    print(count)