input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
iN ,iX = [int(x) for x in input().split()]
aCum = [0]
for i in map(int,input().split()):aCum+=[aCum[-1]+i]
aCum = aCum[1:]
#aX = [int(x) for x in input().split()]
#aCum = [0]*iN
#aCum[0] = aX[0]
#for i in range(1,iN):
# aCum[i]=aCum[i-1]+aX[i]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = (iN + iK ) * iX + 5 * aCum[-1]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[-1 * i * iK -1]
return iCost
iTotalCost = fCalcCost(iN,iX,aCum,1)
for iK in range(2,fCeil(iN,2) + 1):
iTotalCost = min(iTotalCost,fCalcCost(iN,iX,aCum,iK))
print(iTotalCost)
| iN ,iX = [int(x) for x in input().split()]
aX = [int(x) for x in input().split()]
aCum = [0]*iN
aCum[0] = aX[0]
for i in range(1,iN):
aCum[i]=aCum[i-1]+aX[i]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = (iN + iK ) * iX + 5 * aCum[-1]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[-1 * i * iK -1]
return iCost
#枝刈りのテスト
#これ通用するのかな
iTotalCost = fCalcCost(iN,iX,aCum,1)
for iK in range(2,fCeil(iN,2) + 1):
iThisCost = fCalcCost(iN,iX,aCum,iK)
if iThisCost > iTotalCost:
break
else:
iTotalCost = iThisCost
print(iTotalCost)
| p03255 |
iN ,iX = [int(x) for x in input().split()]
aX = [int(x) for x in input().split()]
aCum = [0]*iN
aCum[0] = aX[0]
for i in range(1,iN):
aCum[i]=aCum[i-1]+aX[i]
def fCeil(iT,iR):
return -1 * iT // iR * -1
#マネして記法を圧縮してみたがどうだろう
def fCalcCost(iN,iX,aCum,iK):
return (iN + iK ) * iX + 5 * aCum[-1] +sum(2*aCum[-i*iK -1] for i in range(2,fCeil(iN,iK)))
iTotalCost = fCalcCost(iN,iX,aCum,1)
iULim = fCeil(iN,2) + 1
for iK in range(2,fCeil(iN,2)+1):
iThisCost = fCalcCost(iN,iX,aCum,iK)
if iThisCost > iTotalCost:
break
else:
iTotalCost = iThisCost
print(iTotalCost)
| iN ,iX = [int(x) for x in input().split()]
#かえって遅い？
aCum = [0]
for x in input().split():
aCum += [aCum[-1] + int(x)]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = (iN + iK ) * iX + 5 * aCum[-1]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[iN - i * iK ]
return iCost
#枝刈り
iTotalCost = fCalcCost(iN,iX,aCum,1)
for iK in range(2,fCeil(iN,2) + 1):
iThisCost = fCalcCost(iN,iX,aCum,iK)
if iThisCost > iTotalCost:
break
else:
iTotalCost = iThisCost
print(iTotalCost)
| p03255 |
iN ,iX = [int(x) for x in input().split()]
aCum = [0]
for x in input().split():
aCum += [aCum[-1] + int(x)]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = (iN + iK ) * iX + 5 * aCum[iN]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[iN - i * iK ]
return iCost
if 1 < iN :
iULim = fCeil(iN,2)+1
iLLim = 1
def fSearchLowCost(iL,iLCost,iU,iUCost,iN,iX,aCum):
if iU - iL < 2 * iX :
iTotalCost = min(iLCost,iUCost)
for iK in range(iL+1,iU) :
iThisCost = fCalcCost(iN,iX,aCum,iK)
iTotalCost = min(iThisCost,iTotalCost)
return iTotalCost
else:
iM = (iU + iL) // 2
iMCost = fCalcCost(iN,iX,aCum,iM)
if iLCost < iUCost :
return fSearchLowCost(iL,iLCost,iM,iMCost,iN,iX,aCum)
else :
return fSearchLowCost(iM,iMCost,iU,iUCost,iN,iX,aCum)
print((fSearchLowCost(iLLim,fCalcCost(iN,iX,aCum,iLLim),iULim,fCalcCost(iN,iX,aCum,iULim),iN,iX,aCum)))
else:
print((2*iX + 5*aX[0]))
| iN ,iX = [int(x) for x in input().split()]
aCum = [0]
for x in input().split():
aCum += [aCum[-1] + int(x)]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = (iN + iK ) * iX + 5 * aCum[iN]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[iN - i * iK ]
return iCost
if 1 < iN :
iULim = fCeil(iN,2)+1
iLLim = 1
def fSearchLowCost(iL,iLCost,iU,iUCost,iN,iX,aCum):
if iU - iL <= iX :
iTotalCost = min(iLCost,iUCost)
for iK in range(iL+1,iU) :
iThisCost = fCalcCost(iN,iX,aCum,iK)
iTotalCost = min(iThisCost,iTotalCost)
return iTotalCost
else:
iM = (iU + iL) // 2
iMCost = fCalcCost(iN,iX,aCum,iM)
if iLCost < iUCost :
return fSearchLowCost(iL,iLCost,iM,iMCost,iN,iX,aCum)
else :
return fSearchLowCost(iM,iMCost,iU,iUCost,iN,iX,aCum)
print((fSearchLowCost(iLLim,fCalcCost(iN,iX,aCum,iLLim),iULim,fCalcCost(iN,iX,aCum,iULim),iN,iX,aCum)))
else:
print((2*iX + 5*aX[0]))
| p03255 |
iN ,iX = [int(x) for x in input().split()]
aCum = [0]
for x in input().split():
aCum += [aCum[-1] + int(x)]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = (iN + iK ) * iX + 5 * aCum[iN]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[iN - i * iK ]
return iCost
if 1 < iN :
iULim = fCeil(iN,2)+1
iLLim = 1
def fSearchLowCost(iL,iLCost,iU,iUCost,iN,iX,aCum):
if iU - iL <= iX :
iTotalCost = min(iLCost,iUCost)
for iK in range(iL+1,iU) :
iTotalCost = min(iTotalCost,fCalcCost(iN,iX,aCum,iK))
return iTotalCost
else:
iM = (iU + iL) // 2
iMCost = fCalcCost(iN,iX,aCum,iM)
if iLCost < iUCost :
return fSearchLowCost(iL,iLCost,iM,iMCost,iN,iX,aCum)
else :
return fSearchLowCost(iM,iMCost,iU,iUCost,iN,iX,aCum)
print((fSearchLowCost(iLLim,fCalcCost(iN,iX,aCum,iLLim),iULim,fCalcCost(iN,iX,aCum,iULim),iN,iX,aCum)))
else:
print((2*iX + 5*aX[0]))
| iN ,iX = [int(x) for x in input().split()]
aCum = [0]
for x in input().split():
aCum += [aCum[-1] + int(x)]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = (iN + iK ) * iX + 5 * aCum[iN]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[iN - i * iK ]
return iCost
def fSearchLowCost(iL,iLCost,iU,iUCost,iN,iX,aCum):
if iU - iL <= iX :
iTotalCost = min(iLCost,iUCost)
for iK in range(iL+1,iU) :
iTotalCost = min(iTotalCost,fCalcCost(iN,iX,aCum,iK))
return iTotalCost
else:
iM = (iU + iL) // 2
iMCost = fCalcCost(iN,iX,aCum,iM)
if iLCost < iUCost :
return fSearchLowCost(iL,iLCost,iM,iMCost,iN,iX,aCum)
else :
return fSearchLowCost(iM,iMCost,iU,iUCost,iN,iX,aCum)
if 1 < iN :
iULim = fCeil(iN,2)+1
iLLim = 1
print((fSearchLowCost(iLLim,fCalcCost(iN,iX,aCum,iLLim),iULim,fCalcCost(iN,iX,aCum,iULim),iN,iX,aCum)))
else:
print((2*iX + 5*aX[0]))
| p03255 |
import math
import sys
n,x= list(map(int,input().split()))
a = list(map(int, sys.stdin.readline().split()))
ru = [0]*(n+1)
for i in range(1,n+1):
ru[i] = ru[i-1]+a[i-1]
ans = float("inf")
for i in range(1,n+1):
tmp = x*i
l = math.ceil(n/i)
for j in range(1,l+1):
if ans <= tmp:
break
if j == 1:
m = -i*(j+1)-1
if m < -n:
m = -n-1
tmp += (ru[n]-ru[m])*5
else:
m = -i*(j+1)-1
if m < -n:
m = -n-1
if -i*j-1 < -n:
break
tmp += (ru[-i*j-1]-ru[m])*(2*j+3)
ans = min(ans,tmp)
print((ans+n*x)) | import sys
n,x= list(map(int,input().split()))
a = list(map(int, sys.stdin.readline().split()))
ru = [0]*(n+1)
for i in range(1,n+1):
ru[i] = ru[i-1]+a[i-1]
ans = float("inf")
for i in range(1,(n+1)//2+1):
tmp = x*i+ru[n]*5
j = n-i*2
while j > 0:
tmp += ru[j]*2
j -= i
ans = min(ans,tmp)
print((ans+n*x)) | p03255 |
def main():
string = input().strip()
k = int(eval(input()))
s = set()
length = len(string)
for i in range(length):
for j in range(i, length):
s.add(string[i:j+1])
print((sorted(s)[k - 1]))
if __name__ == '__main__':
main()
| def main():
string = input().strip()
k = int(eval(input()))
s = set()
for char in sorted(set(string)):
for i in range(len(string)):
if string[i] == char:
s.add(string[i])
s.add(string[i:i+1])
s.add(string[i:i+2])
s.add(string[i:i+3])
s.add(string[i:i+4])
s.add(string[i:i+5])
if len(s) >= k:
print((sorted(s)[k - 1]))
return
if __name__ == '__main__':
main()
| p03355 |
#!/usr/bin/env python3
from sys import stdin
def solve(tc):
s = stdin.readline().strip()
k = int(stdin.readline().strip())
n = len(s)
li = [list() for i in range(26)]
for i in range(n):
li[ord(s[i])-ord('a')].append(i)
p = 0
while len(li[p])==0:
p += 1
ans = set()
while len(ans)<k and p<26:
for i in range(n):
for j in range(len(li[p])):
b = li[p][j]
e = min(n, li[p][j] + i + 1)
ans.add(s[b:e])
p += 1
lans = list(ans)
lans.sort()
print((lans[k-1]))
pass
LOCAL_TEST = not __debug__
if LOCAL_TEST:
infile = __file__.split('.')[0] + "-test.in"
stdin = open(infile, 'r')
tcs = (int(stdin.readline().strip()) if LOCAL_TEST else 1)
tc = 1
while tc <= tcs:
solve(tc)
tc += 1 | #!/usr/bin/env python3
from sys import stdin
def solve(tc):
s = stdin.readline().strip()
k = int(stdin.readline().strip())
n = len(s)
li = [list() for i in range(26)]
for i in range(n):
li[ord(s[i])-ord('a')].append(i)
p = 0
while len(li[p])==0:
p += 1
ans = set()
while len(ans)<k and p<26:
for i in range(k):
for j in range(len(li[p])):
b = li[p][j]
e = min(n, li[p][j] + i + 1)
ans.add(s[b:e])
p += 1
lans = list(ans)
lans.sort()
print((lans[k-1]))
# print(lans[k-1])
pass
LOCAL_TEST = not __debug__
if LOCAL_TEST:
infile = __file__.split('.')[0] + "-test.in"
stdin = open(infile, 'r')
tcs = (int(stdin.readline().strip()) if LOCAL_TEST else 1)
tc = 1
while tc <= tcs:
solve(tc)
tc += 1 | p03355 |
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def roundUp(a, b):
return -(-a // b)
@staticmethod
def toUpperMultiple(a, x):
return Math.roundUp(a, x) * x
@staticmethod
def toLowerMultiple(a, x):
return (a // x) * x
@staticmethod
def nearPow2(n):
if n <= 0:
return 0
if n & (n - 1) == 0:
return n
ret = 1
while(n > 0):
ret <<= 1
n >>= 1
return ret
@staticmethod
def isPrime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
MOD = int(1e09) + 7
def main():
# sys.stdin = open("sample.txt")
S = Scanner.string()
K = Scanner.int()
m = []
N = len(S)
for i in range(N):
for j in range(i, N):
m.append(S[i: j + 1])
m = sorted(set(m))
print((m[K-1]))
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def roundUp(a, b):
return -(-a // b)
@staticmethod
def toUpperMultiple(a, x):
return Math.roundUp(a, x) * x
@staticmethod
def toLowerMultiple(a, x):
return (a // x) * x
@staticmethod
def nearPow2(n):
if n <= 0:
return 0
if n & (n - 1) == 0:
return n
ret = 1
while(n > 0):
ret <<= 1
n >>= 1
return ret
@staticmethod
def isPrime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
MOD = int(1e09) + 7
def main():
# sys.stdin = open("sample.txt")
S = Scanner.string()
K = Scanner.int()
m = []
N = len(S)
for i in range(N):
for j in range(i, min(i+K, N)):
m.append(S[i: j + 1])
m = sorted(set(m))
print((m[K-1]))
if __name__ == "__main__":
main()
| p03355 |
import sys
def solve():
input = sys.stdin.readline
s = input().strip("\n")
K = int(eval(input()))
substr = set()
N = len(s)
for i in range(N):
for j in range(i+1, N + 1):
substr |= {s[i:j]}
sl = list(substr)
sl.sort()
print((sl[K-1]))
return 0
if __name__ == "__main__":
solve() | import sys
def solve():
input = sys.stdin.readline
s = input().strip("\n")
K = int(eval(input()))
substr = set()
N = len(s)
for i in range(N):
for j in range(1, min(6, N - i + 1)):
substr |= {s[i:i+j]}
sl = list(substr)
sl.sort()
print((sl[K-1]))
return 0
if __name__ == "__main__":
solve()
| p03355 |
s = input().strip()
K = int(eval(input()))
C = {}
for i in range(len(s)):
if s[i] not in C:
C[s[i]] = []
C[s[i]].append(i)
if len(C)==1:
a = s[0]
print((a*K))
else:
A = []
for a in C:
for i in C[a]:
for j in range(i+1,len(s)+1):
A.append(s[i:j])
A = sorted(list(set(A)))
print((A[K-1])) | s = input().strip()
K = int(eval(input()))
C = {}
for i in range(len(s)):
if s[i] not in C:
C[s[i]] = []
C[s[i]].append(i)
D = {}
for a in C:
for i in C[a]:
for j in range(i+1,len(s)+1):
if s[i:j] not in D:
D[s[i:j]] = 0
D[s[i:j]] += 1
D = sorted(list(D.keys()))
print((D[K-1])) | p03355 |
def all_index(s, c):
ins = []
for i in range(len(s)):
if s[i] == c:
ins.append(i)
return ins
s = input().strip()
k = int(eval(input()))
ss = set()
alphabets = sorted(list(set(s)))
for c in alphabets:
ins = all_index(s, c)
for i in ins:
for j in range(i, len(s)):
ss.add(s[i:j+1])
if len(ss) >= k:
break
print((sorted(list(ss))[k-1])) | def all_index(s, c):
ins = []
for i in range(len(s)):
if s[i] == c:
ins.append(i)
return ins
s = input().strip()
k = int(eval(input()))
ss = set()
alphabets = sorted(list(set(s)))
for c in alphabets:
ins = all_index(s, c)
for i in ins:
for j in range(i, len(s)):
if (j+1 - i) > k:
break
ss.add(s[i:j+1])
if len(ss) >= k:
break
print((sorted(list(ss))[k-1])) | p03355 |
import sys
from string import ascii_lowercase as AL
input = sys.stdin.readline
def main():
s = input().rstrip()
K = int(eval(input()))
N = len(s)
total = 0
for al in AL:
induces = []
for i in range(N):
if al == s[i]:
induces.append(i)
if not induces:
continue
match = [al]
for i in range(1, 5):
for idx in induces:
if idx + i < N:
match.append(s[idx:idx + i + 1])
match = set(match)
match = sorted(match)
if total + len(match) >= K:
ans = match[K - 1 - total]
break
else:
total += len(match)
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
s = input().rstrip()
K = int(eval(input()))
N = len(s)
sub = []
for i in range(N):
for j in range(K):
sub.append(s[i:i+j+1])
sub = set(sub)
sub = sorted(sub)
ans = sub[K-1]
print(ans)
if __name__ == "__main__":
main()
| p03355 |
import sys
from string import ascii_lowercase as AL
input = sys.stdin.readline
def main():
S = input().rstrip()
K = int(eval(input()))
N = len(S)
sub = set()
for al in AL:
for i in range(N):
if S[i] == al:
for j in range(1, 6):
sub.add(S[i:i + j])
if len(sub) >= K:
break
sub = sorted(sub)
ans = sub[K - 1]
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
S = input().rstrip()
K = int(eval(input()))
N = len(S)
sub = set()
for i in range(N):
for j in range(1, K + 1):
sub.add(S[i:i + j])
sub = sorted(sub)
ans = sub[K - 1]
print(ans)
if __name__ == "__main__":
main()
| p03355 |
import sys
sys.setrecursionlimit(10 ** 7)
# ----------
INF = float("inf")
MOD = 10 ** 9 + 7
# ----------
s = list(input().strip())
K = int(eval(input()))
N = len(s)
if N == 1:
print((s[0]))
exit()
sub = set()
for i in range(N):
for j in range(N):
sub.add(''.join(s[i:j+1]))
print((sorted(sub)[K]))
|
S = input().strip()
K = int(eval(input()))
L = len(S)
substr = set()
for i in range(L):
for j in range(5):
s = S[i:min(i+j+1, L)]
if s:
substr.add(s)
print((sorted(substr)[K-1]))
| p03355 |
import sys
from sys import exit
from collections import deque
from copy import deepcopy
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod=MOD):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x,mode='counter'):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
if mode=='counter':
return C
S = set([1])
for k in C:
T = deepcopy(S)
for x in T:
for i in range(1,C[k]+1):
S.add(x*(k**i))
if mode=='set':
return S
if mode=='list':
return sorted(list(S))
######################################################
S=input()
N=len(S)
K=intput()
L=[list()]*26
ans=[]
for i in range(N):
L[ston(S[i])].append(i)
for l in L:
for i in l:
for j in range(i+1,N+1):
s=S[i:j]
if bisect_left(ans,s)==bisect_right(ans,s):
insort_left(ans,s)
if len(ans)>=K:
print(ans[K-1])
exit()
| import sys
from sys import exit
from collections import deque
from copy import deepcopy
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod=MOD):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x,mode='counter'):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
if mode=='counter':
return C
S = set([1])
for k in C:
T = deepcopy(S)
for x in T:
for i in range(1,C[k]+1):
S.add(x*(k**i))
if mode=='set':
return S
if mode=='list':
return sorted(list(S))
######################################################
S=input()
N=len(S)
K=intput()
L=[list()]*26
ans=[]
for i in range(N):
L[ston(S[i])].append(i)
for l in L:
for i in l:
for j in range(i+1,min(i+K+1,N+1)):
s=S[i:j]
if bisect_left(ans,s)==bisect_right(ans,s):
insort_left(ans,s)
if len(ans)>=K:
print(ans[K-1])
exit()
| p03355 |
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)
s = stdin.readline().rstrip()
k = int(stdin.readline().rstrip())
def main():
finish = set()
S = len(s)
for i in range(S):
for j in range(i+1,S+1):
finish.add(s[i:j])
finish = list(finish)
finish.sort()
print((finish[k-1]))
if __name__ == "__main__":
main() | from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)
s = stdin.readline().rstrip()
k = int(stdin.readline().rstrip())
finish = set()
S = len(s)
for i in range(S):
for j in range(1,6):
finish.add(s[i:i+j])
finish = list(finish)
finish.sort()
print((finish[k-1])) | p03355 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
A,B = MI()
S = LS2()
for i in range(A+B+1):
if i == A:
if S[i] != '-':
print('No')
break
else:
if S[i] == '-':
print('No')
break
else:
print('Yes')
| import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
A,B = MI()
S = LS2()
for i in range(A+B+1):
if i == A:
if S[i] != '-':
print('No')
break
else:
if S[i] == '-':
print('No')
break
else:
print('Yes')
| p03474 |
import sys
# import collections
# import math
import string
# import bisect
# import re
# import itertools
# import statistics
def main():
a, b = (int(x) for x in sys.stdin.readline().split())
s = sys.stdin.readline().rstrip()
if s[a] == '-':
s_a, s_b = s[:a], s[a+1:]
for i in s_a:
if not i in string.digits:
f_a = False
break
else:
f_a = True
for i in s_b:
if not i in string.digits:
f_b = False
break
else:
f_b = True
else:
print('No')
exit()
print(('Yes' if f_a and f_b else 'No'))
if __name__ == "__main__":
# execute only if run as a script
main()
| import sys
a, b = list(map(int, sys.stdin.readline().split()))
s = sys.stdin.readline().rstrip()
def main():
return 'Yes' if s[a] == '-' and not '-' in set(s[:a] + s[a+1:]) else 'No'
if __name__ == '__main__':
ans = main()
print(ans) | p03474 |
a=list(map(int,input().split()));t=list(map(len,input().split('-')));print(['No','Yes'][a==t]) | print(['No','Yes'][list(map(int,input().split()))==list(map(len,input().split('-')))]) | p03474 |
"""
author : halo2halo
date : 24, Jan, 2020
"""
import sys
# import itertools
# import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
A, B = list(map(int, readline().split()))
S = readline().decode('utf8').rstrip()
T=S[:A]+S[A+1:]
bl = S[A] == '-' and not('-' in T)
print(('Yes' if bl else 'No'))
| """
author : halo2halo
date : 24, Jan, 2020
"""
import sys
# import itertools
# import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
A, B = list(map(int, readline().split()))
S = readline().decode('utf8').rstrip()
T=S[:A]+S[A+1:]
bl = S[A] == '-' and T.find('-')==-1
print(('Yes' if bl else 'No'))
| p03474 |
import re
a,b = list(map(int, input().split()))
s = input().split('-')
print(('Yes' if len(s)==2 and len(s[0])==a else 'No')) | a,b = list(map(int, input().split()))
s = input().split('-')
print(('Yes' if len(s)==2 and len(s[0])==a else 'No')) | p03474 |
import re,sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
A,B = LI()
S = S()
print(('Yes' if re.fullmatch(pattern=r'\d{{{}}}-\d{{{}}}'.format(A,B),string=S) else 'No'))
| import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
A,B = LI()
S = S()
ans = 1
for i in range(A+B+1):
if i==A:
if S[i]!='-':
ans = 0
break
else:
if not S[i] in '1234567890':
ans = 0
break
print((['No','Yes'][ans]))
| p03474 |
#!/usr/bin/env python3
import sys
YES = "Yes" # type: str
NO = "No" # type: str
def solve(A: int, B: int, S: str):
is_hyphen = True if S[A : A + 1] == "-" else False
before = S[:A]
after = S[A + 1 :]
try:
int(before)
int(after)
if is_hyphen:
print(YES)
else:
print(NO)
except:
print(NO)
return
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
S = next(tokens) # type: str
solve(A, B, S)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
YES = "Yes" # type: str
NO = "No" # type: str
def solve(A: int, B: int, S: str):
is_mid = True if S[A] == "-" else False
is_num = (S[:A] + S[A + 1 :]).find("-") == -1
print((YES if is_mid and is_num else NO))
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
S = next(tokens) # type: str
solve(A, B, S)
if __name__ == "__main__":
main()
| p03474 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0144
"""
import sys
from sys import stdin
input = stdin.readline
from enum import Enum
class Graph(object):
""" single source shortest path """
class Status(Enum):
""" ?????????????¨??????¶??? """
white = 1 # ????¨????
gray = 2 # ?¨???????
black = 3 #?¨???????
def __init__(self, n, data):
num_of_nodes = n+1
self.color = [Graph.Status.white] * num_of_nodes # ????????????????¨??????¶???
self.M = [[float('inf')] * num_of_nodes for _ in range(num_of_nodes)]
for i in range(num_of_nodes):
self.M[i][i] = 0
self._make_matrix(data) # data????????????????????£??\??????(?????\?¶???¨???????????????????????§????????????)
self.d = [float('inf')] * num_of_nodes # ?§???????????????????(?????????)
self.p = [-1] * num_of_nodes # ????????????????????????????¨?????????????????????????
def _make_matrix(self, data):
for d in data:
r = d[0]
for t in d[2:]:
self.M[r][t] = 1
def dijkstra(self, start):
self.d[start] = 0
self.p[start] = -1
while True:
mincost = float('inf')
# ??\??????????????§??????????????¨?????????????????????u???????????????
for i in range(len(self.d)):
if self.color[i] != Graph.Status.black and self.d[i] < mincost: # S????±???????????????????S??¨??\?¶?????????????????????????????????????????°???????????????????
mincost = self.d[i]
u = i # u??????????????????ID
if mincost == float('inf'):
break
self.color[u] = Graph.Status.black # ?????????u???S????±???????????????´???
for v in range(len(self.d)):
if self.color[v] != Graph.Status.black and self.M[u][v] != float('inf'):
# v????????????????????????????????°??????S???????????£???u????????????????????????????????????????????°??????????????±??§??´??°??????
if self.d[u] + self.M[u][v] < self.d[v]:
self.d[v] = self.d[u] + self.M[u][v]
self.p[v] = u
self.color[v] = Graph.Status.gray
def main(args):
n = int(eval(input()))
network = []
for _ in range(n):
network.append([int(x) for x in input().split()])
packets = []
p = int(eval(input()))
for _ in range(p):
packets.append([int(x) for x in input().split()])
memo = [[0]*(n+1) for _ in range(n+1)]
for i in range(1, n+1):
g = Graph(n, network)
g.dijkstra(i)
for j in range(1, n+1):
if i == j:
continue
if g.d[j] == float('inf'):
memo[i][j] = float('inf')
else:
path = [j]
u = j
while g.p[u] != i:
path.append(g.p[u])
u = g.p[u]
path.append(i)
memo[i][j] = len(path)
for s, d, v in packets:
if memo[s][d] <= v:
print((memo[s][d]))
else:
print('NA')
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0144
"""
import sys
from sys import stdin
input = stdin.readline
from enum import Enum
class Graph(object):
""" single source shortest path """
class Status(Enum):
""" ?????????????¨??????¶??? """
white = 1 # ????¨????
gray = 2 # ?¨???????
black = 3 #?¨???????
def __init__(self, n, data):
self.num_of_nodes = n+1
self.color = [Graph.Status.white] * self.num_of_nodes # ????????????????¨??????¶???
self.M = [[float('inf')] * self.num_of_nodes for _ in range(self.num_of_nodes)]
for i in range(self.num_of_nodes):
self.M[i][i] = 0
self._make_matrix(data) # data????????????????????£??\??????(?????\?¶???¨???????????????????????§????????????)
self.d = [float('inf')] * self.num_of_nodes # ?§???????????????????(?????????)
self.p = [-1] * self.num_of_nodes # ????????????????????????????¨?????????????????????????
def _make_matrix(self, data):
for d in data:
r = d[0]
for t in d[2:]:
self.M[r][t] = 1
def dijkstra(self, start):
self.d[start] = 0
self.p[start] = -1
while True:
mincost = float('inf')
# ??\??????????????§??????????????¨?????????????????????u???????????????
for i in range(len(self.d)):
if self.color[i] != Graph.Status.black and self.d[i] < mincost: # S????±???????????????????S??¨??\?¶?????????????????????????????????????????°???????????????????
mincost = self.d[i]
u = i # u??????????????????ID
if mincost == float('inf'):
break
self.color[u] = Graph.Status.black # ?????????u???S????±???????????????´???
for v in range(len(self.d)):
if self.color[v] != Graph.Status.black and self.M[u][v] != float('inf'):
# v????????????????????????????????°??????S???????????£???u????????????????????????????????????????????°??????????????±??§??´??°??????
if self.d[u] + self.M[u][v] < self.d[v]:
self.d[v] = self.d[u] + self.M[u][v]
self.p[v] = u
self.color[v] = Graph.Status.gray
def warshallFloyd(self):
V = self.num_of_nodes
for k in range(V):
for i in range(V):
for j in range(V):
self.M[i][j] = min(self.M[i][j], self.M[i][k] + self.M[k][j])
def main(args):
n = int(eval(input()))
network = []
for _ in range(n):
network.append([int(x) for x in input().split()])
packets = []
p = int(eval(input()))
for _ in range(p):
packets.append([int(x) for x in input().split()])
g = Graph(n, network)
g.warshallFloyd()
for s, d, v in packets:
if g.M[s][d] < v:
print((g.M[s][d]+1))
else:
print('NA')
if __name__ == '__main__':
main(sys.argv[1:]) | p00144 |
from collections import deque
n=int(input())
r=[list(map(int,input().split())) for _ in range(n)]
m=int(input())
pa=[list(map(int,input().split())) for _ in range(m)]
for i in range(m):
d=[1]*n
q=deque([pa[i][0]])
used=[False]*n
used[pa[i][0]-1]=True
while len(q)!=0:
f=0
p=q.popleft()
p-=1
if d[p]==pa[i][2]:break
for j in r[p][2:]:
j-=1
if pa[i][1]-1==j:
f=1
d[j]+=d[p]
break
if used[r[j][0]-1]:continue
q.append(j+1)
d[j]=d[p]+1
used[j]=True
if f==1:
break
if f==1:
print((d[j]))
else:
print("NA") | n=int(input())
g=[[1000000]*n for _ in range(n)]
for i in range(n):
g[i][i]=0
for i in range(n):
r=list(map(int,input().split()))
for j in r[2:]:
g[r[0]-1][j-1]=1
for k in range(n):
for i in range(n):
for j in range(n):
g[i][j]=min(g[i][j],g[i][k]+g[k][j])
m=int(input())
for i in range(m):
s,d,v=list(map(int,input().split()))
s-=1
d-=1
if g[s][d]<v:
print((g[s][d]+1))
else:
print('NA') | p00144 |
n=int(eval(input()))
count=0
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
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
for i in make_divisors(n):
if int(n)!=n or n==1:
break
if n%i==0 and len(factorization(i))==1:
n=n/i
count+=1
if count-1>=0:
print((count-1))
else:
print((0))
| from collections import Counter
n=int(eval(input()))
def soin(n):
soin_ans=[]
while n%2==0:
n//=2
soin_ans.append(2)
f=3
while f<=n**0.5:
if n%f==0:
n//=f
soin_ans.append(f)
else:
f+=2
if n!=1:
soin_ans.append(n)
return soin_ans
s_list=soin(n)
s_set=set(s_list)
sc=Counter(s_list)
count=0
for i in s_set:
for j in range(1,sc[i]+1):
if n%i**j==0:
n//=i**j
count+=1
print(count) | p02660 |
n = int(eval(input()))
ans = 0
i = 2
while n>1 and i*i<=n:
if n % i == 0:
c = 0
while n % i == 0:
n = n / i
c = c + 1
Y=1
U=2
while c>=Y:
ans=ans+1
Y=Y+U
U=U+1
i = i + 1
if n > 1:
ans = 1 + ans
print(ans) | n = int(eval(input()))
ans = 0
i = 2
while n>1 and i*i<=n:
if n % i == 0:
c = 0
while n % i == 0:
n = n / i
c = c + 1
Y=1
U=2
while c>=Y:
ans=ans+1
Y=Y+U
U=U+1
i += 1
if n > 1:
ans = 1 + ans
print(ans) | p02660 |
n = int(eval(input()))
ans = 0
i = 2
while n>1 and i*i<=n:
if n % i == 0:
c = 0
while n % i == 0:
n = n / i
c += 1
Y=1
U=2
while c>=Y:
ans=ans+1
Y=Y+U
U=U+1
i = i + 1
if n > 1:
ans = 1 + ans
print(ans)
| n = int(eval(input()))
ans = 0
i = 2
while n>1 and i*i<=n:
if n % i == 0:
c = 0
while n % i == 0:
n = n / i
c += 1
j = 1
while c>=j:
ans=ans+1
c -= j
j += 1
i = i + 1
if n > 1:
ans = 1 + ans
print(ans) | p02660 |
import sys
N = int(sys.stdin.readline().rstrip())
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_judge(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)
a = set(a)
if len(a) == 1:
return True
else:
return False
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)
a = set(a)
if len(a) == 1 and prime_judge(list(a)[0]):
return True
else:
return False
divisors = make_divisors(N)
ans = 0
for d in divisors:
if prime_factorize(d) and N % d == 0 and N // d > 0:
N //= d
ans += 1
print(ans)
| import sys
N = int(sys.stdin.readline().rstrip())
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_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)
a = set(a)
if len(a) == 1:
return True
else:
return False
divisors = make_divisors(N)
ans = 0
for d in divisors:
if prime_factorize(d) and N % d == 0:
N //= d
ans += 1
print(ans) | p02660 |
import sys
N = int(sys.stdin.readline().rstrip())
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_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)
a = set(a)
if len(a) == 1:
return True
else:
return False
divisors = make_divisors(N)
ans = 0
for d in divisors:
if prime_factorize(d) and N % d == 0:
N //= d
ans += 1
print(ans) | import sys
N = int(sys.stdin.readline().rstrip())
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
primes = prime_factorize(N)
from collections import Counter
cnts = Counter(primes)
ans = 0
for p, cnt in list(cnts.items()):
tmp = 1
while cnt - tmp >= 0:
cnt -= tmp
tmp += 1
ans += 1
print(ans) | p02660 |
import math
N = int(eval(input()))
if N == 1:
print((0))
exit()
div = {}
i = 2
while i*i <= N:
while N % i == 0:
N = N // i
if i in div:
div[i] += 1
else:
div[i] = 1
if N == 1:
break
i += 1
if N != 1:
div[N] = 1
ans = 0
for v in list(div.values()):
i = 1
while v >= i:
v -= i
i += 1
ans += 1
print(ans)
| import math
N = int(eval(input()))
if N == 1:
print((0))
exit()
div = {}
for i in range(2, int(math.sqrt(N))+1):
while N % i == 0:
N = N // i
if i in div:
div[i] += 1
else:
div[i] = 1
if N == 1:
break
if N != 1:
div[N] = 1
ans = 0
for v in list(div.values()):
i = 1
while v >= i:
v -= i
i += 1
ans += 1
print(ans)
| p02660 |
def find_primes(n):
ps = []
t = [True] * n
t[0] = t[1] = False
for i in range(2, n):
if not t[i]:
continue
ps.append(i)
for j in range(i, n, i):
t[j] = False
return ps
def solve(string):
n = int(string)
if n == 1:
return "0"
rn = int(n**0.5 + 1)
ps = find_primes(rn)
ans = 0
for i in ps:
k = 1
while n % (i**k) == 0:
ans += 1
n //= i**k
k += 1
return str(ans + (n >= rn))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| import collections
n = int(eval(input()))
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
if n == 1: # 1
print((0))
exit()
c = collections.Counter(prime_factorize(n))
_, counts = list(zip(*c.most_common()))
l = list(counts)
ans = 0
if l == [1]: # prime number
print((1))
exit()
for i in l:
for j in range(1, i+1):
if i >= j:
i -= j
ans += 1
print(ans)
| p02660 |
import math
def get_prime(n):
if n <= 1:
return []
prime = [2]
if n > 2:
limit = int(math.sqrt(n))
odd = [i for i in range(3, n + 1, 2)]
while limit >= odd[0]:
prime.append(odd[0])
odd = [j for j in odd if j % odd[0] != 0]
prime += odd
return prime
from collections import defaultdict
def prime_factorization(n):
if n <= 1:
return {}
else:
# print(int(math.sqrt(n)))
prime = get_prime(int(math.sqrt(n)))
dct = defaultdict(int)
for p in prime:
while n % p == 0:
dct[p] += 1
n //= p
if n != 1:
dct[n] += 1
dct = dict(dct)
return dct
n = int(eval(input()))
pf = prime_factorization(n)
Z = []
for k, v in list(pf.items()):
for i in range(1, v + 1):
Z.append(k ** i)
Z.sort()
count = 0
for z in Z:
if n % z == 0:
count += 1
n //= z
print(count) | def p_facto(n):
ret = []
nc = n
for i in range(2, nc):
if i*i > nc:
break
if n % i == 0:
ex = 0
while n % i == 0:
ex += 1
n //= i
ret.append([i, ex])
if n != 1:
ret.append([n, 1])
return ret
def main(N):
ans = 0
for p, e in pf:
ex = 1
while True:
z = p**ex
if N % z == 0:
ans += 1
N //= z
else:
break
ex += 1
print(ans)
if __name__ == "__main__":
N = int(eval(input()))
pf = p_facto(N)
main(N)
| p02660 |
N = int(eval(input()))
if N == 1:
print((0))
exit()
primes = []
i = 2
tmp = N
flag = False
while i**2 <= tmp:
if N % i == 0:
flag = True
count = 0
while N % i == 0:
N //= i
count += 1
primes.append((i, count))
i += 1
if (not N == 1) and flag:
i = 2
tmp = N
while N > 1:
if N % i == 0:
count = 0
while N % i == 0:
N //= i
count += 1
primes.append((i, count))
i += 1
if not primes:
print((1))
exit()
count = 0
for p in primes:
c = 0
t = 0
for i in range(1, 10 ** 9):
c += i
t += 1
if c > p[1]:
count += t - 1
break
elif c == p[1]:
count += t
break
print(count)
| N = int(eval(input()))
if N == 1:
print((0))
exit()
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
primes = factorization(N)
count = 0
for p in primes:
c = 0
t = 0
for i in range(1, 10 ** 9):
c += i
t += 1
if c > p[1]:
count += t - 1
break
elif c == p[1]:
count += t
break
print(count)
| p02660 |
import sys
read = sys.stdin.read
def main():
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(eval(input()))
if n == 1:
print((0))
sys.exit()
nfac = factorization(n)
r = 0
for nfe in nfac:
c = 1
while True:
if c <= nfe[1]:
nfe[1] -= c
r += 1
c += 1
else:
break
print(r)
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
# 「素数の乗数」かつ「Nを割り切れる」数Zをなるべく多く選ぶ
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(eval(input()))
if n == 1:
print((0))
sys.exit()
pfactors = factorization(n)
r = 0
for pfe in pfactors:
pfe1 = pfe[1]
t1 = 1
while pfe1:
if pfe1 >= t1:
r += 1
pfe1 -= t1
t1 += 1
else:
break
print(r)
if __name__ == '__main__':
main() | p02660 |
N = int(eval(input()))
def prime_factorize(n):
if n == 1:
return []
ans = []
tmp = n
i = 2
while pow(i, 2) <= n:
if tmp % i == 0:
cnt = 0
while tmp % i == 0:
cnt += 1
tmp /= i
ans.append([i, cnt])
i += 1
if tmp != 1:
ans.append([tmp, 1])
if ans == []:
ans.append([n, 1])
return ans
pl = prime_factorize(N)
ans = 0
for p, n in pl:
tmp = n
i = 1
while tmp-i >= 0:
tmp -= i
i += 1
ans += 1
print(ans) | N = int(eval(input()))
i = 2
tmp = N
ans = 0
while i*i <= N:
cnt = 0
while tmp % i == 0:
tmp //= i
cnt += 1
if cnt > 0:
k = 1
while cnt - k >= 0:
cnt -= k
ans += 1
k += 1
i += 1
if tmp != 1:
ans += 1
print(ans) | p02660 |
from functools import reduce
from decimal import *
from operator import mul
def main():
n = int(eval(input()))
p = prime_factorize(n)
sa = list(sorted(p))
pp = []
num = 1
for i, v in enumerate(sa):
if i > 0 and sa[i-1] != v:
num = 1
num *= v
if num not in pp and n % num == 0:
pp.append(num)
num = 1
print((len(pp)))
def input_list():
return list(map(int, input().split()))
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
if __name__ == '__main__':
main()
| # import sys
# input = sys.stdin.readline
import itertools
import collections
from decimal import Decimal
# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
n = int(eval(input()))
p = prime_factorize(n)
cp = collections.Counter(p)
ans = 0
for c, num in list(cp.items()):
count = 0
jou = 1
for _ in range(num):
count += 1
if count == jou:
count = 0
jou += 1
ans += 1
print(ans)
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 bfs(H, W, black_cells, dist):
d = 0
while black_cells:
h, w = black_cells.popleft()
d = dist[h][w]
for dy, dx in ((1, 0), (0, 1), (-1, 0), (0, -1)):
new_h = h + dy
new_w = w + dx
if new_h < 0 or H <= new_h or new_w < 0 or W <= new_w:
continue
if dist[new_h][new_w] == -1:
dist[new_h][new_w] = d + 1
black_cells.append((new_h, new_w))
return d
def input_list():
return list(map(Decimal, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| p02660 |
n = int(eval(input()))
dic = {}
def f(num):
while(num%2==0):
num //= 2
if(dic.get(2) is None):
dic[2] = 1
else:
dic[2] += 1
s = 3
while((s*s) <= num):
if((num % s)==0):
if(dic.get(s) is None):
dic[s] = 1
else:
dic[s] += 1
num //= s
else:
s += 2
if num != 1:
if(dic.get(num) is None):
dic[num] = 1
else:
dic[num] += 1
f(n)
l = []
for x,y in list(dic.items()):
cnt = 1
if(y==1):
l.append(x)
continue
while(y >= cnt):
l.append((x**cnt))
y -= cnt
cnt += 1
print((len(l)))
| n = int(eval(input()))
def pFact(n):
l=[]
if(n==1):
return [1]
while(n%2==0):
l.append(2)
n//=2
f=3
while(f*f <= n):
if(n%f==0):
l.append(f)
n//=f
else:
f += 2
if(n!=1):
l.append(n)
return l
l = pFact(n)
dic = {}
div_l = []
for x in l:
if(dic.get(x) is None):
dic[x] = 1
else:
dic[x] += 1
cnt = 0
for x,y in list(dic.items()):
if(x==1):
continue
e = 1
while((y-e)>=0):
y -= e
e += 1
cnt += 1
print(cnt) | p02660 |
def factorize(n):
res = []
i = 2
while i * i <= n:
cnt = 0
while n % i == 0:
cnt += 1
n //= i
if cnt > 0:
res.append([i, cnt])
i += 1
if n != 1:
res.append([n, 1])
return res
n = int(eval(input()))
nlist = factorize(n)
ans = 0
for j in range(0, len(nlist)):
sum_ = 1
i = 2
while nlist[j][1] >= sum_:
sum_ += i
i += 1
ans += i-2
print(ans) | def factorize(n):
res = []
i = 2
while i * i <= n:
cnt = 0
while n % i == 0:
cnt += 1
n //= i
if cnt > 0:
res.append([i, cnt])
i += 1
if n != 1:
res.append([n, 1])
return res
n = int(eval(input()))
nlist = factorize(n)
ans = 0
for k, v in nlist:
i = 1
while v >= i:
v -= i
i += 1
ans += i-1
print(ans) | p02660 |
#約数
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 soinsu_bunkai(m):
pf={}
for i in range(2,int(m**0.5)+1):
while m%i==0:
pf[i]=pf.get(i,0)+1
m//=i
if m>1:
pf[m]=1
return pf
# 初期入力
import sys
input = sys.stdin.readline
N = int(eval(input()))
div =make_divisors(N)
div.sort()
div_2 =div[1:]
count =0
for i in div_2:
i2 = soinsu_bunkai(i)
if len(i2) ==1:
q,mod =divmod(N,i)
if mod ==0:
count +=1
N =q
print(count) | #約数
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 soinsu_bunkai(m):
pf={}
for i in range(2,int(m**0.5)+1):
while m%i==0:
pf[i]=pf.get(i,0)+1
m//=i
if m>1:
pf[m]=1
return pf
#初期入力
N = int(eval(input()))
div =make_divisors(N) #Nの約数
div.sort()
div_1_except=div[1:]
count =0
for i in div_1_except:
q,mod= divmod(N,i)
if mod ==0:
ii =soinsu_bunkai(i) #Nの約数を素因数分解
if len(ii) ==1 :
count +=1
N =q
print(count) | p02660 |
#約数
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 soinsu_bunkai(m):
pf={}
for i in range(2,int(m**0.5)+1):
while m%i==0:
pf[i]=pf.get(i,0)+1
m//=i
if m>1:
pf[m]=1
return pf
#初期入力
N = int(eval(input()))
div =make_divisors(N) #Nの約数
div.sort()
div_1_except=div[1:]
count =0
for i in div_1_except:
q,mod= divmod(N,i)
if mod ==0:
ii =soinsu_bunkai(i) #Nの約数を素因数分解
if len(ii) ==1 :
count +=1
N =q
print(count) | #約数は使わず、素因数分解のみ
#素因数分解
def soinsu_bunkai(m):
pf={}
for i in range(2,int(m**0.5)+1):
while m%i==0:
pf[i]=pf.get(i,0)+1
m//=i
if m>1:
pf[m]=1
return pf
#初期入力
N = int(eval(input()))
xx =[]
prime_factorization =soinsu_bunkai(N)
count =0
for i in list(prime_factorization.keys()):
x=1
while x <= prime_factorization[i]:
if N % i**x ==0:
xx.append(i**x)
count +=1
N //= i**x
x +=1
print(count) | p02660 |
def LI():return list(map(int,input().split()))
def yes():return print("Yes")
def no():return print("No")
from collections import deque, defaultdict, Counter
# from heapq import heappop, heappush
# import math
# from decimal import Decimal
# def divisors(x):
# ret=[]
# for i in range(1,int(x**.5)+1):
# if x%i==0:
# ret.append(i)
# if x//i==i:continue
# ret.append(x//i)
# return sorted(ret)
# print(divisors(64),2**6)
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
n=int(input())
pf=prime_factor(n)
pf=Counter(pf)
# print(pf)
def cng(x):
le=2*x
ret=-1
mi=int(le**0.5)
for i in range(mi-1,mi+10000):
# print((i+1)*(i+2),le,i*(i+1))
if (i+1)*(i+2)>le>=i*(i+1):
ret=i
# print((i+1)*(i+2),le,i*(i+1))
break
return ret
mp=[]
for i in range(2*10**5):
mp.append(cng(i))
# print(-1 in mp)
ans=0
for i in pf.values():
ans+=mp[i]
print(ans)
| a=[]
for i in range(51):
a+=[i]*(i+1)
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
from collections import Counter
c=Counter(prime_factor(int(eval(input()))))
ans=0
for i in list(c.values()):
ans+=a[i]
print(ans) | p02660 |
n=int(eval(input()))
M=10**6+1
l=[]
p=[1]*M
for i in range(2,M):
if p[i]:
l+=[i]
for j in range(2*i,M,i):
p[j]=0
d={}
for k in l:
c=0
while n%k==0: n//=k; c+=1
if c>0: d[k]=c
s=[1]
for i in range(2,9):
s.append(s[-1]+i)
a=0
for i in list(d.values()):
for j in s:
if j>i: break
a+=1
print((a+(n>1))) | n=int(eval(input()))
M=10**6
l=[]
p=[1]*M
for i in range(2,M):
if p[i]:
l+=[i]
for j in range(2*i,M,i): p[j]=0
d={}
for k in l:
while n%k<1: n//=k; d[k]=d.get(k,0)+1
a=0
for i in list(d.values()):
t=c=0
while t+c<i: c+=1; t+=c
a+=c
print((a+(n>1))) | p02660 |
n=int(eval(input()))
M=10**6
l=[]
p=[1]*M
for i in range(2,M):
if p[i]:
l+=[i]
for j in range(2*i,M,i): p[j]=0
d={}
for k in l:
while n%k<1: n//=k; d[k]=d.get(k,0)+1
a=0
for i in list(d.values()):
t=c=0
while t+c<i: c+=1; t+=c
a+=c
print((a+(n>1))) | n=int(eval(input()))
d={}
for k in range(2,10**6):
while n%k<1: n//=k; d[k]=d.get(k,0)+1
a=0
for i in list(d.values()):
t=c=0
while t+c<i: c+=1; t+=c
a+=c
print((a+(n>1))) | p02660 |
n=int(eval(input()))
int_sqrt=lambda x:int(x**0.5)+1
def sieve(x):
p=[]
b=[1]*x
for i in range(2,x):
if b[i]:
p+=[i]
for j in range(2*i,x,i): b[j]=0
return p
def prime_factor(x):
d={}
for i in p:
while x%i<1:
x//=i
d[i]=d.get(i,0)+1
if x<2: break
if x>1: d[x]=1
return d
p=sieve(int_sqrt(n))
d=prime_factor(n)
a=0
for i in list(d.values()):
t=c=0
while t+c<i: c+=1; t+=c
a+=c
print(a) | n=int(eval(input()))
int_sqrt=lambda x:int(x**0.5)+1
def prime_factor(x):
d={}
for i in p:
while x%i<1:
x//=i
d[i]=d.get(i,0)+1
if x<2: break
if x>1: d[x]=1
return d
p=list(range(2,int_sqrt(n)))
d=prime_factor(n)
a=0
for i in list(d.values()):
t=c=0
while t+c<i: c+=1; t+=c
a+=c
print(a) | p02660 |
n=int(eval(input()))
int_sqrt=lambda x:int(x**0.5)+1
def prime_factor(x):
d={}
for i in p:
while x%i<1:
x//=i
d[i]=d.get(i,0)+1
if x<2: break
if x>1: d[x]=1
return d
p=list(range(2,int_sqrt(n)))
d=prime_factor(n)
a=0
for i in list(d.values()):
t=c=0
while t+c<i: c+=1; t+=c
a+=c
print(a) | n=int(eval(input()))
d={2:0}
while n%2<1: n//=2; d[2]+=1
for i in range(3,int(n**0.5)+1,2):
while n%i<1: n//=i; d[i]=d.get(i,0)+1
if n<2: break
if n>1: d[n]=1
a=0
for i in list(d.values()):
t=c=0
while t+c<i: c+=1; t+=c
a+=c
print(a) | p02660 |
n = int(eval(input()))
# 素因数分解
# √n+1までを対象に因数分解
# 素数のみを対象に処理しなくても2で引っかかる場合は4、6などは対象にならない。
prime = []
for i in range(2, int(n**0.5)+1):
cnt = 0
while n%i == 0:
n //= i # 割り切れる場合に最後の処理で余りが1になり、ループを抜ける
cnt += 1
prime.append(cnt) # 因数分解した回数を保持
if n == 1:
break
# 対象が素数であった場合は１を結果として保持
if n > 1:
prime.append(1)
ans = 0
for x in prime:
for i in range(1, x+1):
if x >= i: # 素数の数をカウント
ans += 1
x -= i
else:
break
print(ans) | n = int(eval(input()))
s = []
for i in range(2, int(n**0.5)+1):
t = 0
while n%i == 0:
n //= i
t += 1
s.append(t)
if n == 1: break
if n > 1: s.append(1)
ans = 0
for i in s:
for j in range(1, i+1):
if i >= j:
i -= j
ans += 1
else:
break
print(ans) | p02660 |
import sys
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
def renzoku(n):
x = (-1+(1+8*n)**(0.5))//2
return int(x)
N = int(eval(input()))
if N == 1:
print("0")
sys.exit()
oriN = N*1
A = factorization(N)
#print(A)
M = len(A)
ans = 0
for i in range(M):
temp = A[i][1]
f = renzoku(temp)
ans += f
print(ans) | 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==[]: #1の場合はここ
arr.append([n, 1])
return arr
def count(X):
cnt = 0
now = 1
while cnt+now <=X:
cnt += now
now += 1
return now-1
#print(count(3))
N = int(eval(input()))
if N == 1:
print((0))
exit()
A = factorization(N)
#print(A)
ans = 0
for i in range(len(A)):
ans += count(A[i][1])
print(ans)
| p02660 |
n = int(eval(input()))
def pcheck(n):
if n == 1:
return False
else:
root = int(n ** 0.5)
for i in range(2, root + 1):
if n % i == 0:
return False
return True
if n == 1:
print('0')
elif pcheck(n) == True:
print('1')
else:
rootn = int(n ** 0.5)
k = 0
for i in range(2, rootn + 2):
if n == 1:
print(k)
break
elif n % i == 0:
j = 1
p = i
while n % p == 0:
k += 1
n //= p
j += 1
p = i ** j
p //= i
while n % i == 0:
if n % p != 0:
p //= i
continue
n //= p
if pcheck(n) == True:
k += 1
print(k)
break
else:
print('1') | n = int(eval(input()))
def pcheck(n):
if n == 1:
return False
else:
root = int(n ** 0.5)
for i in range(2, root + 1):
if n % i == 0:
return False
return True
if n == 1:
print('0')
elif n == 6:
print('2')
elif pcheck(n) == True:
print('1')
else:
rootn = int(n ** 0.5)
k = 0
for i in range(2, rootn + 2):
if n == 1:
print(k)
break
elif n % i == 0:
j = 1
p = i
while n % p == 0:
k += 1
n //= p
j += 1
p = i ** j
p //= i
while n % i == 0:
if n % p != 0:
p //= i
continue
n //= p
else:
if pcheck(n) == True:
k += 1
print(k)
else:
print('1')
| p02660 |
from collections import defaultdict
import decimal
import sys
input = sys.stdin.readline
def prime_factor_count(n):
def count(n, i):
cnt = 0
while n % i == 0:
cnt += 1
n //= i
return n, cnt
d = {}
if n == 1:
return d
n, cnt = count(n, 2)
d[2] = cnt
lst = [2]
for num in range(3, int(n ** 0.5) + 1, 2):
if n == 1:
break
for p_num in lst:
if num % p_num == 0:
break
elif p_num * p_num > num:
lst.append(num)
n, cnt = count(n, num)
d[num] = cnt
break
else:
if n != 1:
d[n] = 1
return d
def main():
n = int(eval(input()))
d = prime_factor_count(n)
cnt = 0
tmp_n = 0
for k, v in list(d.items()):
exp_cnt = 1
while 1:
if exp_cnt > v:
break
else:
if tmp_n % (tmp_exp := k ** exp_cnt) == 0:
tmp_n //= tmp_exp
cnt += 1
v -= exp_cnt
exp_cnt += 1
else:
if n == tmp_n:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def prime_factor_count(n):
def count(n, p):
cnt = 0
while n % p == 0:
n //= p
cnt += 1
np_cnt = 1
while (cnt := cnt - np_cnt) >= 0:
np_cnt += 1
return n, np_cnt - 1
n, cnt = count(n, 2)
if n == 1:
return cnt
for i in range(3, int(n ** 0.5) * 1, 2):
n, tmp_cnt = count(n, i)
cnt += tmp_cnt
if n == 1:
break
else:
cnt += 1
return cnt
def main():
n = int(eval(input()))
ans = prime_factor_count(n)
print(ans)
if __name__ == '__main__':
main()
| p02660 |
def main():
from math import sqrt
N = int(eval(input()))
def prime_factorization(n):
facts = []
for i in range(2, int(sqrt(n)) + 5):
while n % i == 0:
n //= i
facts.append(i)
if n != 1:
facts.append(n)
return facts
ans = 0
facts = sorted(set(prime_factorization(N)))
for f in facts:
i = 1
while N % (f**i) == 0:
N //= f**i
i += 1
ans += 1
print(ans)
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
def prime_factorize(n):
res = []
for i in range(2, n+1):
if i*i > n:
break
if n % i != 0:
continue
ex = 0
while n % i == 0:
ex += 1
n //= i
res.append((i, ex))
if n != 1:
res.append((n, 1))
return res
divs = prime_factorize(N)
ans = 0
for p, e in divs:
d = p
for _ in range(e):
if N % d != 0:
break
N //= d
d *= p
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p02660 |
import sys
input = sys.stdin.readline
def factors(x: int) -> list:
s, xx = [], x
for i in range(2, int(x ** 0.5 + 1)):
if xx % i == 0:
c = 0
while xx % i == 0: c += 1; xx //= i
s.append((i, c))
if xx != 1: s.append((xx, 1))
if s == []: s.append((x, 1))
return s
n, res = int(eval(input())), 0
f = factors(n)
pre = [1, 3, 6, 10, 15, 21, 28, 36, 43]
flag = False
if len(f) == 1 and f[0][0] == 1: print((0)); flag = True
if not flag:
for fact in f:
for i in range(len(pre)):
if pre[i] > fact[1]: res += i; break
print(res) | import sys
input = sys.stdin.readline
from collections import defaultdict
def prime(n: int) -> defaultdict:
f, i = defaultdict(int), 2
while i * i <= n:
while n % i == 0: f[i] += 1; n //= i
i += 1
if n != 1: f[n] = 1
return f
def solve(n: int) -> int:
if n == 1: return 1
r, l = n, 0
while (r - l) > 1:
m = (l + r) // 2
if m * (m + 1) // 2 <= n: l = m
else: r = m
return l
n, res = int(eval(input())), 0
for k, v in list(prime(n).items()): res += solve(v)
print(res) | p02660 |
n=int(eval(input()))
def primes_factraizar(n):
rn = int(n**0.5)
is_prime = [True] * (rn+1) #まずは[1]*n^0.5を用意
is_prime[0] = False
is_prime[1] = False
for i in range(2, rn + 1): #素数の判定√nまでで十分
if not is_prime[i]: #非素数は無視
continue #continue分はループ中の後続の命令をスキップする
for j in range(i * 2, rn + 1, i): #i*2~nまでのiの倍数を順番に消す
is_prime[j] = False
return [i for i in range(rn + 1) if is_prime[i]]
primes = primes_factraizar(n)
if n==0 or n==1:
print((0))
exit()
div = []
for i in primes:
for j in range(1000):
if n%i==0:
n=n//i
else:
if j == 0:
break
div.append(j)
break
if n != 1:
div.append(1)
if div == []:
print((1))
exit()
ans = 0
for i in div:
c = 0
for j in range(1,10**9):
if i >= c+j:
c+=j
else:
ans += j-1
break
print(ans)
| n = int(eval(input()))
if n == 1:
print((0))
exit()
def primes_factraizar(n):
rn = int(n**0.5)
is_prime = [True]*(rn+1)
is_prime[0] = False
is_prime[1] = False
for i in range(2,rn+1):
if not is_prime[i]:
continue
for j in range(i*2,rn+1,i):
is_prime[j] = False
return [i for i in range(rn+1) if is_prime[i]]
primes = primes_factraizar(n)
divisors = []
for i in primes:
if n % i == 0:
divisors.append(i)
divisors.sort()
if divisors == []:
print((1))
exit()
ans = 0
for i in divisors:
if i == 1:
continue
c = 0
while n%i == 0:
n = n // i
c += 1
d=0
for count in range(1,1000):
if c >= d+count:
ans += 1
d+=count
else:
break
if not n == 1:
ans += 1
print(ans) | p02660 |
import math
# 素数リスト生成 eratosthenes
def makePrime(m):
p = [i for i in range(m + 1)]
for i in p[3:]:
if p[i] % 2 == 0: p[i] = 0
root_m = m ** 0.5
for i in range(3,m):
if i > root_m: break
if p[i] != 0:
for j in range(i, m + 1, 2):
if i * j >= m + 1: break
p[i * j] = 0
#return p
return sorted(list(set(p)))[2:]
# 素数かどうか判定
def isPrime(x):
if x <= 1:
return False
for i in range(2,math.floor(math.sqrt(x))+1):
if (x % i) == 0:
return False
return True
# zの値を作成
def z_make(n,p):
for prime in p:
for i in range(1,100000000000):
z = prime ** i
if z >= n:
break
if not z in memo:
memo.append(z)
def divGame2(n):
for z in memo:
global ans
if n % z == 0:
rem = n / z
memo.remove(z)
ans += 1
#print("n=",n," z=",z,"rem=",rem," ans=",ans)
return divGame2(rem)
memo = [] # memory
ans = 0 # answer
p = [] # Prime
n = int(eval(input()))
p = makePrime(100000)
if isPrime(n): # 素数だったら１が答え
print((1))
else:
z_make(n,p) # zの値を生成。memoができる
memo.sort() # 念のため並び替え
#print(memo)
divGame2(n) # メイン実行
print(ans) # 答えの出力
| n = int(eval(input()))
i = 2
memo = []
while( i*i <= n ):
x = 0
while(n % i == 0):
#print("n % i == 0 =",n,i,"n/i=",n/i,x+1)
n = int(n / i);
x = x + 1
memo.append([i,x])
i = i + 1
if not (n == 1):
memo.append([n,1])
ans = 0
for i in memo:
x = i[1]
b = 1
while b <= x:
x = x - b
b = b + 1
ans = ans + 1
print(ans)
| p02660 |
def func(N):
tmp=N
arr=[]
for i in range(2,int((N**0.5//1))+1):
if tmp%i==0:
cnt=0
while tmp%i==0:
cnt+=1
tmp//=i
arr.append([i,cnt])
if tmp!=1:
arr.append([tmp, 1])
if arr==[]:
arr.append([tmp,1])
return arr
N=int(eval(input()))
a=func(N)
ans=0
if a[0][0]==1:
print((0))
exit()
b=[1,3,6,10,15,21,28,36,45]
for i in a:
for j in range(len(b)):
if i[1]<b[j]:
ans+=j
break
print(ans)
| def func(N):
tmp=N
arr=[]
for i in range(2,int((N**0.5//1))+1):
if tmp%i==0:
cnt=0
while tmp%i==0:
cnt+=1
tmp//=i
arr.append([i,cnt])
if tmp!=1 or arr==[]:
arr.append([tmp, 1])
return arr
N=int(eval(input()))
a=func(N)
ans=0
if a[0][0]==1:
print((0))
exit()
b=[1,3,6,10,15,21,28,36,45]
for i in a:
for j in range(len(b)):
if i[1]<b[j]:
ans+=j
break
print(ans)
| p02660 |
from math import sqrt
N = int(eval(input()))
rn = int(sqrt(N))
sieve = [0] * (rn + 1)
sieve[0] = -1
sieve[1] = -1
t = [0] * (rn + 1)
for i in range(2, rn + 1):
if sieve[i] != 0:
continue
sieve[i] = i
j = i
while j < rn + 1:
t[j] = 1
j *= i
for j in range(i * i, rn + 1, i):
if sieve[j] == 0:
sieve[j] = i
result = 0
last = -1
for i in range(2, rn + 1):
if t[i] == 0:
continue
if N % i == 0:
result += 1
N //= i
last = i
if N != 1 and N > rn:
result += 1
print(result)
| from math import sqrt
def prime_factorize(n):
result = []
for i in range(2, int(sqrt(n)) + 1):
if n % i != 0:
continue
t = 0
while n % i == 0:
n //= i
t += 1
result.append((i, t))
if n == 1:
break
if n != 1:
result.append((n, 1))
return result
N = int(eval(input()))
result = 0
for p, e in prime_factorize(N):
i = 1
while e >= i:
result += 1
e -= i
i += 1
print(result)
| p02660 |
from math import sqrt
def prime_factorize(n):
result = []
for i in range(2, int(sqrt(n)) + 1):
if n % i != 0:
continue
t = 0
while n % i == 0:
n //= i
t += 1
result.append((i, t))
if n == 1:
break
if n != 1:
result.append((n, 1))
return result
N = int(eval(input()))
result = 0
for p, e in prime_factorize(N):
i = 1
while e >= i:
result += 1
e -= i
i += 1
print(result)
| from math import sqrt
def prime_factorize(n):
result = []
if n % 2 == 0:
t = 0
while n % 2 == 0:
n //= 2
t += 1
result.append((2, t))
for i in range(3, int(sqrt(n)) + 1, 2):
if n % i != 0:
continue
t = 0
while n % i == 0:
n //= i
t += 1
result.append((i, t))
if n == 1:
break
if n != 1:
result.append((n, 1))
return result
N = int(eval(input()))
result = 0
for p, e in prime_factorize(N):
i = 1
while e >= i:
result += 1
e -= i
i += 1
print(result)
| p02660 |
from math import sqrt
def prime_factorize(n):
result = []
if n % 2 == 0:
t = 0
while n % 2 == 0:
n //= 2
t += 1
result.append((2, t))
for i in range(3, int(sqrt(n)) + 1, 2):
if n % i != 0:
continue
t = 0
while n % i == 0:
n //= i
t += 1
result.append((i, t))
if n == 1:
break
if n != 1:
result.append((n, 1))
return result
N = int(eval(input()))
result = 0
for p, e in prime_factorize(N):
i = 1
while e >= i:
result += 1
e -= i
i += 1
print(result)
| def prime_factorize(n):
result = []
if n % 2 == 0:
t = 0
while n % 2 == 0:
n //= 2
t += 1
result.append((2, t))
for i in range(3, int(n ** 0.5) + 1, 2):
if n % i != 0:
continue
t = 0
while n % i == 0:
n //= i
t += 1
result.append((i, t))
if n == 1:
break
if n != 1:
result.append((n, 1))
return result
N = int(eval(input()))
result = 0
for p, e in prime_factorize(N):
i = 1
while e >= i:
result += 1
e -= i
i += 1
print(result)
| p02660 |
import math
import random
def is_prime3(q,k=50):
q = abs(q)
#計算するまでもなく判定できるものははじく
if q == 2: return True
if q < 2 or q&1 == 0: return False
#n-1=2^s*dとし（但しaは整数、dは奇数)、dを求める
d = (q-1)>>1
while d&1 == 0:
d >>= 1
#判定をk回繰り返す
for i in range(k):
a = random.randint(1,q-1)
t = d
y = pow(a,t,q)
#[0,s-1]の範囲すべてをチェック
while t != q-1 and y != 1 and y != q-1:
y = pow(y,2,q)
t <<= 1
if y != q-1 and t&1 == 0:
return False
return True
def get_prime(number):
prime_list = []
search_list = list(range(2,number + 1))
while search_list[0] <= math.sqrt(number):
head_num = search_list.pop(0)
prime_list.append(head_num)
search_list = [num for num in search_list if num % head_num != 0]
prime_list.extend(search_list)
return prime_list
l = get_prime(10**6+10)
N = int(eval(input()))
ans = 0
k = 1
i = 0
l2 = []
while(l[i]**2 <= N):
if N % (l[i]**k) == 0:
N //= (l[i]**k)
l2.append(l[i]**k)
k += 1
ans += 1
else:
i += 1
k = 1
index = 0
while(index < len(l2)):
if N % (l2[index]) == 0:
N //= l2[index]
else:
index += 1
if is_prime3(N) and N not in l2:
ans += 1
print(ans)
| import math
def factrization_prime(number):
factor = {}
div = 2
s = math.sqrt(number)
while div < s:
div_cnt = 0
while number % div == 0:
div_cnt += 1
number //= div
if div_cnt != 0:
factor[div] = div_cnt
div += 1
if number > 1:
factor[number] = 1
return factor
N = int(eval(input()))
v = list(factrization_prime(N).values())
ans = 0
for i in range(len(v)):
k = 1
while(True):
if v[i] >= k:
v[i] -= k
k += 1
ans += 1
else:
break
print(ans)
| p02660 |
x = int(eval(input()))
import math
from collections import defaultdict
def isprime(n):
if n <= 1:
return 0
m = int(math.sqrt(n)) + 1
for i in range(2, m):
if n % i == 0:
return 0
return 1
if isprime(x):
print((1))
else:
res = 0
value = defaultdict(int)
def bprime(n):
cnt = 2
while n != 1:
while n % cnt == 0:
n //= cnt
value[cnt] += 1
cnt += 1
def cal(n):
j = 1
cnt = 0
while n >= j:
n -= j
j += 1
cnt += 1
return cnt
bprime(x)
for key in list(value.keys()):
res += cal(value[key])
print(res) | x = int(eval(input()))
import math
from collections import defaultdict
res = 0
value = defaultdict(int)
def isprime(n):
if n <= 1:
return 0
m = int(math.sqrt(n)) + 1
for i in range(2, m):
if n % i == 0:
return 0
return 1
if isprime(x):
print((1))
else:
def bprime(n):
cnt = 2
m = int(math.sqrt(n)) + 1
while n != 1 and cnt < m:
while n % cnt == 0:
n //= cnt
value[cnt] += 1
cnt += 1
if cnt == m and n != 1:
value[n] += 1
def cal(n):
if n <= 2:
return 1
j = 1
cnt = 0
while n >= j:
n -= j
j += 1
cnt += 1
return cnt
bprime(x)
for key in list(value.keys()):
res += cal(value[key])
print(res) | p02660 |
import math
def sosu(n):
sosu=1
if n==1:
sosu=0
sq=int(math.sqrt(n))
for x in range(2,sq+2):
if n%x==0 and x<n:
sosu=0
break
return sosu #素数なら1、そうでなければ0
n=int(eval(input()))
so=[]
count=0
if n==1:
count=0
elif sosu(n)==1:
count=1
else:
for x in range(2,int(n/2)+2):
if x>n:
break
hantei=sosu(x)
shisu=1
if hantei==1:
while n%(x**shisu)==0:
count+=1
shisu+=1
n=n/(x**(shisu-1))
print(count) | 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(eval(input()))
if n==1:
ans=0
else:
a=prime_factorize(n)
if a==[]:
ans=1
else:
ans=0
xzen=a[0]
count=1
ans+=1
for x in range(1,len(a)):
if xzen==a[x]:
count+=1
if count==3 or count==6 or count==10 or count==15 or count==21 or count==28 or count==36:
ans+=1
else:
xzen=a[x]
count=1
ans+=1
print(ans) | p02660 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def prime_factorization(n):
res = []
for i in range(2, int(pow(n, 0.5)) + 1):
if n % i == 0:
ex = 0
while n % i == 0:
ex += 1
n //= i
res.append([i, ex])
if n != 1:
res.append([n, 1])
return res
def resolve():
n = int(eval(input()))
L = prime_factorization(n)
res = 0
for v, ex in L:
i = 1
while ex >= 0:
if ex - i < 0:
break
ex -= i
res += 1
i += 1
print(res)
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def prime_factorization(n):
res = []
for i in range(2, int(pow(n, 0.5)) + 1):
if n % i == 0:
ex = 0
while n % i == 0:
ex += 1
n //= i
res.append(ex)
if n != 1:
res.append(1)
return res
def resolve():
n = int(eval(input()))
div = prime_factorization(n)
res = 0
for ex in div:
i = 1
while ex > 0:
ex -= i
if ex < 0:
break
i += 1
res += 1
print(res)
if __name__ == '__main__':
resolve()
| p02660 |
n = int(eval(input()))
if n == 1:
print((0))
exit()
from collections import Counter
def factorize(n):
d = Counter()
m = 2
while m*m <= n:
while n%m == 0:
n //= m
d[m] += 1
m += 1
if n > 1:
d[n] += 1
return d
fac = factorize(n)
ans = 0
for v in list(fac.values()):
n = 1
while v >= n:
v -= n
ans += 1
n += 1
print(ans)
| n = int(eval(input()))
if n == 1:
print((0))
exit()
from collections import Counter
def factorize(n):
d = Counter()
if n < 2:
return d
while n%2 == 0:
n //= 2
d[2] += 1
m = 3
while m*m <= n:
while n%m == 0:
n //= m
d[m] += 1
m += 2
if n > 1:
d[n] += 1
return d
fac = factorize(n)
ans = 0
for v in list(fac.values()):
n = 1
while v >= n:
v -= n
ans += 1
n += 1
print(ans)
| p02660 |
from collections import defaultdict
from itertools import accumulate
def main():
n = int(eval(input()))
prime_counter = defaultdict(int)
acc = tuple(accumulate(list(range(1, 42)))) # 10^12 < 2^39
f = 2
while f * f <= n:
if n % f == 0:
n //= f
prime_counter[f] += 1
else:
f += 1
if n != 1:
prime_counter[n] += 1
ans = 0
for c in list(prime_counter.values()):
for i, x in enumerate(acc):
if c < x:
tmp = i
break
ans += tmp
print(ans)
if __name__ == '__main__':
main()
| from collections import defaultdict
from itertools import accumulate
def main():
n = int(eval(input()))
prime_counter = defaultdict(int)
acc = tuple(accumulate(list(range(1, 42)))) # 10^12 < 2^39
f = 2
while n % f == 0:
n //= f
prime_counter[f] += 1
f = 3
while f * f <= n:
if n % f == 0:
n //= f
prime_counter[f] += 1
else:
f += 2
if n != 1:
prime_counter[n] += 1
ans = 0
for c in list(prime_counter.values()):
for accum_index, x in enumerate(acc):
if c < x:
break
ans += accum_index
print(ans)
if __name__ == '__main__':
main()
| p02660 |
def main():
n = int(eval(input()))
ans = 0
fac = 2
e = 1
while True:
div = pow(fac, e)
if n % div == 0:
n //= div
ans += 1
e += 1
else:
while n % fac == 0:
n //= fac
fac += 1
if fac * fac > n:
break
e = 1
if n != 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| def main():
n = int(eval(input()))
ans = 0
fac = 2
e = 1
while True:
div = pow(fac, e)
if n % div == 0:
n //= div
ans += 1
e += 1
else:
while n % fac == 0:
n //= fac
if fac == 2:
fac += 1
else:
fac += 2
if fac * fac > n:
break
e = 1
if n != 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p02660 |
def main():
n = int(eval(input()))
ans = 0
e = 1
facs = (2 if x == 0 else x * 2 + 1 for x in range(10 ** 6))
for fac in facs:
while n % (div := pow(fac, e)) == 0:
n //= div
ans += 1
e += 1
while n % fac == 0:
n //= fac
if fac * fac > n:
break
e = 1
if n != 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| def main():
n = int(eval(input()))
ans = 0
e = 1
def facs():
yield 2
for x in range(10 ** 6):
yield x * 2 + 3
for fac in facs():
while n % (div := pow(fac, e)) == 0:
n //= div
ans += 1
e += 1
while n % fac == 0:
n //= fac
if fac * fac > n:
break
e = 1
if n != 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p02660 |
from itertools import accumulate
from collections import defaultdict
def main():
n = int(eval(input()))
prime_counter = defaultdict(int)
acc = tuple(accumulate(list(range(1, 42)))) # 10^12 < 2^39
def facs():
yield 2
for x in range(10 ** 6):
yield x * 2 + 3
for fac in facs():
while fac * fac <= n:
if n % fac == 0:
n //= fac
prime_counter[fac] += 1
else:
break
if n != 1:
prime_counter[n] += 1
ans = 0
for c in list(prime_counter.values()):
for i, x in enumerate(acc):
if c < x:
tmp = i
break
ans += tmp
print(ans)
if __name__ == '__main__':
main()
| from itertools import accumulate
from collections import defaultdict
def main():
n = int(eval(input()))
prime_counter = defaultdict(int)
acc = tuple(accumulate(list(range(1, 42)))) # 10^12 < 2^39
def facs():
yield 2
for x in range(10 ** 6):
yield x * 2 + 3
for fac in facs():
while n % fac == 0:
n //= fac
prime_counter[fac] += 1
if fac * fac > n:
break
if n != 1:
prime_counter[n] += 1
ans = 0
for c in list(prime_counter.values()):
for i, x in enumerate(acc):
if c < x:
tmp = i
break
ans += tmp
print(ans)
if __name__ == '__main__':
main()
| p02660 |
from itertools import accumulate
from collections import defaultdict
def main():
n = int(eval(input()))
prime_counter = defaultdict(int) # key ^ value
acc = tuple(accumulate(list(range(1, 42)))) # because 10^12 < 2^39
def facs():
yield 2
for x in range(10 ** 5 * 5):
yield x * 2 + 3
for fac in facs():
count = 0
while n % fac == 0:
n //= fac
count += 1
# ここで if braek を入れると遅い？
prime_counter[count] += 1
if n != 1:
prime_counter[1] += 1
ans = 0
for prime_count, count_count in list(prime_counter.items()):
for i, x in enumerate(acc):
if prime_count < x:
tmp = i
break
ans += tmp * count_count
print(ans)
if __name__ == '__main__':
main()
| from itertools import accumulate
from collections import defaultdict
def main():
n = int(eval(input()))
prime_counter = defaultdict(int) # key ^ value
acc = tuple(accumulate(list(range(1, 42)))) # because 10^12 < 2^39
def facs(n):
yield 2
max_x = int((n ** 0.5 - 3) / 2 + 1)
for x in range(max_x):
yield x * 2 + 3
for fac in facs(n):
while n % fac == 0:
n //= fac
prime_counter[fac] += 1
# ここで if fac * fac > n: braek を入れると，
# 計算量の少ないケースでは早く，多いケースでは遅くなる。
if n != 1:
prime_counter[n] += 1
ans = 0
for c in list(prime_counter.values()):
for i, x in enumerate(acc):
if c < x:
tmp = i
break
ans += tmp
print(ans)
if __name__ == '__main__':
main()
| p02660 |
from itertools import accumulate
from collections import defaultdict
def main():
n = int(eval(input()))
prime_counter = defaultdict(int) # key ^ value
acc = tuple(accumulate(list(range(1, 42)))) # because 10^12 < 2^39
def facs(n):
yield 2
max_x = int((n ** 0.5 - 3) / 2 + 1)
for x in range(max_x):
yield x * 2 + 3
for fac in facs(n):
while n % fac == 0:
n //= fac
prime_counter[fac] += 1
# ここで if fac * fac > n: braek を入れると，
# 計算量の少ないケースでは早く，多いケースでは遅くなる。
if n != 1:
prime_counter[n] += 1
ans = 0
for c in list(prime_counter.values()):
for i, x in enumerate(acc):
if c < x:
tmp = i
break
ans += tmp
print(ans)
if __name__ == '__main__':
main()
| from itertools import accumulate
from collections import defaultdict
def main():
n = int(eval(input()))
prime_counter = defaultdict(int) # key ^ value
acc = tuple(accumulate(list(range(1, 42)))) # because 10^12 < 2^39
def facs(n):
yield 2
max_x = int(n ** 0.5)
for x in range(3, max_x+1, 2):
yield x
for fac in facs(n):
while n % fac == 0:
n //= fac
prime_counter[fac] += 1
# ここで if fac * fac > n: braek を入れると，
# 計算量の少ないケースでは早く，多いケースでは遅くなる。
if n != 1:
prime_counter[n] += 1
ans = 0
for c in list(prime_counter.values()):
for i, x in enumerate(acc):
if c < x:
tmp = i
break
ans += tmp
print(ans)
if __name__ == '__main__':
main()
| p02660 |
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(eval(input()))
flag = 0
if N == 1:
flag = -1
M = len(factorization(N))
num = [1,3,6,10,15,21,28,36]
ans = 0
for i in range(M):
for j in range(len(num)):
if num[j] <= factorization(N)[i][1]:
ans += 1
if flag == -1:
print((0))
else:
print(ans) | 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(eval(input()))
flag = 0
if N == 1:
flag = -1
M = len(factorization(N))
num = [1,3,6,10,15,21,28,36]
ans = 0
for i in range(M):
for j in range(len(num)):
if num[j] <= factorization(N)[i][1]:
ans += 1
else:
break
if flag == -1:
print((0))
else:
print(ans) | p02660 |
import math
def isPrime(num):
if num < 2:
return False
elif num == 2:
return True
elif num % 2 == 0:
return False
for i in range(3, math.floor(math.sqrt(num))+1, 2):
if num % i == 0:
return False
return True
def find_all_prime(num):
prime_list = [2]
for i in range(3, num, 2):
if isPrime(i):
prime_list.append(i)
return prime_list
if __name__ == "__main__":
N = int(eval(input()))
if isPrime(N):
print((1))
else:
prime_list = find_all_prime(int(1.25*10**6))
count = 0
for i in prime_list:
j = 1
while N > 1:
if N // i**j == 0:
break
if N % i**j == 0:
N = N // i**j
count += 1
j +=1
print(count) | def factorization(n):
factorization_list = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp % i == 0:
count = 0
while temp % i == 0:
count += 1
temp //= i
factorization_list.append([i, count])
if temp != 1:
factorization_list.append([temp, 1])
if factorization_list==[]:
factorization_list.append([n, 1])
return factorization_list
if __name__ == "__main__":
N = int(eval(input()))
if N == 1:
print((0))
else:
factorization_list = factorization(N)
count = 0
for factor in factorization_list:
e = factor[1]
i = 1
while True:
e -= i
i += 1
count += 1
if e < i:
break
print(count) | p02660 |
from collections import Counter
n = int(eval(input()))
def primes(x):
is_prime = [True] * (x+1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(x**0.5)+1):
if not is_prime[i]:
continue
for j in range(i*2, x+1, i):
is_prime[j] = False
return [i for i in range(x+1) if is_prime[i]]
pl = primes(int(n**0.5)+1)
def factorization(x):
arr = []
tmp = x
while x > 1:
for i in pl:
if x % i == 0:
x /= i
arr.append(i)
break
if x == tmp and len(arr) == 0:
return [x]
return arr
ans = 0
for k, v in list(Counter(factorization(n)).items()):
i = 0
while v > i:
i += 1
v -= i
ans += 1
print(ans)
| n = int(eval(input()))
from collections import Counter
factors = []
i = 2
while n > 1:
if n < i * i:
factors.append(n)
break
while n % i == 0:
factors.append(i)
n //= i
i += 1
ans = 0
for cnt in list(Counter(factors).values()):
i = 1
while cnt >= i:
cnt -= i
i += 1
ans += 1
print(ans)
| p02660 |
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(eval(input()))
l = factorization(n)
ans = 0
for c in l:
if c[0]==1:
break
lim = c[1]
num = 1
while lim >= num:
lim -= num
num += 1
ans += num-1
print(ans) | 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])
return arr
n = int(eval(input()))
l = factorization(n)
ans = 0
for c in l:
lim = c[1]
num = 0
while lim > num:
num += 1
lim -= num
ans += num
print(ans) | p02660 |
n=int(eval(input()))
a=p=1
while p<6**8:
c=t=0;p+=1
while n%p<1:n//=p;x=c==t;t+=x;c+=1-t*x;a+=x
print((a-(n<2))) | n=int(eval(input()))
a=p=1
while p<1e6:
c=t=0;p+=1
while n%p<1:n//=p;x=c==t;t+=x;c+=1-t*x;a+=x
print((a-(n<2))) | p02660 |
#!/usr/bin/env python3
import sys
from functools import reduce
import math
def is_prime(n):
if n % 2 == 0 and n > 2:
return False
for i in range(3, int(math.sqrt(n)) + 1, 2):
if n % i == 0:
return False
return True
def sieve(n):
n=int(n)
# Create a boolean array "prime[0..n]" and initialize
# all entries it as true. A value in prime[i] will
# finally be false if i is Not a prime, else true.
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
# If prime[p] is not changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0]= False
prime[1]= False
return [i for i, p in enumerate(prime) if p]
def inthroot(x,n):
"calculate floor(x**(1/n))"
return math.floor(x**(1/n))
def is_a_power(n):
"return (a,b) if n=a**b otherwise throw ValueError"
for b in sieve( math.log2(n) +1 ):
if b == 0:
raise ValueError
a = inthroot(n,b)
if a**b == n:
return a,b
raise ValueError
def smooth_factorization(n):
"return (p,e) where p is prime and n = p**e if such value exists, otherwise throw ValueError"
e=1
p=n
while True:
try:
p,n = is_a_power(p)
e = e*n
except ValueError:
break
if is_prime(p):
return p,e
def factors(n):
return set(
reduce(
list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0),
)
)
def solve(N: int):
count = 0
picked_z = set([])
while True:
zs = list(factors(N))
zs.remove(1)
for _ in range(len(zs)):
z = min(zs)
i = zs.index(z)
is_prime_power = smooth_factorization(z)
if is_prime_power and z not in picked_z:
picked_z.add(z)
N = N / z
count += 1
del zs[i]
break
del zs[i]
if len(zs) == 0:
break
print(count)
return
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
solve(N)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
from functools import reduce
import math
from collections import defaultdict
from math import sqrt
def is_prime(n):
for i in range(2, int(sqrt(n))):
if n % i == 0:
return False
return True
def prime_factors(n):
primes = defaultdict(int)
i = 2
mx = sqrt(n)
while n != 1:
if n % i == 0:
n = n // i
primes[i] += 1
elif i >= mx:
if len(primes) == 0:
primes[i] += 1
elif is_prime(n):
primes[i] += 1
break
else:
i += 1
return primes
def solve_n(x):
return (-1 + sqrt(1 + 4 * 2* x)) / 2
def solve(N: int):
fs = prime_factors(N)
count = 0
for key, value in list(fs.items()):
val = solve_n(value)
count += math.floor(val)
print(count)
return
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
solve(N)
if __name__ == "__main__":
main()
| p02660 |
N=int(eval(input()))
p_list=[]
if N%2==0:
count=0
while N%2==0:
count+=1
N/=2
p_list.append([2,count])
i=3
while i<N**0.5+1:
if N%i==0:
count=0
while N%i==0:
count+=1
N/=i
p_list.append([i,count])
i+=2
if N!=1:
p_list.append([int(N),1])
result=0
for i in range(len(p_list)):
j=1
while p_list[i][1]>=j:
p_list[i][1]-=j
j+=1
result+=1
print(result) | N=int(eval(input()))
p=[]
r=0
if N%2==0:
c=0
while N%2==0:
c+=1
N/=2
p.append([c])
i=3
while i<N**0.5+1:
if N%i==0:
c=0
while N%i==0:
c+=1
N/=i
p.append([c])
i+=2
if N!=1:
p.append([1])
for i in range(len(p)):
j=1
while p[i][0]>=j:
p[i][0]-=j
j+=1
r+=1
print(r) | p02660 |
N=int(eval(input()))
p=[]
r=0
if N%2==0:
c=0
while N%2==0:
c+=1
N/=2
p.append(c)
for i in range(3,int(N**0.5)+1,2):
if N%i==0:
c=0
while N%i==0:
c+=1
N/=i
p.append(c)
if N!=1:
p.append(1)
for i in p:
r+=int(((8*i+1)**0.5-1)/2)
print(r) | N=int(eval(input()))
p=[]
r=0
if N%2==0:
c=0
while N%2==0:
N=N//2
c+=1
p.append(c)
for i in range(3,int(N**0.5)+1,2):
if N%i==0:
c=0
while N%i==0:
N=N//i
c+=1
p.append(c)
if N!=1:
p.append(1)
while p:
r+=int(((8*p.pop()+1)**0.5-1)/2)
print(r) | p02660 |
n = int(eval(input()))
c = 0
for p in range(2, int(n**0.5)+1): #nが合成数
e = 0
while n%p == 0:
n //= p
e += 1
i = 1
while e >= i:
e -= i
c += 1
i += 1
if n != 1: #nが素数
c += 1
print(c) | n = int(eval(input()))
c = 0
for p in range(2, int(n**0.5)+1): #nが合成数
e = 0
while n%p == 0:
n //= p
e += 1
i = 1
while e >= i:
e -= i
c += 1
i += 1
if n != 1: #nが素数 or nがn^0.5より大きい素数を因数に持つ合成数
c += 1
print(c) | p02660 |
from math import sqrt
def is_prime(n):
if n == 1:
return False
for i in range(2, int(sqrt(n))+1):
if n % i == 0:
return False
return True
def factorization(n):
arr = []
temp = n
for i in range(2, int(sqrt(n))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if len(arr) > 1:
break
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
base=int(eval(input()))
tmp=base
num=[]
if is_prime(base):
num.append(base)
else:
for i in range(2, base+1):
if i > tmp:
break
if tmp % i == 0 and len(factorization(i)) == 1:
num.append(i)
tmp/=i
print((len(num))) | from math import sqrt
def is_prime(n):
if n == 1:
return False
for i in range(2, int(sqrt(n))+1):
if n % i == 0:
return False
return True
def factorization(n):
arr = []
temp = n
for i in range(2, int(sqrt(n))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if len(arr) > 1:
break
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
base=int(eval(input()))
tmp=base
num=[]
if is_prime(base):
num.append(base)
else:
for i in range(2, base+1):
if i > tmp:
break
if tmp % i == 0 and len(factorization(i)) == 1:
num.append(i)
tmp/=i
if is_prime(tmp):
num.append(tmp)
break
print((len(list(set(num))))) | p02660 |
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
def readinput():
n=int(eval(input()))
return n
def possibleCnt(n):
cnt=0
resu=n
for i in range(1,n+1):
if resu >= i:
cnt+=1
resu-=i
#print(cnt,resu)
return cnt
def main(n):
ansList=factorization(n)
#print(ansList)
count=0
for l in ansList:
if(l[0]!=1):
count+=possibleCnt(l[1])
return count
if __name__=='__main__':
n=readinput()
ans=main(n)
print(ans)
| 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
import math
def myFactorization(n):
'''nを素因数分解する
戻り値: factList = [[prime1, exp1], [prime2, exp2],...]
n=(prime1)**exp1 * (prime2)**exp2 * ...
'''
factList=[]
temp=n
cnt=0
while(temp%2==0):
temp=temp//2
cnt+=1
if(cnt>0):
factList.append([2,cnt])
m=int(math.sqrt(n))+1
for i in range(3,m+1,2):
cnt=0
while(temp%i==0):
temp=temp//i
cnt+=1
if(cnt>0):
factList.append([i,cnt])
if(temp==1):
break
if(temp>1):
factList.append([temp,1])
return factList
def readinput():
n=int(eval(input()))
return n
def possibleCnt(n):
cnt=0
resu=n
for i in range(1,n+1):
if resu >= i:
cnt+=1
resu-=i
#print(cnt,resu)
return cnt
def main(n):
#ansList=factorization(n)
ansList=myFactorization(n)
#print(ansList)
count=0
for l in ansList:
if(l[0]!=1):
count+=possibleCnt(l[1])
return count
if __name__=='__main__':
n=readinput()
ans=main(n)
print(ans)
| p02660 |
from collections import Counter
N = int(eval(input()))
n = N
counter = Counter()
while n % 2 == 0:
counter[2] += 1
n //= 2
p = 3
while p ** 2 <= N:
if n % p == 0:
counter[p] += 1
n //= p
else:
p += 2
if n != 1:
counter[N] += 1
ans = 0
for key in list(counter.keys()):
e = 1
while counter[key] >= e:
ans += 1
counter[key] -= e
e += 1
print(ans)
| from collections import Counter
def prime_factorization(n):
counter = Counter()
max_pp = n
while n % 2 == 0:
counter[2] += 1
n //= 2
p = 3
while p ** 2 <= max_pp:
if n % p == 0:
counter[p] += 1
n //= p
else:
p += 2
if n != 1:
counter[n] += 1
return counter
N = int(eval(input()))
prime_counter = prime_factorization(N)
ans = 0
for key in list(prime_counter.keys()):
for e in range(1, N):
if prime_counter[key] >= e:
prime_counter[key] -= e
ans += 1
e += 1
else:
break
print(ans)
| p02660 |
import sys
from bisect import bisect
def solve():
input = sys.stdin.readline
N = int(eval(input()))
A = [int(i) + 1 for i in range(40)]
B = [0] * 41
for i, a in enumerate(A):
B[i+1] = B[i] + a
count = 0
k = N
for i in range(2, N+1):
if i ** 2 > N: break
if N % i == 0:
d = 0
while k % i == 0:
d += 1
k //= i
count += bisect(B, d) - 1
if k > 1: count += 1
print(count)
return 0
if __name__ == "__main__":
solve() | import sys
from bisect import bisect
def solve():
input = sys.stdin.readline
N = int(eval(input()))
sum = [0] * 41
for i in range(1, 41):
sum[i] = sum[i-1] + i
count = 0
k = N
for i in range(2, N + 1):
if i ** 2 > k: break
if k % i == 0:
d = 0
while k % i == 0:
d += 1
k //= i
count += bisect(sum, d) - 1
if k > 1: count += 1
print(count)
return 0
if __name__ == "__main__":
solve() | p02660 |
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(eval(input()))
fact = factorization(n)
cnt = 0
for f in fact:
if f[0] == 1:
continue
i = 1
while True:
f[1] -= i
i += 1
if f[1] < 0:
break
cnt += 1
print(cnt) | def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//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(eval(input()))
fact = factorization(n)
cnt = 0
for f in fact:
if f[0] == 1:
continue
i = 1
while True:
f[1] -= i
i += 1
if f[1] < 0:
break
cnt += 1
print(cnt) | p02660 |
N = int(eval(input()))
A = [0 for k in range(int(N**0.5)+1)]
#N=1の処理
if N == 1:
print((0))
exit()
ans = 0
prime = [2]
for k in range(3, len(A), 2):
if A[k] == 0:
prime.append(k)
for j in range(k, len(A), k):
A[j] = 1
for p in prime:
if N%p == 0:
break
else:
print((1))
exit()
used = []
use = []
#print(prime)
for p in prime:
if p > N:
break
if N%p == 0:
#print(p)
ans += 1
used.append(p)
use.append(p)
N = N // p
np = p * p
while N % np == 0:
#print(np)
ans += 1
used.append(np)
N = N // np
np = np * p
#print(use)
#print(N)
for u in used:
if N % u == 0:
N = N // u
for u in used:
if N % u == 0:
N = N // u
for u in used:
if N % u == 0:
N = N // u
if N > 1:
ans += 1
print(ans) | N = int(eval(input()))
A = [0 for k in range(int(N**0.5)+1)]
#N=1の処理
if N == 1:
print((0))
exit()
ans = 0
prime = [2]
for k in range(3, len(A), 2):
if A[k] == 0:
prime.append(k)
for j in range(k, len(A), k):
A[j] = 1
for p in prime:
if N%p == 0:
break
else:
print((1))
exit()
use = []
for p in prime:
if p > N:
break
if N%p == 0:
ans += 1
use.append(p)
N = N // p
np = p * p
while N % np == 0:
ans += 1
N = N // np
np = np * p
for u in use:
while N % u == 0:
N = N // u
if N > 1:
ans += 1
print(ans) | p02660 |
n = int(eval(input()))
def prime_factor(n):
factor = []
for i in range(2, int(n ** 0.5) + 1):
while (n % i == 0):
factor.append(i)
n //= i
if n != 1:
factor.append(n)
return factor
from collections import Counter
f = prime_factor(n)
c = Counter(f)
res = 0
for k, v in list(c.items()):
num = c[k] # 指数
i = 1
while num >= i:
num -= i
res += 1
i += 1
print(res) | from collections import Counter
n = int(eval(input()))
def prime_factor(n):
factor = []
for i in range(2, int(n ** 0.5) + 1):
while (n % i == 0):
factor.append(i)
n //= i
if n != 1:
factor.append(n)
return factor
factor = prime_factor(n)
c = Counter(factor)
cnt = 0
for k, v in list(c.items()):
num, idx = 1, 1
while num <= v:
cnt += 1
idx += 1
num += idx
print(cnt) | p02660 |
from collections import Counter
n = int(eval(input()))
def prime_factor(n):
factor = []
for i in range(2, int(n ** 0.5) + 1):
while (n % i == 0):
factor.append(i)
n //= i
if n != 1:
factor.append(n)
return factor
factor = prime_factor(n)
c = Counter(factor)
cnt = 0
for k, v in list(c.items()):
num, idx = 1, 1
while num <= v:
cnt += 1
idx += 1
num += idx
print(cnt) | n = int(eval(input()))
def prime_factor(n):
factor = []
for i in range(2, int(n ** 0.5) + 1):
while (n % i == 0):
factor.append(i)
n //= i
if n != 1:
factor.append(n)
return list(set(factor))
factor = prime_factor(n)
cnt = 0
for p in factor:
if n % p == 0:
e = 1
while n % pow(p, e) == 0:
cnt += 1
n //= pow(p, e)
e += 1
print(cnt) | p02660 |
from heapq import heappop, heappush
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def prime_factorization(n):
d = {}
i = 2
while i * i <= n:
if n % i == 0:
d[i] = 1
n //= i
while n % i == 0:
n //= i
d[i] += 1
i += 1
if n > 1:
d[n] = 1
return d
def main():
N = int(readline())
d = prime_factorization(N)
queue = []
for k, v in list(d.items()):
for i in range(1, v+1):
heappush(queue, (pow(k, i), k, i))
cnt = dict()
ans = 0
while queue:
z, p, e = heappop(queue)
if p in cnt:
if cnt[p] + e <= d[p]:
cnt[p] += e
ans += 1
else:
continue
else:
cnt[p] = e
ans += 1
print(ans)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def prime_factorization(n):
d = {}
i = 2
while i * i <= n:
if n % i == 0:
d[i] = 1
n //= i
while n % i == 0:
n //= i
d[i] += 1
i += 1
if n > 1:
d[n] = 1
return d
def main():
N = int(readline())
d = prime_factorization(N)
ans = 0
for k, v in list(d.items()):
e = 0
for i in range(1, v+1):
e += i
if e > v:
break
ans += 1
print(ans)
if __name__ == "__main__":
main()
| p02660 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,copy
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
#素因数分解
def prime_factorize(n):
if n == 1:
return [1]
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 = inp()
if n == 1:
print((0))
quit()
c = Counter(prime_factorize(n))
res = 0
for key in list(c):
va = c[key]
cnt = 0
for i in range(1,100000):
cnt += i
if va < cnt:
res += i-1
break
print(res) | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
#素因数分解
def prime_factorize(n):
if n == 1:
return [1]
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 = inp()
c = Counter(prime_factorize(n))
res = 0
# print(c)
for k,v in list(c.items()):
if k == 1: continue
cnt = 0
for now in range(1,150000):
cnt += now
if cnt > v:
res += now-1
break
print(res) | p02660 |
import math
def solve():
N = int(eval(input()))
divisors = calc_divisors(N)
divisors.sort()
now = N
i = 1
ans = 0
while i != len(divisors):
if isPrime(divisors[i]) and now % divisors[i] == 0:
now /= divisors[i]
ans += 1
else:
if len(set(prime_factorize(divisors[i]))) == 1 and now % divisors[i] == 0:
now /= divisors[i]
ans += 1
i += 1
print(ans)
def isPrime(n):
if n == 1: return False
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
def sieve(n):
is_prime = [True] * (n+1)
is_prime[0] = False
is_prime[1] = False
p = 0
for i in range(2,n+1):
if is_prime[i]:
p = i
for j in range(p+p, n+1, p):
is_prime[j] = False
if p * p > n:
break
primes = []
for i in range(2,n+1):
if is_prime[i]:
primes.append(i)
return primes
def prime_factorize(n):
prime_numbers = []
for p in range(2, int(math.sqrt(n)+1)):
if n % p != 0:
continue
while n % p == 0:
n /= p
prime_numbers.append(p)
if n != 1:
prime_numbers.append(n)
return prime_numbers
def calc_divisors(n):
divisors = []
for i in range(1,int(math.sqrt(n)+1)):
if n % i == 0:
divisors.append(i)
if (i*i != n):
divisors.append(n//i)
return divisors
if __name__ == '__main__':
solve() | import math
from collections import Counter
def solve():
N = int(eval(input()))
primeFac = prime_factorize(N)
counter = Counter(primeFac)
divisors = []
for key, val in list(counter.items()):
for i in range(1,val+1):
divisors.append(pow(key,i))
divisors.sort()
now = N
ans = 0
for d in divisors:
if now % d == 0:
ans += 1
now //= d
print(ans)
def prime_factorize(n):
prime_numbers = []
for p in range(2, int(math.sqrt(n)+1)):
if n % p != 0:
continue
while n % p == 0:
n /= p
prime_numbers.append(p)
if n != 1:
prime_numbers.append(n)
return prime_numbers
if __name__ == '__main__':
solve() | p02660 |
import itertools
import math
import fractions
import functools
import copy
from collections import deque
from functools import reduce
from decimal import Decimal
n = int(eval(input()))
prime = {}
num = n
i = 2
while True:
if i * i > n:
if(num > 1):
prime[num] = 1
break
while num%i == 0:
prime[i] = prime.get(i, 0) + 1
num = num//i
i += 1
count = 0
for val in list(prime.values()):
use = 1
while True:
if(val < use):
break
val -= use
use += 1
count+=1
print(count)
| import itertools
import math
import fractions
import functools
import copy
from collections import deque
from functools import reduce
from decimal import Decimal
n = int(eval(input()))
def how_many_prime(n):
prime = {}
num = n
i = 2
while True:
if i * i > n:
if(num > 1):
prime[num] = 1
break
while num % i == 0:
prime[i] = prime.get(i, 0) + 1
num = num//i
i += 1
return prime
prime = how_many_prime(n)
count = 0
for val in list(prime.values()):
use = 1
while True:
if(val < use):
break
val -= use
use += 1
count += 1
print(count)
| p02660 |
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(eval(input()))
count = 0
a = factorization(n)
if n == 1:
print((0))
exit()
for i in range(len(a)):
a[i][1] -= 1
count += 1
count_n = 2
while a[i][1] > 0:
a[i][1] -= count_n
if a[i][1] >= 0:
count += 1
count_n += 1
print(count)
| 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(eval(input()))
count = 0
a = factorization(n)
if n == 1:
print((0))
exit()
for i in range(len(a)):
a[i][1] -= 1
count += 1
b = 2
while a[i][1] > 0:
a[i][1] -= b
if a[i][1] >= 0:
count += 1
b += 1
print(count) | p02660 |
def factorization(n):
m=n
counter_map={}
i=2
tmp=1
while n!=1:
#因数に持つか判定
if n%i==0:
n=n//i
#素数判定
for j in range(2,int(i**(1/2))+1):
if i%j==0:
break
else:
tmp*=i
if i not in counter_map:
counter_map[i]=1
tmp=1
else:
if tmp not in counter_map:
counter_map[tmp]=1
tmp=1
else:
i+=1
tmp=1
if i>int(m**(1/2)) and n!=1:
counter_map[n]=1
break
#print(i,n,counter_map)
return counter_map
a=int(eval(input()))
b=factorization(a)
#print(b)
print((len(b)))
| def factorization(n):
m=n
counter_map={}
i=2
tmp=1
while n!=1:
#因数に持つか判定
if n%i==0:
n=n//i
#素数判定
for j in range(2,int(i**(1/2))+1):
if i%j==0:
break
else:
tmp*=i
if i not in counter_map:
counter_map[i]=1
tmp=1
else:
if tmp not in counter_map:
counter_map[tmp]=1
tmp=1
else:
i+=1
tmp=1
if i>int(m**(1/2)) and n!=1:
counter_map[n]=1
break
return counter_map
a=int(eval(input()))
b=factorization(a)
sum=0
for i in list(b.keys()):
counter=0
for j in range(1,41):
if b[i]>=1+(j+2)*(j-1)//2:
counter=j
else:
break
sum+=counter
print(sum)
| p02660 |
def era(num):
input_list = [False if i % 2 == 0 or i % 3 == 0 or i % 5 == 0 else True for i in range(num)]
input_list[0] = input_list[1] = False
input_list[2] = input_list[3] = input_list[5] = True
sqrt = num**0.5
for serial in range(3, num, 2):
if serial >= sqrt:
return input_list
for s in range(serial ** 2, num, serial):
input_list[s] = False
N=int(eval(input()))
if N<25:
Prime=[2,3,5]
else:
input_list=era(int(N**0.5)+1)
Prime=[i for i, b in enumerate(input_list) if b == True]
Fac={}
for p in Prime:
while N%p==0:
N//=p
if p in Fac:
Fac[p]+=1
else:
Fac[p]=1
if N==1:
break
if N!=1:
Fac[N]=1
ans=0
for k in Fac:
nec=1
while True:
if Fac[k]>=nec:
ans+=1
Fac[k]-=nec
nec+=1
else:
break
print(ans) | N=int(eval(input()))
F={}
for i in range(2,int(N**0.5)+1):
if N%i==0:
F[i]=1
N//=i
while N%i==0:
N//=i
F[i]+=1
if N>1:
F[N]=1
ans=0
for f in F:
j=1
while True:
F[f]-=j
j+=1
if F[f]>=0:
ans+=1
else:
break
print(ans) | p02660 |
K = int(eval(input()))
N = 10**6
dp = [1] * (N+1)
dp[0] = dp[1] = 0
def pw(j,i):
while(j%i==0):
j //= i
if j == 1:
return True
else:
return False
for i in range(2,N+1):
if dp[i]:
for j in range(i*i, N+1, i):
#if not pw(j,i):
dp[j] = 0
ans = 0
for n in range(N):
i = 0
while(1):
i+=1
v = pow(n,i)
if (dp[n] == 1 and K%v==0):
K //= v
ans += 1
else:
break
for n in range(N):
while(dp[n] == 1 and K%n==0):
K //= n
#print (K)
if K!=1:
ans += 1
print (ans)
| N = int(eval(input()))
def factorize(N):
n = N
r = []
for i in range(2,int(N**0.5)+1): # intに変換すること
cnt = 0
while(n%i==0):
cnt += 1
n //= i # 整数除算(//)を使うこと
if cnt!=0:
r.append((i,cnt))
if n!=1:
r.append((n,1))
return r
ans = 0
for _, cnt in factorize(N):
i = 1
while(i <= cnt):
cnt-=i
i+=1
ans+=1
print (ans)
| p02660 |
def is_prime(num:int):
if num == 1:
return False
elif num == 2:
return True
elif num % 2 == 0:
return False
r_num = int(num ** 0.5)
for i in range(3, r_num + 1, 2):
if num % i == 0:
return False
return True
def main():
n = int(eval(input()))
if n == 1:
print((0))
return
cnt = 0
r_n = int(n ** 0.5)
for i in range(2, n):
if n < i:
break
elif cnt == 0 and r_n+1 < i:
break
if n % i == 0 and is_prime(i):
n = int(n/i)
cnt += 1
x = 2
while True:
q = i ** x
if q > n:
break
if n % q == 0:
n = int(n/q)
x += 1
cnt += 1
else:
break
if cnt == 0:
cnt = 1
print(cnt)
main()
| def is_prime(num:int):
if num == 1:
return False
elif num == 2:
return True
elif num % 2 == 0:
return False
r_num = int(num ** 0.5)
for i in range(3, r_num + 1, 2):
if num % i == 0:
return False
return True
def main():
n = int(eval(input()))
if n == 1:
print((0))
return
cnt = 0
r_n = int(n ** 0.5)
divided = []
for i in range(2, n):
if n < i:
break
elif cnt == 0 and r_n+1 < i:
break
if n % i == 0 and is_prime(i):
n = int(n/i)
divided.append(i)
cnt += 1
x = 2
while True:
q = i ** x
if q > n:
break
if n % q == 0:
n = int(n/q)
x += 1
cnt += 1
else:
break
if is_prime(n) and n not in divided:
n = 1
cnt += 1
break
if cnt == 0:
cnt = 1
print(cnt)
main()
| p02660 |
#23ぐらいまでで良さそう。
z = [2, 3, 4, 5, 7, 8, 9, 11, 13, 16, 17, 19, 23]
def primes(n):
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, n + 1, i):
is_prime[j] = False
return [i for i in range(n + 1) if is_prime[i]]
sosuu = primes(10001000)
count = [0] * len(sosuu)
convert = [0] * 56
N = int(eval(input()))
ans = 0
flag = True
while (flag):
flag = False
for i in range(len(sosuu)):
if N % sosuu[i] == 0:
N = N // sosuu[i]
count[i] += 1
flag = True
tmp = 0
for i in range(1, 11):
tmp += i
convert[tmp] = i
for i in range(1, len(convert)):
if convert[i] == 0:
convert[i] = convert[i - 1]
for i in count:
ans += convert[i]
if N > sosuu[-1] and ans == 0:
ans = 1
print(ans)
| N = int(eval(input()))
hash = {}
end = int(N ** (1/2))
for i in range(2, end + 1):
while N % i == 0:
if i in hash:
hash[i] += 1
else:
hash[i] = 1
N = N // i
if N != 1:
if N in hash:
hash[N] += 1
else:
hash[N] = 1
if len(list(hash.keys())) == 0 and N != 1:
print((1))
exit()
count = 0
trans = [1, 3, 6, 10, 15, 21, 28, 36, 45, 55]
res = 0
for i in list(hash.values()):
for j in range(len(trans)):
if i > trans[j]:
continue
elif i == trans[j]:
res += (j + 1)
break
else:
res += j
break
print(res) | p02660 |
from collections import Counter
def get_prime_factors(x):
out = []
if x < 1:
return out
while not x%2:
out.append(2)
x //= 2
i = 3
while i*i <= x:
if not x%i:
out.append(i)
x //= i
else:
i += 2
if x != 1:
out.append(x)
return out
def main():
n = int(eval(input()))
primes = Counter(get_prime_factors(n))
ans = 0
for k, v in list(primes.items()):
num = 1
while v >= num:
v -= num
num += 1
ans += 1
print(ans)
if __name__ == "__main__":
main() | from collections import Counter
def get_prime_factors(x):
out = []
if x < 1:
return out
while not x%2:
out.append(2)
x //= 2
i = 3
while i*i <= x:
if not x%i:
out.append(i)
x //= i
else:
i += 2
if x != 1:
out.append(x)
return out
def main():
n = int(eval(input()))
primes = Counter(get_prime_factors(n))
ans = 0
for prime, num in list(primes.items()):
i = 1
while num >= i:
ans += 1
num -= i
i += 1
print(ans)
if __name__ == "__main__":
main() | p02660 |
N = int(eval(input()))
n, p, score = N, 2, 0
while p ** 2 <= N:
e = 1
while n % (p ** e) == 0:
n //= (p ** e)
score += 1
e += 1
else:
while n % p == 0:
n //= p
p += 1
else:
if n != 1:
score += 1
print(score) | N = int(eval(input()))
n, p, score = N, 2, 0
while p ** 2 <= N:
e = 1
while n % (p ** e) == 0:
n //= (p ** e)
score += 1
e += 1
else:
while n % p == 0:
n //= p
p = p + 1 if p == 2 else p + 2
else:
if n != 1:
score += 1
print(score) | p02660 |
def prime(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(eval(input()))
a = prime(N)
a.sort()
import copy
b = copy.copy(a)
b = list(set(b))
b.sort()
m = 0
def cnt(c_, used, ans,now):
m = ans
for i in range(len(c_)):
for j in range(1,a.count(b[i])+1-c_[i]):
if now*b[i]**j > N:
break
if used.count(b[i]**j) != 0:
continue
c = copy.copy(c_)
c[i] += j
m = max(m, cnt(c, used+[b[i]**j], ans+1, now*b[i]**j))
return m
m = cnt([0]*len(b), [], 0, 1)
print(m) | def prime(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(eval(input()))
a = prime(N)
a.sort()
import copy
b = copy.copy(a)
b = list(set(b))
b.sort()
ret = 0
for i in b:
cnt = 0
idx=0
while True:
idx += 1
cnt = cnt + idx
if a.count(i) >= cnt:
ret += 1
else:
break
print(ret) | p02660 |
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
if(a%b==0):return(b)
return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
N=int(eval(input()))
#N=10**18
if N==1:
print((0))
exit()
i=2
#N=10**12
def sosuu(x):
sosuulst=[]
i=2
while i<int(x**.5+1):
for s in sosuulst:
if i%s==0:
break
else:
sosuulst.append(i)
i+=1
for s in sosuulst:
if x%s==0:
while x%s==0:
x//=s
if x==1:
return(1)
else:
return(0)
return(1)
c=0
lst=[]
lst2=[]
for i in range(2,int(N**.5+1)):
if N%i==0:
lst.append(i)
lst2.append(N//i)
lst2.reverse()
lst+=lst2
lst.append(N)
#print(lst)
for i in lst:
if N%i==0:
if sosuu(i):
# print(N,i)
N//=i
c+=1
print(c)
| from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
if(a%b==0):return(b)
return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
N=int(eval(input()))
#N=10**18
lst=defaultdict(int)
lst2=[]
lst3=[]
for i in range(2,int(N**.5)+100):
if N%i==0:
lst2.append(i)
lst3.append(N//i)
lst3.reverse()
lst2+=lst3
for i in lst2+[N]:
while N>1 and N%i==0:
N//=i
lst[i]+=1
c=0
#print(lst)
for s in lst:
l=lst[s]
i=1
while l>=i:
l-=i
c+=1
i+=1
print(c)
| p02660 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.