code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
n = int(input())
ans = []
while n > 0:
n -= 1
k = n % 26
n = n // 26
ans.append(chr(ord('a') + k))
for j in reversed(range(len(ans))):
print(ans[j], end = '') | N = int(input())
s = 1
t = 0
while N > 26**s + t:
t += 26**s
s += 1
N -= t
ans = []
for i in range(s):
c = 0
while N > 26**(s-i-1):
N -= 26**(s-i-1)
c += 1
ans.append(chr(97+c))
print("".join(ans)) | 1 | 11,911,067,326,080 | null | 121 | 121 |
N,M=map(int,input().split())
S,r,s=input(),[],N
for _ in range(2*N):
if S[s]=='1':
s += 1
else:
r.append(str(N-s))
N,s=s,max(0,s-M)
if N == 0:
break
print(*[-1] if s else r[1:][::-1]) | # C - Marks
def main():
N, K, *A = map(int, open(0).read().split())
res = ["Yes" if tail > top else "No" for top, tail in zip(A, A[K:])]
print("\n".join(res))
if __name__ == "__main__":
main()
| 0 | null | 73,248,322,963,968 | 274 | 102 |
z = input()
if z=='hi' or z=='hihi' or z=='hihihi' or z=='hihihihi' or z=='hihihihihi':
print("Yes")
else:
print("No")
| s=input()
for i in range(1,6):
if s=='hi'*i:
print('Yes')
quit()
print('No') | 1 | 53,044,711,091,840 | null | 199 | 199 |
S = input()
if S == 'MON':
print("6")
elif S == 'TUE':
print("5")
elif S == 'WED':
print("4")
elif S == 'THU':
print("3")
elif S == 'FRI':
print("2")
elif S == 'SAT':
print("1")
elif S == 'SUN':
print("7")
| s = str(input())
apple = ["SUN","MON","TUE","WED","THU","FRI","SAT","SUN"]
print(7-apple.index(s)) | 1 | 133,082,113,283,460 | null | 270 | 270 |
import sys
line = sys.stdin.readline()
inp = int(line)
h,mod = inp//3600, inp%3600
m,mod = mod//60, mod%60
s = mod
print ("%d:%d:%d" % (h,m,s)) | from collections import deque
n,m=map(int,input().split())
road=[[] for i in range(n)]
flag=[0]*n
for i in range(m):
a,b=map(int,input().split())
road[a-1].append(b-1)
road[b-1].append(a-1)
count=0
for i in range(n):
if flag[i]!=0:
continue
count+=1
q=deque([i])
while q:
p=q.popleft()
flag[p]=1
for z in road[p]:
if flag[z]==0:
q.append(z)
print(count-1) | 0 | null | 1,301,942,745,842 | 37 | 70 |
n = int(input())
m = range(1,n + 1)
a = range(1,n + 1,2)
b = len(a) / len(m)
print(b) | N,K = map(int,input().split())
H = list(map(int,input().split()))
H.sort(reverse=True)
cnt = 0
for h in H:
if h >= K:
cnt += 1
else:
break
print(cnt)
| 0 | null | 177,711,509,191,798 | 297 | 298 |
N,M = map(int,input().split())
a = [-1]*N
ans = 0
for i in range(M):
s,c = map(int,input().split())
if a[s-1] == -1:
a[s-1] = c
elif a[s-1] != c:
ans = -1
break
if a[0] == 0 and N>1:
ans = -1
if ans != -1:
if a[0] == -1 and N>1:
a[0] = 1
if a[0] == -1 and N == 1:
a[0] = 0
for i in range(N):
if a[i] == -1:
a[i] = 0
a[i] = str(a[i])
ans = "".join(a)
print(ans)
| import sys
def dfs(u):
global time
color[u] = "GRAY"
time += 1
d[u] = time
for v in range(n):
if M[u][v] and color[v] == "WHITE":
dfs(v)
color[u] = "BLACK"
time += 1
f[u] = time
if __name__ == "__main__":
n = int(sys.stdin.readline())
color = ["WHITE"] * n
time = 0
d = [-1] * n
f = [-1] * n
M = [[0] * n for i in range(n)]
for inp in sys.stdin.readlines():
inp = list(map(int, inp.split()))
for i in inp[2:]:
M[inp[0]-1][i-1] = 1
for i in range(n):
if d[i] == -1:
dfs(i)
for i in range(n):
print(i+1, d[i], f[i]) | 0 | null | 30,212,191,176,160 | 208 | 8 |
n = int(input())
l = list(map(int,input().split()))
l.reverse()
print(' '.join(map(str,l)))
| import math
while True:
n = int(input())
if n == 0:
break
dset = list(map(int, input().split()))
mean = sum(dset)/len(dset)
sigma = math.sqrt(sum([(x-mean)**2 for x in dset])/len(dset))
print('%.06f' % sigma) | 0 | null | 576,209,017,860 | 53 | 31 |
def main():
import sys
input = sys.stdin.readline
inf = 1 << 60
N, M, L = map(int, input().split())
dist = [[inf] * N for _ in range(N)]
for _ in range(M):
A, B, C = map(int, input().split())
A -= 1
B -= 1
dist[A][B] = dist[B][A] = C
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(
dist[i][j],
dist[i][k] + dist[k][j]
)
g = [[inf] * N for _ in range(N)] # 到達に必要な補充回数
for A in range(N):
for B in range(N):
if dist[A][B] <= L:
g[A][B] = 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]
)
Q = int(input())
for _ in range(Q):
s, t = (int(x) - 1 for x in input().split())
d = g[s][t]
if d == inf:
print(-1)
else:
print(d - 1)
if __name__ == '__main__':
main()
| def warshal(data):
for k in range(n):
for i in range(n):
for j in range(n):
data[i][j]=min(data[i][j],data[i][k]+data[k][j])
return data
n,m,l=map(int,input().split())
inf=float("inf")
data=[[inf]*n for i in range(n)]
for i in range(m):
a,b,c=map(int,input().split())
data[a-1][b-1]=c
data[b-1][a-1]=c
for i in range(n):
data[i][i]=0
data=warshal(data)
for i in range(n):
for j in range(n):
if data[i][j]<=l:
data[i][j]=1
else:
data[i][j]=inf
for i in range(n):
data[i][i]=0
data=warshal(data)
q=int(input())
st=[]
for i in range(q):
s,t=map(int,input().split())
st.append([s-1,t-1])
for s,t in st:
if data[s][t]==inf:
print(-1)
else:
print(data[s][t]-1) | 1 | 172,953,937,427,040 | null | 295 | 295 |
# Template 1.0
import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx): return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
toret = {}
for tup in temp:
toret[tup[0]] = tup[1]
return toret
def sortDictWithKey(passedDic):
return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
n = INT()
a = LIST()
flag = 0
for el in a:
if(el%2==0):
if(el%3==0 or el%5==0):
continue
else:
flag = 1
break
if(flag==0):
print("APPROVED")
else:
print("DENIED") | N = int(input())
A = list(map(int, input().split()))
for a in A:
if a%2 == 0 and a%3 != 0 and a%5 != 0:
print('DENIED')
exit()
print('APPROVED') | 1 | 69,050,286,364,608 | null | 217 | 217 |
s = map(int, raw_input().split())
s.sort()
print ' '.join(map(str, s)) | import sys
prm = sys.stdin.readline()
prm = prm.split()
prm.sort()
a = int(prm[0])
b = int(prm[1])
c = int(prm[2])
print a, b, c | 1 | 428,449,044,048 | null | 40 | 40 |
n = int(input())
a = list(map(int, input().split()))
a_ = [i for i in a if i % 2 == 0]
for i in a_:
bool_3 = i % 3 != 0
bool_5 = i % 5 != 0
if bool_3 and bool_5:
print('DENIED')
break
else:
print('APPROVED')
| import numpy as np
stdin = open(0)
A = np.fromstring(stdin.read(), np.int64, sep=' ')[1:]
A = A[A % 2 == 0]
if np.all((A % 3 == 0) | (A % 5 == 0)):
print('APPROVED')
else:
print('DENIED') | 1 | 69,187,145,191,964 | null | 217 | 217 |
N,K=map(int,input().split())
A=[]
people=list(range(1,N+1,1))
for idx in range(K):
d=int(input())
X=list((map(int,input().split())))
for i in range(len(X)):
A.append(X[i])
ans =[i for i in people if not i in A]
print(len(ans)) | n, k = map(int, input().split())
treat_array = [0]*n
for i in range(k):
d = int(input())
for j in map(int, input().split()):
treat_array[j-1] += 1
ans = 0
for i in range(n):
if treat_array[i] == 0:
ans += 1
print(ans) | 1 | 24,643,320,221,508 | null | 154 | 154 |
import math
k = int(input())
sum = 0
for a in range(1,k+1):
for b in range(1,k+1):
x = math.gcd(a, b)
for c in range(1,k+1):
sum += math.gcd(x, c)
print(sum) | import math
K = int(input())
Sum = 0
for A in range(1,K+1):
for B in range(1,K+1):
for C in range(1,K+1):
Sum = Sum+math.gcd(math.gcd(A,B),C)
print(Sum) | 1 | 35,649,176,552,512 | null | 174 | 174 |
N = int(input())
for i in range(1,int(N**(1/2)) + 1)[::-1]:
if N%i == 0:
print(i + N//i - 2)
exit() | icase=0
if icase==0:
a,b=map(int,input().split())
print(max(a-2*b,0))
| 0 | null | 164,688,633,122,910 | 288 | 291 |
def ifTriangle(a, b, c):
if (a**2) + (b**2) == c**2: print("YES")
else: print("NO")
n=int(input())
for i in range(n):
lines=list(map(int, input().split()))
lines.sort()
ifTriangle(lines[0], lines[1], lines[2]) | import itertools
import math
N = int(input())
x_list = [0] * N
y_list = [0] * N
for i in range(N):
x_list[i], y_list[i] = map(int, input().split())
l_sum = 0
l = 0
for comb in itertools.combinations(range(N), 2):
l = (
(x_list[comb[0]] - x_list[comb[1]]) ** 2
+ (y_list[comb[0]] - y_list[comb[1]]) ** 2
) ** 0.5
l_sum += l
ans = 2 * l_sum / N
print(ans) | 0 | null | 74,570,726,794,142 | 4 | 280 |
'''
ITP-1_9-D
???????????????
????????? strstr ?????????????????????????????????????????????????????????????????°???????????????????????????????????????????????\?????????????????????????????§??????
print a b: strstr ??? a ??????????????? b ??????????????§??????????????????
reverse a b: strstr ??? a ??????????????? b ??????????????§?????????????????????
replace a b p: strstr ??? a ??????????????? b ??????????????§??? p ?????????????????????
????????§??????????????? strstr ????????????????????? 0 ???????????¨????????????
???Input
1 ?????????????????? strstr ????????????????????????strstr ?????±?°????????????????????????????2 ????????????????????° qq ????????????????????????
?¶???? qq ??????????????????????¨??????¢?????§?????????????????????
???Output
??? print ???????????¨???????????????????????????????????????????????????
'''
# inputData
string = input()
exeCnt = int(input())
for cnt0 in range(exeCnt):
exeData = input().split()
exe00 = exeData[0]
exe01 = int(exeData[1])
exe02 = int(exeData[2])
# exe03 = exeData[3]
if exe00 == 'print':
print(string[exe01:exe02 + 1])
elif exe00 == 'reverse':
string = string[0:exe01] + string[exe01:exe02 + 1][::-1] + string[exe02 + 1:]
elif exe00 == 'replace':
exe03 = exeData[3]
string = string[0:exe01] + exe03 + string[exe02 + 1:] | w = input()
q = int(input())
for _ in range(q):
S = input().split()
s = S[0]
a, b = map(int, S[1: 3])
if s == "print":
print(w[a: b + 1])
elif s == "reverse":
w = w[:a] + w[a: b + 1][::-1] + w[b + 1:]
else:
w = w[:a] + S[3] + w[b + 1:]
| 1 | 2,086,024,894,690 | null | 68 | 68 |
n = input()
for i in range(n):
a, b, c = map(int, raw_input().strip().split(' '))
if a*a+b*b == c*c or a*a+c*c == b*b or c*c+b*b == a*a:
print "YES"
else:
print "NO" | N=int(input())
from collections import Counter
if max(Counter([int(x) for x in input().split()]).values())==1:
print("YES")
else:
print("NO") | 0 | null | 36,922,826,677,958 | 4 | 222 |
import sys
def ISI(): return map(int, sys.stdin.readline().rstrip().split())
n, m=ISI()
if(n==m):print("Yes")
else:print("No") | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M = map(int, readline().split())
if N == M:
print('Yes')
else:
print('No')
return
if __name__ == '__main__':
main()
| 1 | 83,253,860,324,698 | null | 231 | 231 |
#coding:utf-8
n = input()
l = map(int, raw_input(). split())
print("{0} {1} {2}". format(min(l), max(l), sum(l))) | a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
d = abs(a-b)
if v <= w:
print('NO')
else:
if (v-w)*t < d:
print('NO')
else:
print('YES')
| 0 | null | 7,912,625,838,652 | 48 | 131 |
import sys
input = sys.stdin.readline
# 再帰上限を引き上げる
sys.setrecursionlimit(10**6)
n, u, v = map(int, input().split())
u, v = u-1, v-1
l = [[] for i in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
a, b = a-1, b-1
l[a].append(b)
l[b].append(a)
def dfs(G, cr, seen, dist):
seen[cr] = 1
for i in G[cr]:
if seen[i] == 0:
dist[i] = dist[cr] + 1
dfs(G, i, seen, dist)
return dist
seen_u = [0]*n
seen_v = [0]*n
dist_u = [0]*n
dist_v = [0]*n
T1 = dfs(l, u, seen_u, dist_u)
T2 = dfs(l, v, seen_v, dist_v)
for i in range(n):
if dist_u[i] >= dist_v[i]:
dist_v[i] = -1
print(max(dist_v)-1) | D = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for i in range(D)]
t = [int(input()) for i in range(D)]
last = [0]*26
S = 0
for d in range(1, D+1):
# last更新
for j in range(26):
if j == t[d-1]-1:
last[j] = d
# plus部分
S += s[d-1][t[d-1]-1]
# minus部分
m = 0
for j in range(26):
m += c[j] * (d-last[j])
S -= m
print(S) | 0 | null | 63,919,443,968,432 | 259 | 114 |
a = list(map(int,input().split()))
x = a[1]*2
if x>=a[0]:
print(0)
else:
print(a[0]-x) | l,r,d = map(int,input().split())
#print(l,r,d)
ans = 0
for i in range(101):
if d * i > r:
break
elif d * i >= l:
ans += 1
continue
else:
continue
print(ans) | 0 | null | 87,263,756,699,658 | 291 | 104 |
import os
import sys
import numpy as np
def solve(inp):
def bitree_sum(bit, t, i):
s = 0
while i > 0:
s += bit[t, i]
i ^= i & -i
return s
def bitree_add(bit, n, t, i, x):
while i <= n:
bit[t, i] += x
i += i & -i
def bitree_lower_bound(bit, n, d, t, x):
sum_ = 0
pos = 0
for i in range(d, -1, -1):
k = pos + (1 << i)
if k <= n and sum_ + bit[t, k] < x:
sum_ += bit[t, k]
pos += 1 << i
return pos + 1
def initial_score(d, ccc, sss):
bit_n = d + 3
bit = np.zeros((26, bit_n), dtype=np.int64)
INF = 10 ** 18
for t in range(26):
bitree_add(bit, bit_n, t, bit_n - 1, INF)
ttt = np.zeros(d, dtype=np.int64)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
best_t = 0
best_diff = -INF
costs = ccc * (i - last)
costs_sum = costs.sum()
for t in range(26):
tmp_diff = sss[i, t] - costs_sum + costs[t]
if best_diff < tmp_diff:
best_t = t
best_diff = tmp_diff
ttt[i] = best_t
last[best_t] = i
score += best_diff
bitree_add(bit, bit_n, best_t, i + 2, 1)
return bit, score, ttt
def calculate_score(d, ccc, sss, ttt):
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
last[t] = i
score += sss[i, t] - (ccc * (i - last)).sum()
return score
def pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
while ttt[cd] == ct:
ct = np.random.randint(0, 26)
diff = 0
t = ttt[cd]
k = bitree_sum(bit, t, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, t, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, t, k + 1) - 2
b = ccc[t]
diff -= b * (cd - c) * (e - cd)
diff -= sss[cd, t]
k = bitree_sum(bit, ct, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct, k + 1) - 2
b = ccc[ct]
diff += b * (cd - c) * (e - cd)
diff += sss[cd, ct]
if diff > permissible:
bitree_add(bit, bit_n, t, cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
else:
diff = 0
return diff
def swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
dd = np.random.randint(1, 14)
cd1 = np.random.randint(0, d - dd)
cd2 = cd1 + dd
ct1 = ttt[cd1]
ct2 = ttt[cd2]
if ct1 == ct2:
return 0
diff = 0
k = bitree_sum(bit, ct1, cd1 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct1, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct1, k + 1) - 2
diff += ccc[ct1] * (e + c - cd1 - cd2)
k = bitree_sum(bit, ct2, cd2 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct2, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct2, k + 1) - 2
diff -= ccc[ct2] * (e + c - cd1 - cd2)
diff -= sss[cd1, ct1] + sss[cd2, ct2]
diff += sss[cd1, ct2] + sss[cd2, ct1]
if diff > permissible:
bitree_add(bit, bit_n, ct1, cd1 + 2, -1)
bitree_add(bit, bit_n, ct1, cd2 + 2, 1)
bitree_add(bit, bit_n, ct2, cd1 + 2, 1)
bitree_add(bit, bit_n, ct2, cd2 + 2, -1)
ttt[cd1] = ct2
ttt[cd2] = ct1
else:
diff = 0
return diff
d = inp[0]
ccc = inp[1:27]
sss = np.zeros((d, 26), dtype=np.int64)
for r in range(d):
sss[r] = inp[27 + r * 26:27 + (r + 1) * 26]
bit, score, ttt = initial_score(d, ccc, sss)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
loop = 5 * 10 ** 6
permissible_min = -2000.0
method_border = 0.8
best_score = score
best_ttt = ttt.copy()
for lp in range(loop):
permissible = (1 - lp / loop) * permissible_min
if np.random.random() < method_border:
diff = pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
else:
diff = swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
score += diff
# print(lp, score, calculate_score(d, ccc, sss, ttt))
if score > best_score:
best_score = score
best_ttt = ttt.copy()
return best_ttt + 1
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', '(i8[:],)')(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit('(i8[:],)', cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print('\n'.join(map(str, ans)))
| a,b=map(int,raw_input().split())
print(a*b) | 0 | null | 12,729,135,639,978 | 113 | 133 |
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
alphabet = list(alphabet)
n = int(input())
s = input()
l = len(s)
for i in range(l):
k = alphabet.index(s[i])
print(alphabet[(k+n)%26], end = "")
print()
| n = int(input())
s = list(input())
for i, char in enumerate(s):
x = ord(char) + n
if x > 90:
x = x - 90 + 64
s[i] = chr(x)
print("".join(s)) | 1 | 134,654,757,075,156 | null | 271 | 271 |
from math import sqrt;
count = int(input());
data = [];
for n in range(count):
data.append(int(input()));
def prime_number(data):
max_divisor = get_max_divisor(data);
divisor_primes = get_prime(max_divisor);
count = 0;
for n in data:
ok = 1;
for p in divisor_primes:
if n < p:
ok = 0;
break;
elif n == p:
break;
elif n % p == 0:
ok = 0;
break;
count += ok;
return count;
def get_max_divisor(data):
maxN = data[0];
for n in data[1:]:
if n > maxN:
maxN = n;
return int(sqrt(maxN)) + 1;
def get_prime(max_divisor):
primes = [];
for n in range(2, max_divisor + 1):
is_prime = True;
for p in primes:
if n % p == 0:
is_prime = False;
if is_prime:
primes.append(n);
return primes;
print(prime_number(data));
| import sys
def solve():
n = int(sys.stdin.readline())
ans = 0
for i in range(n):
num = int(sys.stdin.readline())
ans += is_prime(num)
print(ans)
def is_prime(n):
if n < 2:
return False
for p in range(2, n + 1):
if p*p > n:
break
if n % p == 0:
return False
return True
if __name__ == '__main__':
solve() | 1 | 9,834,739,720 | null | 12 | 12 |
n,m = map(int, input().split())
print("Yes") if n-m==0 else print("No") | def main():
# import sys
# readline = sys.stdin.readline
# readlines = sys.stdin.readlines
N = int(input())
A = [(a, i) for i, a in enumerate(map(int, input().split()))]
A.sort(reverse=True)
dp = [[-float('inf')] * (N + 1) for _ in range(N + 1)]
dp[0][0] = 0
for k in range(N):
for i in range(k + 1):
j = k - i
here = dp[i][j]
a, idx = A[k]
dp[i + 1][j] = max(dp[i + 1][j], here + a * ((N - 1 - i) - idx))
dp[i][j + 1] = max(dp[i][j + 1], here + a * (idx - j))
# print(k, i)
ans = 0
for i in range(N + 1):
j = N - i
ans = max(ans, dp[i][j])
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 58,325,349,240,022 | 231 | 171 |
n = int(input())
def factorize(x):
res = {}
p = 2
while p * p <= x:
if x % p != 0:
p += 1
continue
cnt = 0
while x % p == 0:
x //= p
cnt += 1
res[p] = cnt
p += 1
if x != 1:
res[x] = 1
return res
f = factorize(n)
ans = 0
for pe in f.items():
for e in range(1, pe[1] + 1):
z = pe[0] ** e
if n % z == 0:
n //= z
ans += 1
print(ans)
| import sys
# import re
# import math
# import collections
# import decimal
# import bisect
# import itertools
# import fractions
# import functools
# import copy
# import heapq
# import decimal
# import statistics
import queue
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
a = na()
d = [0, 0, 0]
ans = 1
for ai in a:
ans *= d.count(ai)
ans %= MOD
for i in range(3):
if d[i] == ai:
d[i] += 1
break
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 73,528,327,969,082 | 136 | 268 |
def main():
L = int(input())
l = L/3
print(l*l*l)
main()
| import sys
S,T = input().split()
if not ( S.islower() and T.islower() ): sys.exit()
if not ( 1 <= len(S) <= 100 and 1 <= len(S) <= 100 ): sys.exit()
print(T,S,sep='') | 0 | null | 75,170,526,136,706 | 191 | 248 |
line = input()
words = line.split()
nums = list(map(int, words))
a = nums[0]
b = nums[1]
d = a // b
r = a % b
f = a / b
f = round(f,5)
print ("{0} {1} {2}".format(d,r,f)) | a,b=map(int, input().split())
print("{0} {1} {2:.8f}".format(a//b,a%b,a/b))
| 1 | 605,734,634,802 | null | 45 | 45 |
choise = {1, 2, 3}
for i in range(2):
choise.remove(int(input()))
print(list(choise)[0]) | A = int(input())
B = int(input())
C = [A, B]
for i in [1, 2, 3]:
if i not in C:
print(i)
| 1 | 110,604,104,314,940 | null | 254 | 254 |
N = int(input())
print(0 if N%1000==0 else 1000-N%1000) | n = int(input())
a = []
for i in range(n):
s = str(input())
a.append(s)
b = set(a)
print(len(b)) | 0 | null | 19,198,786,368,792 | 108 | 165 |
H, W = map(int, input().split())
if H == 1 or W == 1:
print(1)
elif H % 2 == 0:
print(H*W//2)
else:
if W % 2 == 0:
print(H*W//2)
else:
print((H//2)*(W//2) + (H//2+1)*(W//2+1)) | H, W = map(int, input().split())
ans = 0
x = H * W
if H == 1 or W == 1:
ans = 1
elif x % 2 == 0:
ans = x // 2
else:
ans = (x // 2) + 1
print(ans) | 1 | 51,154,420,510,028 | null | 196 | 196 |
import math
R = int(input())
p = math.pi
print(2 * p * R) | n=int(input())
a,c,i=[],0,1
while i <= n:
if c==0:
x=i
if x%3==0:
print(' '+str(i), end='')
i+=1
continue
c=0
if x%10==3:
print(' '+str(i), end='')
i+=1
continue
x//=10
if x == 0:
i+=1
continue
else:
c=1
print() | 0 | null | 16,176,865,708,180 | 167 | 52 |
N = int(input())
print(0 if N%1000==0 else 1000-N%1000) | X,Y=list(map(int,input().split()))
judge=False
for i in range(0,X+1):
if i*2+(X-i)*4==Y:
judge=True
if judge:
print("Yes")
else:
print("No") | 0 | null | 11,144,999,522,712 | 108 | 127 |
import math
import sys
import os
from operator import mul
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
N = I()
S = [_S() for _ in range(N)]
ans = 0
s = set()
for i in range(N):
s.add(S[i])
ans = len(s)
print(ans) | d = int(input())
c = list(map(int,input().strip().split()))
s = [list(map(int,input().strip().split())) for i in range(d)]
t = [int(input()) for i in range(d)]
last = [0]*26
sat = 0
for day,kind in enumerate(t):
sat += s[day][kind-1]
last[kind-1] = day+1
for l_kind,l_day in enumerate(last):
sat -= c[l_kind] * (day+1-l_day)
print(sat) | 0 | null | 20,063,296,967,780 | 165 | 114 |
from itertools import permutations
n = int(input())
p = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
perm = list(permutations(sorted(p), n)) #; print(perm)
a = perm.index(tuple(p))
b = perm.index(tuple(q))
print(abs(a-b)) | import itertools
n=int(input())
p=tuple(map(int, input().split()))
q=tuple(map(int, input().split()))
per=itertools.permutations(range(1, n+1), n)
for i, v in enumerate(per):
if(p==v): pi=i
if(q==v): qi=i
print(abs(pi-qi))
| 1 | 100,197,127,213,778 | null | 246 | 246 |
import numpy as np
#A = list(map(int,input().split()))
N = int(input())
A = list(map(int,input().split()))
ans = 0
mod = 10**9 + 7
s = 0
for i in range(N):
s += A[i]
s = s%mod
for i in range(N-1):
s = (s-A[i])%mod
ans += (A[i] * s)%mod
ans = ans % mod
print(ans%mod)
| def main():
n=int(input())
a=list(map(int, input().split()))
mod=10**9+7
ans=((sum(a)%mod)**2)%mod
for i in range(n):
ans-=a[i]**2
ans%=mod
m=pow(2,mod-2,mod)
print(ans*m%mod)
main() | 1 | 3,827,380,348,870 | null | 83 | 83 |
k = int(input())
sum = 0
def gcd(x, y): # ユークリッドの互除法
if y > x:
y,x = x,y
while y > 0:
r = x%y
x = y
y = r
return x
import math
for i in range(1,k+1):
for m in range(1,k+1):
sub = gcd(i,m)
for l in range(1,k+1):
sum += gcd(sub,l)
print(sum)
| from math import gcd
K = int(input())
result = 0
for a in range(1, K + 1):
for b in range(1, K + 1):
t = gcd(a, b)
for c in range(1, K + 1):
result += gcd(t, c)
print(result)
| 1 | 35,361,463,177,666 | null | 174 | 174 |
i = 1
n = int(input())
while i <= n:
x = i
if x % 3 == 0:
print('' , i , end = '')
else:
while x:
if x % 10 == 3:
print('' , i , end = '')
break
x = int(x / 10)
i = i + 1
print('') | n=int(raw_input())
ans=''
for i in range(1,n+1):
if i%3==0:ans+=" " + str(i)
else :
x=i
while x:
if x%10==3:
ans+=' '+str(i)
break
x/=10
print ans | 1 | 907,213,034,948 | null | 52 | 52 |
a,b = input().split()
a = int(a)
b = int(b.replace(".",""))
print((a*b)//100) | # coding:UTF-8
import sys
from math import factorial
MOD = 998244353
INF = 10000000000
def main():
n, k = list(map(int, input().split())) # スペース区切り連続数字
lrList = [list(map(int, input().split())) for _ in range(k)] # スペース区切り連続数字(行列)
s = []
for l, r in lrList:
for i in range(l, r+1):
s.append(i)
s.sort()
sum = [0] * (n + 1)
Interm = [0] * (2 * n + 1)
sum[1] = 1
for i in range(1, n):
for j in range(k):
l, r = lrList[j][0], lrList[j][1]
Interm[i+l] += sum[i]
Interm[i+r+1] -= sum[i]
sum[i+1] = (sum[i] + Interm[i+1]) % MOD
# result = Interm[n]
result = (sum[n] - sum[n-1]) % MOD
# ------ 出力 ------#
print("{}".format(result))
if __name__ == '__main__':
main()
| 0 | null | 9,665,111,005,700 | 135 | 74 |
N = int(input())
memo1 = []
memo2 = []
memo3 = []
memo4 = []
for i in range(N):
S = input()
sum_n = sum([1 if s=='(' else -1 for s in S])
if sum_n >= 0:
sum_n = 0
min_n = 1
for s in S:
if s == ')':
sum_n -= 1
min_n = min(min_n, sum_n)
else:
sum_n += 1
if min_n >= 0:
memo1.append([min_n, sum_n])
else:
memo2.append([min_n, sum_n])
else:
sum_n = 0
min_n = 1
for s in S[::-1]:
if s == '(':
sum_n -= 1
min_n = min(min_n, sum_n)
else:
sum_n += 1
if min_n >= 0:
memo4.append([min_n, sum_n])
else:
memo3.append([min_n, sum_n])
left = 0
for min_n, sum_n in memo1:
left += sum_n
memo2.sort(reverse=True)
for min_n, sum_n in memo2:
if left + min_n < 0:
print('No')
quit()
else:
left += sum_n
right = 0
for min_n, sum_n in memo4:
right += sum_n
memo3.sort(reverse=True)
for min_n, sum_n in memo3:
if right + min_n < 0:
print('No')
quit()
else:
right += sum_n
if left == right:
print('Yes')
else:
print('No') | import sys
def input(): return sys.stdin.readline().strip()
mod = 998244353
def main():
"""
各トークンを(最下点、最終的な高さ)に分けるのはできた。
そしてそれらを最下点位置が浅い順に並べるのも悪くはなかった、増加パートに関しては。
減少パートは減少度合が小さい順に付け加えたとしても高さが負に潜り込むケースがある。
（例）高さ3から下るとして、(-1, -1), (-2, 0), (-3, -2)が各トークンとすると
この順にくっつけると(-3, -2)を加えるときにアウトだが、
(-2, 0), (-3, -2), (-1, -1)の順だったらOK
なので下る場合には増加パートとは違う方法でくっつけないといけない。
結論としては、これは左右反転させれば増加していることになるので、右からくっつけるようにすればいい。
"""
N = int(input())
S_up = []
S_down = []
for _ in range(N):
s = input()
max_depth = 0
height = 0
for c in s:
if c == '(':
height += 1
else:
height -= 1
max_depth = min(max_depth, height)
if height > 0: S_up.append((max_depth, height - max_depth))
else: S_down.append((-(height - max_depth), -max_depth))
S_up.sort(key=lambda x: (x[0], x[1]))
S_down.sort(key=lambda x: (x[0], x[1]))
height_left = 0
while S_up:
d, h = S_up.pop()
#print("({}, {})".format(d, h))
if height_left + d < 0:
print("No")
return
height_left += d+h
height_right = 0
while S_down:
d, h = S_down.pop()
#print("({}, {})".format(d, h))
if height_right + d < 0:
print("No")
return
height_right += d+h
if height_left != height_right: print("No")
else: print("Yes")
if __name__ == "__main__":
main()
| 1 | 23,818,778,249,480 | null | 152 | 152 |
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
#処理内容
def main():
N = int(input())
L = []
Slist1 = []
Slist2 = []
R = []
l = 0; r = 0
for i in range(N):
M = 0; end = None
var = 0
S = input()
for j in S:
if j == "(":
var += 1
l += 1
else:
var -= 1
r += 1
M = min(var, M)
end = var
if M == 0:
L.append([M, end])
elif M == end:
R.append([M, end])
elif M < 0 and end > 0:
Slist1.append([-M, end])
else:
Slist2.append([M - end, M, end])
Slist1 = sorted(Slist1)
Slist2 = sorted(Slist2)
if l != r:
print("No")
return
cnt = 0
X = len(L)
for i in range(X):
cnt += L[i][1]
judge = "Yes"
X = len(Slist1)
for i in range(X):
M = Slist1[i][0]
cnt -= M
if cnt < 0:
judge = "No"
break
else:
cnt += M + Slist1[i][1]
X = len(Slist2)
for i in range(X):
cnt += Slist2[i][1]
if cnt < 0:
judge = "No"
break
else:
cnt -= Slist2[i][0]
print(judge)
if __name__ == '__main__':
main() | import sys
x = sys.stdin.readline()
a_list = x.split(" ")
if int(a_list[0]) < int(a_list[1]) and int(a_list[1]) < int(a_list[2]):
print "Yes"
else:
print "No" | 0 | null | 12,011,174,001,892 | 152 | 39 |
N = input()
if N.find('7') > -1:
print('Yes')
else:
print('No') | print('Yes' if '7' in list(str(input().split())) else 'No') | 1 | 34,113,991,965,186 | null | 172 | 172 |
x,y = map(int,input().split())
if x > 3:
x = 4
if y > 3:
y = 4
ans = 0
if x == y == 1:
ans += 400000
ans += (8-x-y)*100000
print(ans) | A,B = map(int,input().split())
print([A-2*B,0][A<=2*B]) | 0 | null | 152,995,712,853,258 | 275 | 291 |
n,m=map(int,input().split())
a =list(map(int,input().split()))
day = 0
for i in range(m):
day += a[i]
print(-1 if day>n else n - day) | N, M = map(int, input().split())
A = list(map(int, input().split()))
for Ai in A:
N -= Ai
if N < 0:
print(-1)
break
if N >= 0:
print(N) | 1 | 31,901,350,603,930 | null | 168 | 168 |
input()
array = input().split()
array.reverse()
print(' '.join(array)) | n = int(input())
x = list(input().split())
x.reverse()
print(" ".join(x))
| 1 | 983,049,679,050 | null | 53 | 53 |
N = int(input())
MOD = 10**9+7
nums = list(map(int, input().split()))
B = [0 for _ in range(60)]
for num in nums:
for i in range(60):
if num>>i&1:
B[i] += 1
answer = 0
for i, b in enumerate(B):
if b > 0:
answer = (answer+b*(N-b)*2**i)%MOD
print(answer)
| mod = 10**9 + 7
n = int(input())
dat = list(map(int, input().split()))
cnt0 = [0] * 64
cnt1 = [0] * 64
for i in range(n):
for j in range(62):
if ((dat[i] >> j) & 1) == 1:
cnt1[j] += 1
else:
cnt0[j] += 1
#print(cnt0)
#print(cnt1)
res = 0
for i in range(62):
res += (cnt0[i] * cnt1[i]) << i
res %= mod
print(res) | 1 | 122,764,284,652,662 | null | 263 | 263 |
N = int(input())
if(N % 2 == 0):
print(0.5000000000)
else:
M = (N+1)/2
print(M/N) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
# あるbit列に対するコストの計算
def count(zerone):
one = 0
cnt = 0
for i in range(N):
flag = True
if zerone[i] == 1:
one += 1
for j in range(len(A[i])):
if A[i][j][1] != zerone[A[i][j][0]-1]:
flag = False
break
if flag:
cnt += 1
if cnt == N:
return one
else:
return 0
# bit列の列挙
def dfs(bits):
if len(bits) == N:
return count(bits)
res = 0
for i in range(2):
bits.append(i)
res = max(res, dfs(bits))
bits.pop()
return res
# main
N = int(input())
A = [[] for _ in range(N)]
for i in range(N):
a = int(input())
for _ in range(a):
A[i].append([int(x) for x in input().split()])
ans = dfs([])
print(ans) | 0 | null | 149,324,618,353,920 | 297 | 262 |
N = int(input())
A = list(map(int, input().split()))
mod = int(1e9+7)
CNT = [0] * (N+10)
CNT[-1] = 3
ans = 1
for a in A:
CNT[a] += 1
ans *= CNT[a-1]
ans %= mod
CNT[a-1] -= 1
print(ans) | import sys
from collections import Counter as cc
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(mi())
def main():
mod = 10**9 + 7
n = ii()
a = li()
t = [0]*(n)
ans = 1
for i in range(n):
if a[i] == 0:
tmp = 3
else:
tmp = t[a[i]-1]
ans *= tmp-t[a[i]]
ans %= mod
t[a[i]] += 1
print(ans)
if __name__ == '__main__':
main() | 1 | 130,162,581,609,792 | null | 268 | 268 |
N = int(input())
S = list(input())
i = 1
count = 0
while i * 2 < N:
n = 0
while n + i * 2 < N:
if (S[n] != S[n+i]) and (S[n+i] != S[n+2*i]) and (S[n] != S[n+i*2]):
count += 1
#print(S[n], S[n+i], S[n+2*i])
n += 1
i += 1
print(S.count('G') * S.count('R') * S.count('B') - count) | mod = 1000000007
n = int(input())
ans = pow(10, n, mod) - 2*pow(9, n, mod) + pow(8, n, mod)
print(ans % mod)
| 0 | null | 19,564,726,844,100 | 175 | 78 |
n = int(input())
d = [list(map(int, input().split())) for i in range(n)]
def zoro(items):
return items[0] == items[1]
for a, b, c in zip(d[:], d[1:], d[2:]):
if zoro(a) and zoro(b) and zoro(c):
print('Yes')
exit(0)
print('No')
| n,p = map(int,input().split())
s = input()
l = [0 for i in range(p)]
l[0] = 1
ten = 1
cnt = 0
ans = 0
if p == 2 or p == 5:
for i in range(n):
if int(s[i]) % p == 0:
ans += i+1
else:
for i in range(n):
cnt = (cnt + int(s[-i-1]) * ten) % p
l[cnt] += 1
ten = (ten * 10) % p
for i in l:
if i > 1:
ans += i * (i - 1) // 2
print(ans) | 0 | null | 30,286,313,151,372 | 72 | 205 |
def make_divisors(n):
'''
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 solve():
N = int(input())
D = make_divisors(N)
ans = N - 1
for d in D:
ans = min(ans, N // d - 1 + d - 1)
print(ans)
if __name__ == "__main__":
solve()
| import math, itertools
n = int(input())
X = list(list(map(int,input().split())) for _ in range(n))
L = list(itertools.permutations(range(n),n))
ans = 0
for l in L:
dist = 0
for i in range(n-1):
s,t = l[i],l[i+1]
vx = X[s][0] - X[t][0]
vy = X[s][1] - X[t][1]
dist += math.sqrt(vx**2 + vy**2)
ans += dist
print(ans/len(L)) | 0 | null | 154,926,223,551,792 | 288 | 280 |
# -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def divisors(N: int) -> set:
from math import sqrt
s = {1, N}
for i in range(2, int(sqrt(N))+1):
if N % i == 0:
s.add(i)
s.add(N // i)
return s
def check(n, k):
if k == 1:
return False
while n >= k:
if n % k == 0:
n //= k
else:
n %= k
return n == 1
N = INT()
divs = divisors(N) | divisors(N-1)
ans = 0
for k in divs:
if check(N, k):
ans += 1
print(ans)
| import sys
import numpy as np
from collections import deque
input = lambda: sys.stdin.readline().rstrip()
def solve():
N = int(input())
edge = [[] for _ in range(N)]
ab = [tuple() for _ in range(N - 1)]
for i in range(N - 1):
a, b = map(int, input().split())
a, b = a - 1, b - 1
edge[a].append(b)
edge[b].append(a)
ab[i] = (a, b)
# print(ab)
# print(edge)
max_v = 0
max_v_dim = 0
for i, e in enumerate(edge):
if max_v_dim < len(e):
max_v_dim = len(e)
max_v = i
# print(max_v)
# print(max_v_dim)
# bfs
q = deque()
q.append(max_v)
ec = np.full(N, -1, dtype='i8')
ec[max_v] = max_v_dim + 10
vc = dict()
# vc = np.full((N, N), -1, dtype='i8')
while q:
nv = q.popleft()
nc = ec[nv]
tc = 1
for v in edge[nv]:
v1, v2 = min(nv, v), max(nv, v)
if not ((v1, v2) in vc):
if nc == tc:
tc += 1
ec[v] = tc
vc[(v1, v2)] = tc
tc += 1
q.append(v)
print(max_v_dim)
for v1, v2 in ab:
print(vc[(v1, v2)])
if __name__ == '__main__':
solve()
| 0 | null | 88,375,974,152,508 | 183 | 272 |
c, flag = 0, 0
for _ in range(int(input())):
d1, d2 = map(int, input().split())
if d1 == d2:
c += 1
else:
c = 0
if c >= 3:
flag = 1
if flag:
print("Yes")
else:
print("No") | def readInt():
return list(map(int, input().split()))
h, w = readInt()
if h == 1 or w == 1:
print(1)
elif h*w%2 == 0:
print(h*w//2)
else:
print(h*w//2+1)
| 0 | null | 26,789,463,305,980 | 72 | 196 |
N, K = map(int, input().split())
def createFacArr(n, mod):
'''
二項係数計算用の配列の作成
Parameters
n : int
配列のサイズ
mod : int
あまり
Returns
fac : list
階乗のリスト
finv : list
modの逆元のリスト
ivn : list
'''
fac = [0] * n
finv = [0] * n
inv = [0] * n
fac[0], fac[1] = 1, 1
finv[0], finv[1] = 1, 1
inv[1] = 1
for i in range(2, n):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
return fac, finv
def comb(n ,k, mod, fac, finv):
'''
二項係数の計算
Parameters
n : int
元集合
k : int
元集合から選択する数
mod : int
あまり
fac : list
階乗のリスト
finv : list
逆元のリスト
Returns
c : int
nCkの組み合わせの数
'''
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
K = min(N-1, K)
ans = 0
MOD = 10 ** 9 + 7
fac, finv = createFacArr(N+100, MOD)
for i in range(K+1):
# iは0の個数
ans += comb(N, i, MOD, fac, finv) * comb(N-1, N-i-1, MOD, fac, finv) % MOD
ans %= MOD
print(ans)
| n, k = map(int, input().split())
mod = 10 ** 9 + 7
def comb(n, r):
if n < r:return 0
if n < 0 or k < 0:return 0
return fa[n] * fi[r] % mod * fi[n - r] % mod
fa = [1] * (n + 1)
fi = [1] * (n + 1)
for i in range(1, n + 1):
fa[i] = fa[i - 1] * i % mod
fi[i] = pow(fa[i], mod - 2, mod)
ans = 0
for i in range(min(k, n - 1) + 1):
ans += comb(n, i) * comb(n - 1, i) % mod
print(ans % mod) | 1 | 67,393,477,934,358 | null | 215 | 215 |
N = int(raw_input())
A = map(int, raw_input().split())
count = 0
for i in xrange(N):
minj = i
for j in xrange(i, N):
if A[j] < A[minj]:
minj = j
if minj != i:
A[i], A[minj] = A[minj], A[i]
count += 1
print ' '.join(map(str, A))
print count | def selection_sort(A, N):
count = 0
for i in range(N):
min_j = i
for j in range(i, N):
if A[j] < A[min_j]:
min_j = j
if i != min_j:
A[i], A[min_j] = A[min_j], A[i]
count += 1
print " ".join(map(str, A))
print count
N = input()
A = map(int, raw_input().split())
selection_sort(A, N) | 1 | 20,587,044,900 | null | 15 | 15 |
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
n = INT()
a = LIST()
ans = 1
r = 0
g = 0
b = 0
for x in a:
ans = ans * ( (r == x) + (g == x) + (b == x) ) % (10**9+7)
if r == x:
r += 1
elif g == x:
g += 1
else:
b += 1
print(ans) | a=["SUN","MON","TUE","WED","THU","FRI","SAT"]
s=input()
k=-1
for i in range(7):
if(a[i]==s):k=i
k=(7-k)
print(k) | 0 | null | 131,854,899,713,852 | 268 | 270 |
N,K = map(int, input().split())
P = list(int(n) for n in input().strip().split())[:N]
P.sort()
total = 0
for i in range(K):
total +=P[i]
print(total) | ini = lambda : int(input())
inm = lambda : map(int,input().split())
inl = lambda : list(map(int,input().split()))
gcd = lambda x,y : gcd(y,x%y) if x%y else y
n,k = inm()
p = inl()
p = sorted(p)
print(sum(p[:k]))
| 1 | 11,600,183,875,110 | null | 120 | 120 |
# -*- coding: utf-8 -*-
k,x = list(map(int,input().split()))
ret = "No"
if 500*k>=x:
ret = "Yes"
print(ret) | K, X = input().split()
K = int(K)
X = int(X)
if 500*K >= X:
print("Yes")
else:
print("No") | 1 | 98,076,382,352,080 | null | 244 | 244 |
now = int(input())
if now >= 30:
print('Yes')
else:
print('No')
| N = int(input())
A = sorted(list(map(int, input().split())), reverse=True)
n = N // 2
if N % 2 == 1:
ans = sum(A[:n]) + sum(A[1:n+1])
else:
ans = sum(A[:n]) + sum(A[1:n])
print(ans) | 0 | null | 7,490,578,479,160 | 95 | 111 |
X = int(input())
tmp = 360
while True:
if tmp % X == 0:
print(tmp//X)
exit()
else:
tmp+= 360 | from math import gcd
s = int(input())
print(360//gcd(360,s)) | 1 | 13,185,883,284,604 | null | 125 | 125 |
N = int(input())
A = list(map(int,input().split()))
tot = sum(A)
D = {}
for i in range(N):
a = A[i]
if a not in D:
D[a] = 0
D[a] += 1
Q = int(input())
for _ in range(Q):
b,c = map(int,input().split())
if b not in D:
print(tot)
else:
d = c-b
if c in D:
n = D[b]
D[c] += D[b]
del D[b]
else:
n = D[b]
D[c] = D[b]
del D[b]
tot += n*d
print(tot) | import array
N = int(input())
A = array.array('L', list(map(int, input().split())))
MAX = 10**5+1
X = array.array('L', [0]) * MAX
Y = array.array('L', range(MAX))
for i in range(len(A)): X[A[i]] += 1
Q = int(input())
cur = sum(array.array('L', (X[i]*Y[i] for i in range(len(X)))))
for i in range(Q):
[b, c] = list(map(int, input().split()))
cur = cur - X[b]*b + X[b]*c
print(cur)
X[c] += X[b]
X[b] = 0
| 1 | 12,302,262,909,510 | null | 122 | 122 |
import sys
input=sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
from collections import defaultdict
def main():
n=II()
A=LI()
X=defaultdict(int)
Y=defaultdict(int)
for i,v in enumerate(A):
X[i+v]+=1
Y[i-v]+=1
ans=0
for k,v in X.items():
ans+=v*Y[k]
print(ans)
if __name__=="__main__":
main()
| import collections
cnt = collections.defaultdict(int)
N = int(input())
ans = 0
height = list(map(int, input().split()))
for n in range(1, N+1):
ans += cnt[n - height[n-1]]
cnt[n+height[n-1]] += 1
print(ans) | 1 | 26,100,421,570,090 | null | 157 | 157 |
N = int(input())
l = [i for i in range(1, N + 1) if i % 3 != 0 and i % 5 != 0]
s = sum(l)
print(s) | n = int(input())
sum = 0
for i in range(1, n + 1):
if i % 3 != 0 and i % 5 != 0:
sum = sum + i
print(sum) | 1 | 35,068,922,309,008 | null | 173 | 173 |
N , M = map(int,input().split())
SC = []
for i in range(M):
SC.append(list(map(int,input().split())))
if M == 0:
if N == 1:
print(0)
else:
print(10**(N-1))
exit()
if N == 1:
for i in range(10):
n = str(i)
for j in range(M):
if int(n[SC[j][0]-1]) != SC[j][1]:
break
if j == M-1:
print(i)
exit()
else:
for i in range(10**(N-1),10**N):
n = str(i)
for j in range(M):
if int(n[SC[j][0]-1]) != SC[j][1]:
break
if j == M-1:
print(i)
exit()
print(-1) | n, m = map(int,input().split())
sc = [list(map(int,input().split())) for i in range(m)]
flg = True
for ci in range(0, 10**n):
cis = str(ci)
if len(cis) != n:
continue
for j in range(m):
s, c = sc[j][0]-1, sc[j][1]
if int(cis[s]) != sc[j][1]:
flg = False
break
if j == m-1:
flg = True
if flg == True:
break
print(ci) if flg else print(-1) | 1 | 60,912,309,215,186 | null | 208 | 208 |
A, B = [s for s in input().split()]
A = int(A)
B = int(float(B) * 100 + .5)
C = A * B
ans = int(C // 100)
print(ans) | import sys
s = sys.stdin.readline().rstrip("\n")
print(s[:3]) | 0 | null | 15,602,431,510,928 | 135 | 130 |
n,m=map(int,input().split())
*s,=map(int,input()[::-1])
i=0
a=[]
while i<n:
j=min(n,i+m)
while s[j]:j-=1
if j==i:
print(-1)
exit()
a+=j-i,
i=j
print(*a[::-1]) | n,k=map(int,input().split())
h=input()
cnt=0
for i in range(n):
if h[i]=="1":
cnt+=1
else:
cnt=0
if cnt>=k:
print(-1)
exit()
h=h[::-1]
h+="0"
idx=0
ans=[]
while 1:
if idx+k>=n:
ans.append(n-idx)
break
for i in range(k,0,-1):
if h[idx+i]=="0":
ans.append(i)
idx+=i
break
ans=reversed(ans)
print(" ".join([str(x) for x in ans]))
| 1 | 138,873,363,428,672 | null | 274 | 274 |
x = list(map(int,input().split()))
x[0],x[1] = x[1],x[0]
x[0],x[2] = x[2],x[0]
print(str(x[0]) +" " + str(x[1]) + " "+ str(x[2])) | A,B,C=map(int,input().split())
R=A
A=B
B=R
R=A
A=C
C=R
print(A,B,C) | 1 | 37,914,723,561,792 | null | 178 | 178 |
n=int(input());s=['a']
while len(s)>0:
t=s.pop(-1)
if len(t)==n:print(t)
else:
a=max(ord(i)for i in t)
for a in range(a+1,96,-1):s.append(t+chr(a)) | n = int(input())
s = list(input())
ans = ''
for i in s:
ascii_code = (ord(i) + n)
if ascii_code >= 91:
ascii_code -= 26
ans += chr(ascii_code)
print(ans)
| 0 | null | 93,376,642,662,380 | 198 | 271 |
N = int(input())
A = [int(i) for i in input().split()]
A = sorted(A, reverse=True)
A += A[1:]
A = sorted(A, reverse=True)
print(sum(A[:N-1]))
| n=int(input())
A=sorted(list(map(int,input().split())))
ans=0
if n==1 : print(0);exit()
for i in range(n-1):
# if i==0 : ans+=A[-1];continue
ans+=A[-((i+1)//2+1)]
print(ans) | 1 | 9,121,369,172,464 | null | 111 | 111 |
# -*- coding: utf-8 -*-
r, c = map(int, raw_input().split())
cl= [0] * c
for i in xrange(r):
t = map(int, raw_input().split())
for i, a in enumerate(t): cl[i] += a
print ' '.join(map(str, t)), sum(t)
print ' '.join(map(str, cl)), sum(cl) | r, c = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(r)]
for i in range(r):
matrix[i].append(sum(matrix[i]))
matrix.append(list(map(sum, zip(*matrix))))
# matrix.append([sum(i) for i in zip(*matrix)])
for row in matrix:
print(' '.join(str(e) for e in row))
| 1 | 1,365,222,987,778 | null | 59 | 59 |
def main():
import math
a, b, x = map(int, input().split())
if a * a * b >= x * 2:
c = x * 2 / (b * a)
print(math.degrees(math.atan(b / c)))
else:
d = 2 * (b - x / a / a)
print(math.degrees(math.atan(d / a)))
if __name__ == '__main__':
main()
| import collections
n=int(input())
a=collections.Counter(list(map(int, input().split())))
if len(a)==n: print('YES')
else: print('NO') | 0 | null | 118,173,478,946,608 | 289 | 222 |
def solve():
ans = 0
N, T = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
A.sort()
dp = [[0]*(T+A[-1][0]) for _ in range(N+1)]
for i in range(1,N+1):
for t in range(1,T+A[-1][0]):
if t<A[i-1][0] or t>=T+A[i-1][0]:
dp[i][t] = max(dp[i-1][t],dp[i][t-1])
else:
dp[i][t] = max([dp[i-1][t],dp[i][t-1],dp[i-1][t-A[i-1][0]]+A[i-1][1]])
ans = max(dp[-1])
return ans
print(solve()) | n = int(input())
X = input()
a = 0
for i in range(n-2):
if X[i] + X[i+1] + X[i+2] == 'ABC':
a +=1
else:
a +=0
print(a) | 0 | null | 125,544,923,443,084 | 282 | 245 |
H, W, M = map(int, input().split())
row = [0] * (H + 1)
col = [0] * (W + 1)
bom = []
for i in range(M):
h, w = map(int, input().split())
bom.append([h, w])
row[h] += 1
col[w] += 1
rmax = max(row)
cmax = max(col)
cnt = row.count(rmax) * col.count(cmax)
for h, w in bom:
if rmax == row[h] and cmax == col[w]:
cnt -= 1
print(rmax + cmax - (cnt == 0))
| N = int(input())
S = []
for _ in range(N):
S.append(input())
import sys
from collections import Counter
count_dict = Counter(S)
most_freq = count_dict.most_common(1)[0][1]
words = []
for word, freq in sorted(count_dict.items(), key=lambda x: -x[1]):
if freq == most_freq:
words.append(word)
for word in sorted(words):
print(word)
| 0 | null | 37,556,698,598,690 | 89 | 218 |
n = int(input())
c = 0
for i in range(1,n):
if (i%2==1):
c+=1
print("{0:.10f}".format(1-(c/n)))
| import math
N,M,X = map(int,input().split())
#a[i][0]:price of the i-th book
a = [[] for i in range(N)]
for i in range(N):
a[i] = list(map(int,input().split()))
def is_greater(b):
for i in b:
if i < X:
return False
return True
cost = math.inf
for i in range(2**N):
b = [0]*(M+1)
for j in range(N):
if ((i >> j)&1):
for k in range(M+1):
b[k] += a[j][k]
if b[0] < cost and is_greater(b[1:]):
cost = b[0]
if cost == math.inf:
print(-1)
else:
print(cost) | 0 | null | 99,668,024,489,568 | 297 | 149 |
n = int(raw_input())
elems = map(int, raw_input().split(' '))
cumul = 0
res = 0
for j in range(len(elems)):
res += elems[j] * cumul
cumul += elems[j]
print res
| n = int(input())
d = list(map(int,input().split()))
ans = 0
for i in range(n):
ans += d[i] * (sum(d) - d[i])
print(ans // 2) | 1 | 167,675,830,554,852 | null | 292 | 292 |
import sys
while True:
try:
a,b = raw_input().split()
c = int(a) + int(b)
for i in range(10):
if c / (10**i) == 0:
print (i)
break
except EOFError:
break | import sys
values = []
for line in sys.stdin:
values.append([int(x) for x in line.split()])
digit = 0
for x, y in values:
sum = x + y; digit = 0
while sum >= 1:
sum //= 10
digit += 1
print(digit) | 1 | 77,521,652 | null | 3 | 3 |
a, b = map(int, input().split())
ans = 0
if a >= b:
for i in range(a):
ans += b * 10**i
else:
for i in range(b):
ans += a * 10**i
print(ans) | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def main():
N = I()
s = 'abcdefghijklmnopqrstuvwxyz'
assert len(s) == 26
cur = []
while N > 0:
amari = N % 26
if amari == 0:
amari += 26
cur.append(s[amari-1])
N -= amari
N //= 26
print(''.join(cur[::-1]))
main()
| 0 | null | 47,929,912,126,980 | 232 | 121 |
a = int(input())
print('Yes') if a>=30 else print('No') | #-*- coding: utf-8 -*-
X=int(input())
if X>=30:
print("Yes")
if X<30:
print("No") | 1 | 5,780,638,376,948 | null | 95 | 95 |
N = int(input())
A = list(map(int,input().split()))
A.sort()
ans = 0
for k in range(1, N): ans += A[N-k//2-1]
print(ans) | n = int(input())
count_list = [0] * 4
for i in range(n):
text = input()
if text == "AC":
count_list[0] += 1
elif text == "WA":
count_list[1] += 1
elif text == "RE":
count_list[3] += 1
else:
count_list[2] += 1
print("AC x " + str(count_list[0]))
print("WA x " + str(count_list[1]))
print("TLE x " + str(count_list[2]))
print("RE x " + str(count_list[3])) | 0 | null | 8,950,006,584,508 | 111 | 109 |
r = int(input())
a = (44/7)*r
print(a) | N,K=map(int,input().split())
H=sorted(list(map(int,input().split())))
if K==0:
print(sum(H))
exit()
H=H[-N:-K]
print(sum(H)) | 0 | null | 54,900,297,088,938 | 167 | 227 |
N = int(input())
print(N//2 if N%2==0 else N//2+1) | [n,k] = map(int, input().split(' '))
A = list(map(int, input().split(' ')))
for i in range(k,n):
if A[i-k]<A[i]:
print('Yes')
else:
print('No')
| 0 | null | 33,014,406,710,622 | 206 | 102 |
xs = ["X"] + input().split(" ")
print(xs.index("0")) | N = int(input())
shougen = [[] for _ in range(N)]
for k in range(N):
A = int(input())
for j in range(A):
x, y = map(int, input().split())
x -= 1
shougen[k].append((x, y))
ans = 0
bit = 2**N-1
while bit:
person = [-1 for _ in range(N)]
b = bit
count = 0
while count < N:
person[count] = b & 1
b >>= 1
count += 1
flag = True
for k in range(N):
if person[k] == 1:
for x, y in shougen[k]:
if person[x] != y:
flag = False
break
else:
continue
break
if flag:
ans = max(ans, sum(person))
bit -= 1
print(ans)
| 0 | null | 67,672,947,587,716 | 126 | 262 |
from sys import stdin
from collections import deque
n = int(stdin.readline())
d = [-1] * (n + 1)
def bfs(G):
d[1] = 0
queue = [1]
dq = deque([1])
while len(dq) > 0:
v = dq.popleft()
for c in G[v]:
if d[c] < 0:
d[c] = d[v] + 1
dq.append(c)
for i, x in enumerate(d[1:], start=1):
print(i, x)
G = {}
for i in range(n):
x = list(map(int, stdin.readline().split()))
G[x[0]] = x[2:]
bfs(G) | p = 10**9+7
def pow(x,m):
if m==0:
return 1
if m==1:
return x
if m%2==0:
return (pow(x,m//2)**2)%p
else:
return (x*(pow(x,(m-1)//2)**2)%p)%p
A = [1 for _ in range(10001)]
for i in range(2,10001):
A[i] = (i*A[i-1])%p
B = [1 for _ in range(10001)]
B[10000] = pow(A[10000],p-2)
for i in range(9999,1,-1):
B[i] = ((i+1)*B[i+1])%p
def f(n,k):
if k>n:
return 0
return (A[n]*B[k]*B[n-k])%p
S = int(input())
n = S//3
ans = 0
for i in range(n,0,-1):
k = S-3*i
ans = (ans+f(k+i-1,i-1))%p
print(ans) | 0 | null | 1,639,831,401,110 | 9 | 79 |
N,M = map(int, input().split())
S = list(input())
S.reverse()
ans = []
i = 0
while i < N:
num = 0
for j in range(min(N, i+M), i, -1):
if S[j] == "0":
num = j-i
i = j
break
if num == 0:
ans = -1
break
ans.append(num)
if ans == -1:
print(ans)
else:
ans.reverse()
print(*ans) | import sys
input = lambda: sys.stdin.readline().rstrip()
n, m = map(int, input().split())
s = input()
ans = []
s = s[::-1]
now = 0
while True:
for i in range(m, -1, -1):
if i == 0:
print(-1)
sys.exit()
if now + i <= n and s[now + i] == "0":
now += i
ans.append(i)
if now == n:
print(*ans[::-1])
sys.exit()
else:
break
| 1 | 139,172,643,102,756 | null | 274 | 274 |
K = int(input())
count =1
x = 7%K
for i in range(0,K+1):
if x== 0:
print(count)
break
count+=1
x = (x*10+7)%K
if i== K:
print(-1) | K = int(input())
# 数列を漸化式と見て、順に余りを計算する
# 余りは循環するので、高々K項まで計算すれば、少なくとも1つの循環を抽出できるので十分
# あとは抽出した余りの列において、0が含まれるか、含まれる場合は何番目かを求める
i, a = 0, 0
l = []
for i in range(K):
a = (10*a + 7) % K
l.append(a)
j, ans = 0, -1
for j in range(K):
if l[j] == 0:
ans = j + 1
break
print(ans) | 1 | 6,117,551,156,768 | null | 97 | 97 |
# import math
# from fractions import gcd
# import numpy as np
# import scipy as scp
# 入力の受け取り
k,x = map(int,input().split())
if k * 500 >= x:
ans = "Yes"
else:
ans = "No"
print(ans) | a, b = list(map(int, input().split()))
if a * 500 >= b:
my_result = 'Yes'
else:
my_result = 'No'
print(my_result) | 1 | 97,891,138,270,628 | null | 244 | 244 |
# import numpy as np
import itertools
if __name__ == "__main__":
N,K = map(int,input().split())
P = [ int(p)-1 for p in input().split() ]
C = list(map(int,input().split()))
# print(P)
# 一度計算したサイクル情報をキャッシュしておくための配列
# cycleIDs = np.full( N, -1, np.int64 )
cycleIDs = [ -1 for _ in range(N)]
cycleInfs = []
cycleID = 0
procCnt = 0
for n in range(N):
v = n
if cycleIDs[v] != -1:
continue
else:
currentCycleCosts = []
while True:
# 全頂点について、属するサイクルを計算する
currentCycleCosts.append( C[v] )
cycleIDs[v] = cycleID
v = P[v]
if cycleIDs[v] != -1:
# サイクル終了
# ループを含めない最大の処理回数
procCnt = K % len( currentCycleCosts )
# それで足りてるのかわからないが、Last2周分は、ループ合計がプラスでも必ずしもループするとは限らない
# その部分は、ちゃんと計算する
# -------------------------------------------------
# 4 101
# 2 3 4 1
# 50 -49 -50 50
# 上記のようなパターンの場合、
# 最大25回ループ + 1回処理可能だが、その場合、25 + 50 = 75
# 24回ループ + 2回処理でやめると、124になる
# 無条件でループする回数は、ループ可能な最大の回数-1らしい
# -------------------------------------------------
# 割り切れて、尚且つサイクル合計がマイナスのパターンで、最低１個は処理するのにもここで対応
if len( currentCycleCosts ) + procCnt <= K:
procCnt += len( currentCycleCosts )
cycleInfs.append( ( procCnt, len(currentCycleCosts), currentCycleCosts * 3 ) )
cycleID += 1
break
# scores = []
# procCnt = 0
ans = -10 ** 9
for procCnt, currentCycleSize, currentCycleCosts in cycleInfs:
# サイクル内でループしてスコアを稼ぐ場合の考慮
loopScore = 0
if sum(currentCycleCosts) > 0:
cycleLoopCnt = ( K - procCnt ) // currentCycleSize
loopScore = cycleLoopCnt * sum(currentCycleCosts[:currentCycleSize])
# print("loopScore",loopScore,procCnt)
# このサイクルに属する全頂点分をまとめて計算する
for i in range(currentCycleSize):
# print(np.roll( currentCycleCosts, i ).cumsum()[:procCnt])
score = max( itertools.accumulate( currentCycleCosts[i:i+procCnt] ) )
if ans < score + loopScore:
ans = score + loopScore
# ans = max( ans, score + loopScore )
print(ans)
# print(max(scores))
| N,K=map(int,input().split())
P=list(map(int,input().split()))
P=list(map(lambda x:x-1,P))
C=list(map(int,input().split()))
ans=-float("inf")
for i in range(N):
st=i
tmp=0
for j in range(K):
st=P[st]
tmp+=C[st]
ans=max(ans,tmp)
if i==st:
break
s,v=divmod(K,j+1)
if s>1 and v==0:
s-=1
v=j+1
tmp*=s
ans=max(ans,tmp)
for j in range(v):
st=P[st]
tmp+=C[st]
ans=max(ans,tmp)
print(ans) | 1 | 5,462,759,554,824 | null | 93 | 93 |
s = (input()[::-1]) # 入力文字列を逆順でsに格納
n = len(s)
counts = [0]*2019
counts[0]=1
b = 1
num = 0
for i in s:
num += int(i)*b
num %=2019
b *=10
b %=2019
counts[num]+=1
# print(counts)
ans = 0
for j in counts:
ans +=j*(j-1)/2
print(int(ans)) | s = input()[::-1]
l = [0 for i in range(2019)]
l[0] = 1
a, b = 0, 1
ans = 0
for i in s:
a += int(i) * b
a %= 2019
b *= 10
b %= 2019
l[a] += 1
for i in l:
ans += i * (i - 1) // 2
print(ans) | 1 | 31,003,261,936,192 | null | 166 | 166 |
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))
class UnionFind():
# インデックスは0-start
# 初期化
def __init__(self, n):
self.n = n
self.parents = [-1]*n
self.group = n
# private function
def root(self, x):
if self.parents[x]<0:
return x
else:
self.parents[x] = self.root(self.parents[x])
return self.parents[x]
# x,yが属するグループの結合
def union(self, x, y):
x = self.root(x)
y = self.root(y)
if x==y:
return
if self.parents[x]>self.parents[y]:
x,y = y,x
self.parents[x] += self.parents[y]
self.parents[y] = x
self.group -= 1
# x,yが同グループか判定
def same(self, x, y):
return self.root(x)==self.root(y)
# xと同じグループの要素数を取得
def size(self, x):
return -self.parents[self.root(x)]
######################################################
N,M,K=mint()
T=UnionFind(N)
block=[0]*N
for _ in range(M):
a,b=mint()
T.union(a-1,b-1)
block[a-1]+=1
block[b-1]+=1
for _ in range(K):
c,d=mint()
if T.same(c-1,d-1):
block[c-1]+=1
block[d-1]+=1
ans=[T.size(i)-block[i]-1 for i in range(N)]
lprint(ans,' ') | class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):#要素xが属するグループの根を返す
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):#要素xが属するグループと要素yが属するグループとを併合する
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):#要素xが属するグループのサイズ（要素数）を返す
return -self.parents[self.find(x)]
def same(self, x, y):#要素x, yが同じグループに属するかどうかを返す
return self.find(x) == self.find(y)
def members(self, x):#要素xが属するグループに属する要素をリストで返す
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):#すべての根の要素をリストで返す
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):#グループの数を返す
return len(self.roots())
def all_group_members(self):#{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
return {r: self.members(r) for r in self.roots()}
def __str__(self):#print()での表示用 ルート要素: [そのグループに含まれる要素のリスト]を文字列で返す
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = map(int, input().split())
uf = UnionFind(N)
edge1 = []
edge2 = []
for i in range(M):
a,b = map(int,input().split())
edge1.append((a-1,b-1))
for i in range(K):
c,d = map(int,input().split())
edge2.append((c-1,d-1))
for a,b in edge1:
uf.union(a,b)
#同じグループに属する人数（自分を除く）
ans = [uf.size(i)-1 for i in range(0,N)]
for a,b in edge1:#すでに友達なら削る
ans[a] -= 1
ans[b] -= 1
for c,d in edge2:
if uf.same(c,d): #ブロック関係かつ同じグループに属しているなら
ans[c] -= 1
ans[d] -= 1
print(*ans) | 1 | 61,743,950,645,608 | null | 209 | 209 |
"""
最大限傾けたとき、水と接している面は横から見ると台形ないし三角形となる
水と接している面の面積 x/a が a*b/2 より大きい場合は台形となり、以下の場合は三角形となる
台形の場合
最大限傾けたとき、水と接している台形の上辺の長さをnとすると
(n+b)*a/2 = x/a
n = 2*x/(a**2) - b
求める角度をthetaとすると
tan(theta) = (b-n)/a
theta = arctan((b-n)/a)
三角形の場合
最大限傾けたとき、水と接している三角形の底辺の長さをnとすると
n*b/2 = x/a
n = 2*x/(a*b)
求める角度をthetaとすると
tan(theta) = b/n
theta = arctan(b/n)
"""
import sys
sys.setrecursionlimit(10**6)
a,b,x = map(int, input().split())
import numpy as np
if x/a > a*b/2:
n = 2*x/(a**2) - b
theta = np.arctan((b-n)/a) # radian表記なので戻り値の範囲は[-pi/2, pi/2]
theta = np.rad2deg(theta)
else:
n = 2*x/(a*b)
theta = np.arctan(b/n)
theta = np.rad2deg(theta)
print(theta) | N,P=map(int,input().split())
S=input()
list=[0 for _ in range(P)]
list[0]=1
now=0
a=0
if P==2 or P==5:
M=len(S)
S=reversed(S)
l=0
for s in S:
if int(s)%P==0:
a+=M-l
l+=1
else:
l+=1
print(a)
else:
b=1
h=0
for s in reversed(S):
h=h+b*int(s)
list[h%P]+=1
b=b*10%P
c=0
for i in range(len(list)):
c+=list[i]*(list[i]-1)/2
print(int(c)) | 0 | null | 110,881,697,996,960 | 289 | 205 |
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N = II()
A = LI()
memo = {}
ans = 0
for i, a in enumerate(A):
i = i + 1
# print(i, a - i, i - a)
ans = ans + memo.get(i - a, 0)
memo[a + i] = memo.get(a + i, 0) + 1
print(ans)
if __name__ == '__main__':
solve()
| A, B, C, K = map(int, input().split())
# 1:A枚, 0:B枚, -1:C枚, K枚を選ぶ
A = min(A, K)
B = min(K - A, B)
C = min(K - A - B, C)
assert A + B + C >= K
#print(A, B, C)
print(A - C) | 0 | null | 24,029,323,774,784 | 157 | 148 |
n,m = map(int,input().split())
a = list(map(int,input().split()))
ans = 0
if sum(a) >n:
ans = -1
else:
ans = n-sum(a)
print(ans) | import sys
import heapq
from decimal import Decimal
input = sys.stdin.readline
a, b, c = map(str, input().split())
root_a = Decimal(a)**Decimal('0.5')
root_b = Decimal(b)**Decimal('0.5')
root_c = Decimal(c)**Decimal('0.5')
if root_a + root_b < root_c:
print("Yes")
else:
print("No") | 0 | null | 41,985,557,440,640 | 168 | 197 |
import sys
sys.setrecursionlimit(10 ** 9)
n,m = map(int, input().split())
ab = []
c = [set() for i in range(n)]
for i in range(m):
a = list(map(int, input().split()))
a.sort()
x,y = a[0]-1,a[1]-1
c[x].add(y)
c[y].add(x)
def dfs(s):
if vis[s] == False:
ary.append(s)
vis[s] = True
for j in c[s]:
dfs(j)
vis = [False for i in range(n)]
ans= []
for i in range(n):
ary = []
dfs(i)
if len(ary) == 0:
continue
ans.append(len(ary))
print (len(ans)-1) | from collections import deque
def BFS(s):
q = deque()
q.append(s)
dist = [[10**10]*(W+2) for _ in range(H+2)]
dist[s[0]][s[1]] = 0
d = ((0,1),(0,-1),(1,0),(-1,0))
far = []
while len(q)>0:
i,j = q.popleft()
for di,dj in d:
if field[i+di][j+dj] == "." and dist[i+di][j+dj] == 10**10:
q.append([i+di,j+dj])
dist[i+di][j+dj] = dist[i][j]+1
res = dist[i][j]
return res
H,W = map(int,input().split())
field = ["#"*(W+2)]
field += ["#"+input()+"#" for _ in range(H)]
field += ["#"*(W+2)]
res = 0
for i in range(H+2):
for j in range(W+2):
if field[i][j] == ".":
s = [i,j]
res = max(res,BFS(s))
print(res) | 0 | null | 48,417,449,438,930 | 70 | 241 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
class UnionFind:
def __init__(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def makeSet(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parents[x] = y
self.length[y] += self.length[x]
else:
self.parents[y] = x
self.length[x] += self.length[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getLength(self, x):
x = self.find(x)
return self.length[x]
def isSameGroup(self, x, y):
return self.find(x) == self.find(y)
def main():
N, M, K = map(int, readline().split())
friend = [set() for _ in range(N)]
block = [set() for _ in range(N)]
uf = UnionFind(N)
for _ in range(M):
a, b = map(int, readline().split())
a-=1
b-=1
friend[a].add(b)
friend[b].add(a)
uf.unite(a, b)
for _ in range(K):
c, d = map(int, readline().split())
c-=1
d-=1
block[c].add(d)
block[d].add(c)
for i in range(N):
cnt = 0
for blk in block[i]:
if uf.isSameGroup(i, blk):
cnt += 1
ans = uf.getLength(i)-cnt-len(friend[i])-1
if i == N-1:
print(ans)
else:
print(ans, end=" ")
if __name__ == '__main__':
main() | # AC: 753 msec(Python3)
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.size = [1] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.find(self.par[x])
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.size[x] < self.size[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
return self.find(x) == self.find(y)
def get_size(self, x):
return self.size[self.find(x)]
def main():
N,M,K,*uv = map(int, read().split())
ab, cd = uv[:2*M], uv[2*M:]
uf = UnionFind(N)
friend = [[] for _ in range(N+1)]
for a, b in zip(*[iter(ab)]*2):
uf.unite(a, b)
friend[a].append(b)
friend[b].append(a)
ans = [uf.get_size(i) - 1 - len(friend[i]) for i in range(N+1)]
for c, d in zip(*[iter(cd)]*2):
if uf.is_same(c, d):
ans[c] -= 1
ans[d] -= 1
print(*ans[1:])
if __name__ == "__main__":
main()
| 1 | 61,767,662,616,092 | null | 209 | 209 |
N, M = map(int, input().split())
cnt = 0
l = 0
k = M
while cnt < M and k > 0:
print(l + 1, l + k + 1)
cnt += 1
l += 1
k -= 2
l = M + 1
k = M - 1
while cnt < M:
print(l + 1, l + k + 1)
cnt += 1
l += 1
k -= 2
| n,*a=map(int,open(0).read().split())
m=6**8
c=[0]*m
p=[1,1]+c[:]
for i in range(m):
if p[i]<1:
for j in range(i,m,i):p[j]=i
for a in a:
s={a}
while a!=p[a]:
s|={p[a]}
a//=p[a]
s|={a}
for i in s:c[i]+=1
print(('not','psaeitr'[max(c[2:])>1::2]+'wise')[max(c[2:])<n],'coprime') | 0 | null | 16,493,151,934,044 | 162 | 85 |
from string import ascii_lowercase
N = int(input())
ans = ['a']
for i in range(1, N):
ans2 = []
for a in ans:
for b in ascii_lowercase[:len(set(a)) + 1]:
ans2 += [a + b]
ans = ans2
print('\n'.join(ans))
| def penalty(day, last, c):
val = 0
for i in range(26):
val += c[i] * (day - last[i])
return val
d = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for _ in range(d)]
t = [int(input()) for _ in range(d)]
last = [-1]*26
ans = [0]*(d+1)
for day in range(d):
ans[day+1] = ans[day] + s[day][t[day]-1]
last[t[day]-1] = day
ans[day+1] -= penalty(day, last, c)
for v in ans[1:]:
print(v) | 0 | null | 31,045,110,635,306 | 198 | 114 |
N,M=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
from bisect import bisect_left
def isok(n):
sum=0
for i in range(N):
sum+=N-bisect_left(A,n-A[i])
return sum>=M
start,end=0,2*10**5+1
while end-start>1:
mid=(start+end)//2
if isok(mid):
start=mid
else:
end=mid
b=[A[0]]
for i in range(1,N):
b.append(b[-1]+A[i])
l=0
ans=0
bn=b[N-1]
for i in range(N):
a=bisect_left(A,start-A[i])
l+=N-a
if a>0:
ans+=A[i]*(N-a)+bn-b[a-1]
else:
ans+=A[i]*(N-a)+bn
ans-=start*(l-M)
print(ans) | import os
import sys
import numpy as np
def solve(N, M, A):
# n 以上上がる方法だけを試した時に、M 回以上の握手を行うことができるか
ok = 0
ng = 202020
while ok + 1 < ng:
c = ok+ng >> 1
cnt = 0
idx_A = N-1
for a1 in A:
while idx_A >= 0 and A[idx_A]+a1 < c:
idx_A -= 1
cnt += idx_A + 1
if cnt >= M:
ok = c
else:
ng = c
idx_A = N-1
cum_A = np.zeros(len(A)+1, dtype=np.int64)
cum_A[1:] = np.cumsum(A)
ans = 0
cnt = 0
for a1 in A:
while idx_A >= 0 and A[idx_A]+a1 < ok:
idx_A -= 1
cnt += idx_A + 1
ans += cum_A[idx_A+1] + (idx_A+1)*a1
ans -= (cnt-M) * ok
return ans
# >>> numba compile >>>
numba_config = [
[solve, "i8(i8,i8,i8[:])"],
]
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
vars()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
else:
from numba import njit
for func, signature in numba_config:
vars()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
# <<< numba compile <<<
def main():
N, M = map(int, input().split())
A = np.array(sorted(map(int, input().split()), reverse=True), dtype=np.int64)
ans = solve(N, M, A)
print(ans)
main()
| 1 | 108,243,650,602,580 | null | 252 | 252 |
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
q = int(input())
bc = [list(map(int, input().split())) for _ in range(q)]
cou = Counter(a)
s = sum(a)
for b, c in bc:
s = s + cou[b]*(c-b)
cou[c] += cou[b]
cou[b] = 0
print(s) | from collections import Counter
n = int(input())
a = list(map(int, input().split()))
q = int(input())
ans = sum(a)
count = Counter(a)
for _ in range(q):
b,c = map(int, input().split())
count[c] += count[b]
ans -= b*count[b]
ans += c*count[b]
count[b] = 0
print(ans) | 1 | 12,253,158,793,792 | null | 122 | 122 |
"""ABC174E diff: 1158
"""
N,K=map(int,input().split())
A=list(map(int, input().split()))
if K == 0:
print(max(A))
exit()
def f(x):
"""
K回以内のカットで全ての丸太の長さをX以下にできるか？
X: int
Return: bool
"""
cnt = 0
for a in A:
if a % x == 0:
cnt += a//x - 1
else:
cnt += a//x
if cnt <= K:
return True
else:
return False
left = 0
right = max(A) + 10
while right - left > 1:
mid = (left+right) // 2
if f(mid):
right = mid
else:
left = mid
print(right) | def solve():
N, K = map(int,input().split())
A = list(map(int,input().split()))
left = 0
right = 10 ** 9
while right - left > 1:
mid = (right+left) // 2
cnt = 0
for a in A:
cnt += (a-1) // mid
if cnt <= K:
right = mid
else:
left = mid
print(right)
if __name__ == '__main__':
solve()
| 1 | 6,510,709,141,022 | null | 99 | 99 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.