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
|
|---|---|---|---|---|---|---|
b = []
c = []
while True:
inp = input()
a = inp.split()
a[0] = int(a[0])
a[1] = int(a[1])
if a[0] == 0 and a[1] == 0:
break
else:
a.sort()
b.append(a[0])
c.append(a[1])
for i in range(len(b)):
print(b[i],c[i])
| N = int(input())
L = list(map(int, input().split()))
ans = 0
for i1 in range(N):
for i2 in range(i1, N):
for i3 in range(i2, N):
l1 = L[i1]
l2 = L[i2]
l3 = L[i3]
if l1 != l2 and l2 != l3 and l3 != l1:
if l1 < l2 + l3 and l2 < l3 + l1 and l3 < l1 + l2:
ans += 1
print(ans)
| 0 | null | 2,752,224,377,968 | 43 | 91 |
x,y=map(int,input().split());print('NYoe s'[x*2<=~y%2*y<=x*4::2]) | a,b,c=map(int,input().split())
if a>c:
print(a-c,b)
elif a<=c and b<=(c-a):
print(0,0)
else:
print(0,b-(c-a)) | 0 | null | 59,268,281,901,696 | 127 | 249 |
# B - Battle
# 入力 A B C D
A, B, C, D = map(int, input().split(maxsplit=4))
while True:
C -= B
if C <= 0:
answer = 'Yes'
break
A -= D
if A <= 0:
answer = 'No'
break
print(answer)
| a,b,c = [int(s) for s in input().split(" ")]
if a < b and b < c:
print("Yes")
else:
print("No") | 0 | null | 15,151,386,540,382 | 164 | 39 |
inf = 10**9 + 7
def merge(A, left, mid, right):
cnt = 0
L = A[left:mid]
R = A[mid:right]
L.append(inf)
R.append(inf)
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
return cnt
def merge_sort(A, left, right):
cnt = 0
if left + 1 < right:
mid = (left + right) // 2
cnt += merge_sort(A, left, mid)
cnt += merge_sort(A, mid, right)
cnt += merge(A, left, mid, right)
return cnt
n = int(input())
*A, = map(int, input().split())
cnt = merge_sort(A, 0, n)
print(*A)
print(cnt)
| def main():
n = int(input())
even = n // 2
print(1 - even / n)
if __name__ == "__main__":
main()
| 0 | null | 88,829,849,512,392 | 26 | 297 |
a = int(raw_input())
print str(a*a*a) | x = input()
print str(x*x*x) | 1 | 285,089,979,884 | null | 35 | 35 |
import sys
sys.setrecursionlimit(10**5)
N,u,v=map(int,input().split())
du,dv=[0]*-~N,[0]*-~N
T=[list() for i in range(-~N)]
def dfs(p,t,v,d):
d[v]=t
for i in T[v]:
if i!=p:
dfs(v,t+1,i,d)
for i in range(N-1):
a,b=map(int,input().split())
T[a].append(b)
T[b].append(a)
dfs(0,0,u,du)
dfs(0,0,v,dv)
c=0
for i in range(1,-~N):
if len(T[i])==1 and i!=v:
if du[i]<dv[i]:
c=max(c,~-dv[i])
print(c)
| def main():
a, b, c = map(int, input().split())
ans = 0
for i in range(a, b + 1):
d = c % i
if d == 0:
ans += 1
print(ans)
if __name__ == "__main__":
main() | 0 | null | 59,292,976,409,938 | 259 | 44 |
A,B=map(int,input().split())
if B < A:
A,B=B,A
for i in range(B):
print(A, end="")
print() | n,k,c = map(int,input().split())
S = input()
mae = []
ushiro = []
cur_1 = 0
temp_1 = 0
cur_2 = 0
temp_2 = 0
ans = []
for i in range(n):
if S[i] == 'o' and temp_1 == 0:
mae.append(i)
cur_1 += 1
temp_1 = c
else:
temp_1 = max(temp_1-1,0)
if cur_1 == k:
break
for i in range(n):
if S[n-i-1] == 'o' and temp_2 == 0:
ushiro.append(n-i-1)
cur_2 += 1
temp_2 = c
else:
temp_2 = max(temp_2-1,0)
if cur_2 == k:
break
for i in range(k):
if mae[len(mae)-1-i] == ushiro[i]:
ans.append(ushiro[i]+1)
if len(ans) == 0:
None
else:
ans.reverse()
for i in range(len(ans)):
print(ans[i])
| 0 | null | 62,741,330,223,040 | 232 | 182 |
tarop = hanakop = 0
for i in range(int(input())):
taro, hanako = input().split()
if taro > hanako:
tarop += 3
elif taro < hanako:
hanakop += 3
else:
tarop += 1
hanakop += 1
print(tarop, hanakop) | import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
import bisect
if __name__ == "__main__":
n,x,y = map(int,input().split())
x-=1
y-=1
ans = [0]*(n)
for i in range(n):
for j in range(i+1,n):
d = min(abs(i-j),abs(x-i) + abs(y-j) + 1)
ans[d] += 1
for i in range(1,n):
print(ans[i]) | 0 | null | 23,054,353,948,472 | 67 | 187 |
def main():
S = input()
# my swapcase
for s in S:
o = ord(s)
if 97 <= o < 97 + 26:
o -= 32
elif 65 <= o < 65 + 26:
o += 32
print(chr(o), end="")
print("")
if __name__ == "__main__":
main() | str = raw_input()
li = []
for c in list(str):
if c.isupper():
li.append(c.lower())
elif c.islower():
li.append(c.upper())
else:
li.append(c)
print ''.join(li) | 1 | 1,500,135,578,838 | null | 61 | 61 |
n=int(input())
ans=0
for i in range(1,50000+1):
z=i*1.08
if n<=z<(n+1):
ans=i
break
if ans==0:
print(":(")
else:
print(ans)
| n = int(input())
r = n % 27
if r == 13 or r == 26:
print(':(')
elif r ==0:
x = int(100*n/108)
print(x)
else:
for i in range(1, 25):
if 1.08*(i-1) < r <= 1.08*i:
break
x = int(100*(n - i)/108) + i
print(x) | 1 | 125,780,998,610,080 | null | 265 | 265 |
n, q = map(int, input().split())
p = [input().split() for _ in range(n)]
t = i = 0
while n:
i = i % n
if int(p[i][1]) <= q:
t += int(p[i][1])
print(p[i][0], t)
del p[i]
n -= 1
else:
p[i][1] = int(p[i][1]) - q
t += q
i += 1 | def isStable(inlist, outlist):
flag = True
for i in range(0, N):
for j in range(i+1, N):
for a in range(0, N):
for b in range(a+1, N):
if int(inlist[i][1:]) == int(inlist[j][1:]) and inlist[i] == outlist[b] and inlist[j] == outlist[a]:
flag = False
break
else:
continue
break
else:
continue
break
else:
continue
break
return(flag)
N = int(input())
A = input().split()
B = A[:]
C = A[:]
flag = 1
counter = 0
while flag:
flag = 0
for i in reversed(range(1,N)):
if int(C[i][1:]) < int(C[i-1][1:]):
C[i], C[i-1] = C[i-1], C[i]
counter += 1
flag = 1
print(" ".join(map(str, C)))
if(isStable(A, C)):
print("Stable")
else:
print("Not stable")
counter=0
for i in range(N):
Br = B[i:]
Brr = [int(Br[j][1:]) for j in range(N-i)]
num = Brr.index(min(Brr))
if num != 0:
B[i], B[(i+num)] = B[(i+num)], B[i]
counter += 1
print(" ".join(map(str,B)))
if(isStable(A, B)):
print("Stable")
else:
print("Not stable") | 0 | null | 33,418,813,230 | 19 | 16 |
from collections import defaultdict
N = int(input())
if N == 1:
print(0)
exit()
p = defaultdict(int)
while N % 2 == 0:
p[2] += 1
N //= 2
f = 3
while f * f <= N:
if N % f == 0:
p[f] += 1
N //= f
else:
f += 2
if N != 1:
p[N] += 1
ans = 0
for v in p.values():
n = 1
i = 1
while n <= v:
ans += 1
i += 1
n += i
print(ans) | def factorization(n):
if n==1:
return [[1,1]]
temp=n
ans=[]
for i in range(2, int(n**0.5+1.01)):
if temp % i ==0:
ct=0
while temp % i == 0:
temp //= i
ct += 1
ans.append([i, ct])
if temp != 1:
ans.append([temp, 1])
return ans
N=int(input())
L=factorization(N)
if N==1:
print(0)
exit()
ans=0
for l in L:
ct=0
fac=1
while fac<=l[1]:
ct+=1
fac+=ct+1
ans+=ct
print(ans) | 1 | 16,787,799,110,980 | null | 136 | 136 |
import sys
input=sys.stdin.readline
inf=10**9+7
n,m,l=map(int,input().split())
D=[[inf]*(n+1) for _ in range(n+1)]
for _ in range(m):
a,b,c=map(int,input().split())
D[a][b]=c
D[b][a]=c
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
D[i][j]=min(D[i][j],D[i][k]+D[k][j])
DD=[[inf]*(n+1) for _ in range(n+1)]
for x in range(1,n+1):
for y in range(1,n+1):
if D[x][y]<=l:
DD[x][y]=1
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
DD[i][j]=min(DD[i][j],DD[i][k]+DD[k][j])
q=int(input())
for _ in range(q):
s,t=map(int,input().split())
if DD[s][t]==inf:
print(-1)
else:
print(DD[s][t]-1) | from sys import stdin
readline = stdin.buffer.readline
def r_map(): return map(int, readline().rstrip().split())
def r_list(): return list(r_map())
def main():
N = int(readline().rstrip())
A = r_list()
M = max(A)
d = [0] * (M + 1)
g = True
for a in A:
d[a] += 1
for i in range(2, M + 1):
c = sum(d[i::i])
if c == N:
print("not coprime")
exit()
elif c > 1:
g = False
if g:
print('pairwise coprime')
else:
print('setwise coprime')
if __name__ == "__main__":
main()
| 0 | null | 88,490,973,166,810 | 295 | 85 |
def main():
n = int(input())
t = (n+1) // 2
if n == 1:
print(1)
elif n % 2 == 0:
print(0.5)
else:
print(t*1.0 / n)
main() | N = int(input())
if N == 1:
print(1)
elif N%2 == 0:
print(0.5)
else:
print((N+1)/2/N) | 1 | 177,159,351,721,482 | null | 297 | 297 |
n, m = map(int, input().split())
a = list(map(int, input().split()))
num1 = a[0]
num2 = 0
while num1 % 2 == 0:
num1 //= 2
num2 += 1
gc = 2 ** num2
b = []
for i in a:
if i % gc != 0 or (i // gc) % 2 == 0:
print(0)
exit()
else:
b.append(i // gc)
from fractions import gcd
lcm = 1
for i in b:
lcm = (lcm * i) // gcd(lcm, i)
ans = m // (lcm * (gc // 2))
ans = (ans + 1) // 2
print(ans) | from math import gcd
def lcm(a, b):
return a * b // gcd(a, b)
n, m = map(int, input().split())
a = list(map(int, input().split()))
l = [0] * n
for i in range(n):
tmp = a[i]
while tmp % 2 == 0:
tmp //= 2
l[i] += 1
if i > 0 and l[i] != l[i - 1]:
print(0)
exit(0)
res = 1
for i in range(n):
res = lcm(res, a[i] // 2)
print(m // res - m // (res * 2))
| 1 | 101,692,554,236,790 | null | 247 | 247 |
n = input()
s = []
h = []
c = []
d = []
for i in range(n):
spare = raw_input().split()
if spare[0]=='S':
s.append(int(spare[1]))
elif spare[0]=='H':
h.append(int(spare[1]))
elif spare[0]=='C':
c.append(int(spare[1]))
else :
d.append(int(spare[1]))
for j in range(1,14):
judge = True
for k in range(len(s)):
if j==s[k] :
judge = False
break
if judge :
print 'S %d' %j
for j in range(1,14):
judge = True
for k in range(len(h)):
if j==h[k] :
judge = False
break
if judge :
print 'H %d' %j
for j in range(1,14):
judge = True
for k in range(len(c)):
if j==c[k] :
judge = False
break
if judge :
print 'C %d' %j
for j in range(1,14):
judge = True
for k in range(len(d)):
if j==d[k] :
judge = False
break
if judge :
print 'D %d' %j | import math
cnt=0
n=int(input())
for i in range(1,n+1):
for j in range(1,n+1):
wk=math.gcd(i,j)
for k in range(1,n+1):
cnt+=math.gcd(wk,k)
print(cnt) | 0 | null | 18,417,957,448,152 | 54 | 174 |
from collections import defaultdict
N, X, M = map(int, input().split())
A = [X]
visited = set()
visited.add(X)
idx = defaultdict()
idx[X] = 0
iii = -1
for i in range(1, M):
tmp = (A[-1]**2) % M
if tmp not in visited:
A.append(tmp)
visited.add(tmp)
idx[tmp] = i
else:
iii = idx[tmp]
ans = 0
if iii == -1:
ans = sum(A[:N])
print(ans)
exit()
else:
# ループの頭の直前まで
ans += sum(A[:iii])
N -= iii
if N > 0:
# ループの長さ
l = len(A) - iii
ans += (N // l) * sum(A[iii:])
N -= N // l * l
if N > 0:
# ループに満たないN
ans += sum(A[iii:iii + N])
print(ans)
| N, X, M = map(int, input().split())
visited = [False] * M
tmp = X
total_sum = X
visited[tmp] = True
total_len = 1
while True:
tmp = (tmp ** 2) % M
if visited[tmp]:
loop_start_num = tmp
break
total_sum += tmp
visited[tmp] = True
total_len += 1
path_len = 0
tmp = X
path_sum = 0
while True:
if tmp == loop_start_num:
break
path_len += 1
path_sum += tmp
tmp = (tmp ** 2) % M
loop_len = total_len - path_len
loop_sum = total_sum - path_sum
result = 0
if N <= path_len:
tmp = X
for i in range(N):
result += X
tmp = (tmp ** 2) % M
print(result)
else:
result = path_sum
N -= path_len
loops_count = N // loop_len
loop_rem = N % loop_len
result += loop_sum * loops_count
tmp = loop_start_num
for i in range(loop_rem):
result += tmp
tmp = (tmp ** 2) % M
print(result)
# print("loop_start_num", loop_start_num)
# print("path_sum", path_sum)
# print("loop_sum", loop_sum)
| 1 | 2,793,780,576,110 | null | 75 | 75 |
class Main:
S = input()
if S[-1] == 's':
print(S+'es')
else :
print(S+'s') | s=input()
if(s[-1]=='s'):
s=s+"es"
print(s)
else:
s=s+"s"
print(s) | 1 | 2,418,301,502,474 | null | 71 | 71 |
n = int(input())
cout = ""
for i in range(1,n+1):
x = i
if x%3 == 0:
cout += " " + str(i)
else:
while x > 0:
if x%10 == 3:
cout += " " + str(i)
break
x //= 10
print (cout) | n = int(input())
nums = []
for i in range(3, n + 1):
if i % 3 == 0 or i % 10 == 3 or '3' in str(i):
#print('',i,end='')
nums.append(i)
for i in nums:
print('',i,end='')
print() | 1 | 930,450,703,208 | null | 52 | 52 |
N = int(input())
A = []
xy = []
for i in range(N):
a = int(input())
A.append(a)
xy.append([list(map(int, input().split())) for j in range(a)])
ans = 0
p = [-1]*N
def dfs(i, p):
global ans
if i == N:
ans = max(ans, sum(p))
else:
p_true = p.copy()
if p_true[i] != 0:
p_true[i] = 1
ok = True
for x, y in xy[i]:
if y == p_true[x-1] or p_true[x-1] == -1:
p_true[x-1] = y
else:
ok = False
if ok:
dfs(i+1, p_true)
p_false = p.copy()
if p_false[i] != 1:
p_false[i] = 0
dfs(i+1, p_false)
dfs(0, p)
print(ans)
| from collections import defaultdict,deque
n = int(input())
d = defaultdict(list)
for i in range(n):
a = int(input())
for j in range(a):
x,y = map(int,input().split())
d[i].append((x-1,bool(y)))
maxi = 0
for i in range(2 ** n):
honest = [-1]*n
que = deque([])
for j in range(n):
if ((i >> j) & 1):
que.append(n-1-j)
honest[n-1-j] = True
flag = True
while que and flag:
v = que.popleft()
for x,y in d[v]:
if honest[x] == -1:
honest[x] = y
if y:
que.append(x)
elif honest[x] != y:
flag = False
break
if flag:
maxi = max(maxi,str(bin(i)).count('1'))
print(maxi) | 1 | 121,425,057,542,052 | null | 262 | 262 |
A,B=map(int,input().split())
import math
a=math.gcd(A,B)
ans=A*B//a
print(ans) | import os, sys, re, math
from functools import reduce
def lcm(vals):
return reduce((lambda x, y: (x * y) // math.gcd(x, y)), vals, 1)
(A, B) = [int(n) for n in input().split()]
print(lcm([A, B]))
| 1 | 113,387,847,877,024 | null | 256 | 256 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,k,s = map(int, input().split())
if s==10**9:
a = [10**9]*k + [1]*(n-k)
else:
a = [s]*k + [s+1]*(n-k)
print(" ".join(map(str, a))) | R, C, K = map(int, input().split())
item = {}
for _ in range(K):
r, c, v = map(int, input().split())
item[(r, c)] = v
dp = [[0] * 4 for _ in range(3010)]
ndp = [[0] * 4 for _ in range(3010)]
for r in range(1, R+1):
for c in range(1, C+1):
prer = max(dp[c])
ndp[c][0] = max(prer, ndp[c-1][0])
ndp[c][1] = max(prer, ndp[c-1][1])
ndp[c][2] = max(prer, ndp[c-1][2])
ndp[c][3] = max(prer, ndp[c-1][3])
if item.get((r, c)):
ndp[c][1] = max(ndp[c][1], max(prer, ndp[c-1][0]) + item[(r,c)])
ndp[c][2] = max(ndp[c][2], max(prer, ndp[c-1][1]) + item[(r,c)])
ndp[c][3] = max(ndp[c][3], max(prer, ndp[c-1][2]) + item[(r,c)])
dp = ndp
ndp = [[0] * 4 for _ in range(3010)]
#print(dp)
print(max(dp[C]))
| 0 | null | 48,218,889,778,332 | 238 | 94 |
n,x,y = map(int, input().split())
lis = [0] * n
x -= 1
y -= 1
for i in range(n):
for j in range(i+1, n):
t = min(abs(i-j), abs(i-x)+abs(j-y)+1,abs(i-y)+abs(j-x)+1)
lis[t] += 1
for i in range(1,n):
print(lis[i]) | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
N = int(readline())
def enum_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)
return divisors
divs = enum_divisors(N)
ans = INF
for div1 in divs:
div2 = N // div1
score = (div1 + div2 - 2)
ans = min(score, ans)
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 103,010,085,424,330 | 187 | 288 |
from collections import deque
h,w = map(int, input().split())
hw = [input() for _ in range(h)]
def bfs(s):
que = deque([s])
m = [[-1]*w for _ in range(h)]
sh, sw = s
m[sh][sw] = 0
ret = 0
while que:
now_h, now_w = que.popleft()
for dh, dw in [(1,0), (-1,0), (0,-1), (0,1)]:
nh = now_h + dh
nw = now_w + dw
if not (0<=nh<h and 0<=nw<w) or m[nh][nw] != -1 or hw[nh][nw] == '#':
continue
m[nh][nw] = m[now_h][now_w] + 1
que.append((nh,nw))
ret = max(ret, m[now_h][now_w] + 1)
return ret
ans = 0
for y in range(h):
for x in range(w):
if hw[y][x] == '#':
continue
s = (y, x)
ans = max(bfs(s), ans)
print(ans) | from collections import deque
m=[[1,0],[-1,0],[0,1],[0,-1]]
h,w=map(int,input().split())
l=list()
l.append('#'*(w+2))
for i in range(h):
j=input()
l.append('#'+j+'#')
l.append('#'*(w+2))
def bfs(a,b):
s=[[-1 for j in i] for i in l]
s[a][b]=0
q=deque([[a,b]])
while len(q)>0:
x,y=q.popleft()
for i,j in m:
if l[x+i][y+j]=='.' and s[x+i][y+j]==-1:
q.append([x+i,y+j])
s[x+i][y+j]=s[x][y]+1
num = s[x+i][y+j]
return num
ans = []
for i in range(h+2):
for j in range(w+2):
if l[i][j] == '.':
ans.append(bfs(i,j))
print(max(ans)) | 1 | 94,405,101,204,440 | null | 241 | 241 |
while True:
a,op,b=input().split(" ")
a,b=[int(i) for i in (a,b)]
if op=="+":
print(a+b)
elif op=="-":
print(a-b)
elif op=="*":
print(a*b)
elif op=="/":
print(int(a/b))
else:
break | '''
ITP-1_4-C
?¨???????
???????????´??° a, b ??¨?????????????????? op ?????????????????§???a op b ????¨??????????????????°?????????????????????????????????
????????????????????? op ??????"+"(???)???"-"(???)???"*"(???)???"/"(???)???????????¨?????????????????§????????????????????´?????????
?°???°?????\??????????????¨????????????????¨????????????¨????????????
???Input
??\???????????°????????????????????????????§???????????????????????????????????????????????????¢????????\????????¨????????§??????
a op b
op ??? '?' ?????¨??? ??\?????????????????????????????????????????±???????????????????????£????????????????????????
???Output
?????????????????????????????????????¨??????????????????????????????????????????????
'''
# import
import sys
# ?????°??????????????????
for inputData in sys.stdin:
inputList = inputData.split()
a, op, b = int(inputList[0]), inputList[1], int(inputList[2])
retVal = 0
# 0?????´??? ????????????
if op == '?':
# exec end
break
elif op == '+':
retVal = a + b
elif op == '-':
retVal = a - b
elif op == '*':
retVal = a * b
elif op == '/':
retVal = a // b
else:
retVal = 0
# ????????????
print(retVal) | 1 | 694,274,473,760 | null | 47 | 47 |
N = int(input())
S = list(input())
ans = 'No'
n = int(N / 2)
if S[:n] == S[n:]:
ans = 'Yes'
print(ans) | n = int(input())
s = input()
if n%2 != 0 or s[:n//2] != s[n//2:]:
print("No")
else:
print("Yes") | 1 | 146,342,007,114,900 | null | 279 | 279 |
import sys
from collections import deque
N, M = map(int, input().split())
edge = [[] for _ in range(N)]
for s in sys.stdin.readlines():
a, b = map(lambda x: int(x) - 1, s.split())
edge[a].append(b)
edge[b].append(a)
path = [0] * N
cnt = 0
for i in range(N):
if path[i] == 0:
cnt += 1
q = deque()
path[i] = 1
q.append(i)
while q:
p = q.popleft()
for np in edge[p]:
if path[np] == 0:
path[np] = 1
q.append(np)
print(cnt - 1)
| class UnionFind:
"""
class UnionFind
https://note.nkmk.me/python-union-find/
order O(log(n))
n = the number of elements
parents = the list that contains "parents" of x. be careful that it doesn't contain "root" of x.
"""
def __init__(self, n):
"""
make UnionFind
:param n: the number of elements
"""
self.n = n
self.parents = [-1] * n
def find(self, x):
"""
:param x: an element
:return: the root containing 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):
"""
:param x, y: an element
"""
# root
x = self.find(x)
y = self.find(y)
if x == y:
# already same group so do nothing
return
if self.parents[x] > self.parents[y]:
# the root should be min of group
x, y = y, x
# remind that x, y is the root, x < y, then, y unions to x.
self.parents[x] += self.parents[y]
# and then y's parent is x.
self.parents[y] = x
def size(self, x):
# return the size of group
return -self.parents[self.find(x)]
def same(self, x, y):
# return whether the x, y are in same group
return self.find(x) == self.find(y)
def members(self, x):
# return members of group
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
# return all roots
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
# return how many groups
return len(self.roots())
def all_group_members(self):
# return all members of all groups
return {r: self.members(r) for r in self.roots()}
n,m= map(int,input().split())
union = UnionFind(n)
for i in range(m):
a,b = map(int,input().split())
union.union(a-1,b-1)
print(union.group_count()-1) | 1 | 2,309,971,117,048 | null | 70 | 70 |
from collections import Counter
n=int(input())
a=list(map(int,input().split()))
i_l=[]
j_l=[]
for i in range(n):
i_l.append(i+a[i])
j_l.append(i-a[i])
ci=Counter(i_l)
cl=Counter(j_l)
ans=0
for k,v in ci.items():
ans+=v*cl[k]
print(ans) | from collections import defaultdict
n = int(input())
a = list(map(int, input().split()))
memo = defaultdict(int)
ans = 0
for i, x in enumerate(a, 1):
ans += memo[i - x]
memo[x + i] += 1
print(ans)
| 1 | 25,959,087,518,018 | null | 157 | 157 |
import math
X=int(input())
def ans165(X:int):
cash=100#当初の預金額
count=0
while True:
# cash=int(cash*1.01) #元本に１パーセントの利子をつけ小数点以下切り捨て # WA
# cash = cash * 1.01 * 100 // 100 # 1%の利子をつけて100倍した後に100で割って整数部のみ取り出す # WA
# cash += cash * 0.01 * 100 // 100 # 1%の利子を計算して100倍した後に100で割って整数部のみ取り出す # WA
# cash += cash // 100 # 元本に100で割った整数部を足す # AC
# cash += math.floor(cash * 0.01) # WA
# cash += math.floor(cash / 100) # WA
cash += math.floor(cash // 100) # WA
count += 1#利子をつける回数だけcountを増やす
if cash>=X:#cashがXの値以上になったらループ終了
break
return count
print(ans165(X)) | x = int(input())
r = 100
ans = 0
while r < x:
r = int(r * 101)//100
ans += 1
print(ans)
| 1 | 26,864,110,522,238 | null | 159 | 159 |
import sys
line = sys.stdin.readline()
str_a, str_b = line.split(" ")
a = int(str_a)
b = int(str_b)
if a > b:
c = ">"
elif a < b:
c = "<"
else:
c = "=="
print "a %s b" % (c) | inf = 1100000
def main():
N = int(input())
a = list(map(int, input().split()))
a.sort()
detect = [0] *inf
for x in a:
if detect[x] != 0:
detect[x] = 2
continue
for i in range(x, inf, x):
detect[i] += 1
ans = 0
for i in range(N):
if detect[a[i]] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main() | 0 | null | 7,467,679,747,142 | 38 | 129 |
n=int(input())
l=list(map(int,input().split()))
l.sort()
count=0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if l[i]+l[j]>l[k] and l[i]!=l[j] and l[j]!=l[k] and l[i]!=l[k]:
count+=1
print(count)
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from itertools import combinations
def main():
n, *a = map(int, read().split())
coma = combinations(a, 3)
r = 0
for c in coma:
if sum(c) > max(c)*2:
if len(set(c)) > 2:
r += 1
print(r)
if __name__ == '__main__':
main()
| 1 | 5,065,394,373,020 | null | 91 | 91 |
import sys
input = sys.stdin.readline
x, y = [int(x) for x in input().split()]
ans = 0
for i in [x, y]:
if i == 1:
ans += 300000
elif i == 2:
ans += 200000
elif i == 3:
ans += 100000
if x == 1 and y == 1:
ans += 400000
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
check = list(map(int, readline().split()))
prize = [3 * 10 ** 5, 2 * 10 ** 5, 10 ** 5]
ans = 0
if check.count(1) == 2:
ans = 10 ** 6
else:
if check[0] <= 3:
ans += prize[check[0] - 1]
if check[1] <= 3:
ans += prize[check[1] - 1]
print(ans)
| 1 | 140,798,602,811,438 | null | 275 | 275 |
n = int(input())
memo = [0 for _ in range(45)]
def fib_memo(n):
if memo[n] != 0:
return memo[n]
elif (n == 0) or (n == 1):
return 1
else:
memo[n] = fib_memo(n-1) + fib_memo(n-2)
return memo[n]
print(fib_memo(n)) | #coding:utf-8
n = int(input())
numbers = list(map(int, input().split()))
count = 0
for i in range(n-1):
for j in range(n-1, i, -1):
if numbers[j] < numbers[j-1]:
numbers[j], numbers[j-1] = numbers[j-1], numbers[j]
count += 1
print(*numbers)
print(count) | 0 | null | 10,094,660,160 | 7 | 14 |
s = input()
k = 0
for i in range(len(s) // 2):
if s[i] == s[len(s) - i -1]:
next
else:
k += 1
print(k) | S=input()
nick_name=S[0:3]
print(nick_name) | 0 | null | 67,677,686,121,020 | 261 | 130 |
N = int(input())
for i in range(11):
b = i * 1000
c = b - N
if c >= 0:
break
print(c) |
def gen_factorization(N):
tables=[-1]*(N+1)
for i in range(2,N+1):
if tables[i]!=-1:continue
tmp=i
while tmp<=N:
tables[tmp]=i
tmp+=i
def fuctorization(n):
if n==1:return {1:1}
elif n<0:n=abs(n)
if n>N:return "error"
ans={}
while n!=1:
tmp=tables[n]
#debug print
#print(tmp,n)
ans.setdefault(tmp,0)
ans[tmp]+=1
n//=tmp
return ans
return fuctorization
N=int(input())
f=gen_factorization(10**6+10)
A=list(map(int,input().split()))
primes={}
for i in A:
d=f(i)
for j in d:
primes.setdefault(j,0)
primes[j]+=1
primes[1]=1
ansMax=max(primes.values())
if ansMax==1:
print('pairwise coprime')
elif ansMax==N:
print('not coprime')
else:
print('setwise coprime') | 0 | null | 6,290,587,397,600 | 108 | 85 |
haveTrumps = [[0 for i in range(13)] for j in range(4)]
allCards = int(input())
for i in range(0, allCards):
cardType, cardNum = input().split()
if cardType == "S":
haveTrumps[0][int(cardNum) - 1] = 1
elif cardType == "H":
haveTrumps[1][int(cardNum) - 1] = 1
elif cardType == "C":
haveTrumps[2][int(cardNum) - 1] = 1
elif cardType == "D":
haveTrumps[3][int(cardNum) - 1] = 1
for i in range(0, 4):
for j in range(0, 13):
if haveTrumps[i][j] == 0:
if i == 0:
print("S ", end="")
elif i == 1:
print("H ", end="")
elif i == 2:
print("C ", end="")
elif i == 3:
print("D ", end="")
print("{0}".format(j + 1)) | #!/usr/bin/env python3
def main():
N = int(input())
A = [int(x) for x in input().split()]
lst = [0] * (N + 1)
for a in A:
lst[a] += 1
for i in lst[1:]:
print(i)
if __name__ == '__main__':
main()
| 0 | null | 16,879,141,068,360 | 54 | 169 |
from sys import exit
from itertools import accumulate,chain
n,*s=open(0).read().split()
t=[2*i.count("(")-len(i) for i in s]
if sum(t)!=0:
print("No");exit()
st=[[min(accumulate(s_,lambda a,b: a+(1 if b=="(" else -1),initial=0)),t_] for s_,t_ in zip(s,t)]
now=0
for c in chain(sorted([x for x in st if x[1]>=0])[::-1],sorted([x for x in st if x[1]<0],key=lambda z:z[1]-z[0])[::-1]):
if now+c[0]<0:
print("No");exit()
now+=c[1]
print("Yes") | def main():
n = int(input())
Ss = [input() for _ in range(n)]
U = [[0, 0] for _ in range(n)]
for i in range(n):
for c in Ss[i]:
if c == "(":
U[i][1] += 1
else:
if U[i][1] == 0:
U[i][0] += 1
else:
U[i][1] -= 1
L, R = 0, 0
P = []
for i in range(n):
if U[i][0] == 0 and U[i][1] > 0:
L += U[i][1]
elif U[i][0] > 0 and U[i][1] == 0:
R += U[i][0]
elif U[i][0] > 0 and U[i][1] > 0:
P.append([U[i][0], U[i][1]])
P.sort(key=lambda x: (x[0]-x[1], x[0], -x[1]))
if L == 0 and R == 0 and len(P) == 0:
print("Yes")
elif (L == 0 or R == 0) and len(P) > 0:
print("No")
else:
f = True
for i in range(len(P)):
L -= P[i][0]
if L < 0:
f = False
break
L += P[i][1]
if L == R and f:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main() | 1 | 23,673,956,140,220 | null | 152 | 152 |
from collections import deque
n, d, a = map(int, input().split())
XH = [list(map(int, input().split())) for _ in range(n)]
XH.sort()
# X:座標、 C:倒すための必要爆発回数
XC = [[x, (h - 1) // a + 1] for x, h in XH]
q = deque([])
accum_dmg = 0
ans = 0
for x, c in XC:
# q[-][0]は爆発が届く右端の座標
# 爆発が届いていない地点に来たら累積ダメージを減らす
while q and x > q[0][0]:
_, dmg = q.popleft()
accum_dmg -= dmg
cnt = max(0, c - accum_dmg)
ans += cnt
accum_dmg += cnt
if cnt:
q.append([x + 2 * d, cnt])
print(ans) | import sys
read = sys.stdin.buffer.read
def main():
N, D, A, *XH = map(int, read().split())
monster = [0] * N
for i, (x, h) in enumerate(zip(*[iter(XH)] * 2)):
monster[i] = (x, (h + A - 1) // A)
monster.sort()
X = [x for x, h in monster]
S = [0] * (N + 1)
idx = 0
ans = 0
for i, (x, h) in enumerate(monster):
d = h - S[i]
if d > 0:
right = x + 2 * D
while idx < N and X[idx] <= right:
idx += 1
S[i] += d
S[idx] -= d
ans += d
S[i + 1] += S[i]
print(ans)
return
if __name__ == '__main__':
main()
| 1 | 81,916,819,248,890 | null | 230 | 230 |
C = 500
K, X = map(int, input().split())
if C*K >= X:
print("Yes")
else:
print("No") | #template
from sys import setrecursionlimit
setrecursionlimit(10**6)
from collections import Counter
def inputlist(): return [int(i) for i in input().split()]
#template
li = ['hi','hihi','hihihi','hihihihi','hihihihihi']
S = input()
if S in li:
print("Yes")
else:
print("No") | 0 | null | 75,446,337,063,678 | 244 | 199 |
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()
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()
sys.setrecursionlimit(10**6)
n = ni()
a = na()
b = []
for i in range(n):
b.append((a[i],i))
b.sort(reverse=True)
dp = [[0]*(n+1) for i in range(n+1)]
for i in range(1,n+1):
x,y = b[i-1]
for j in range(i+1):
left = dp[i-1][j-1] + x*abs(y-j+1) if j > 0 else -1
right = dp[i-1][j] + x*abs(n-i+j-y) if j < i else -1
dp[i][j] = max(left,right)
print(max(dp[-1])) | 1 | 33,757,387,851,810 | null | 171 | 171 |
S, T = input().split()
print(T + S) | n = int(input())
if n%2 == 1:
print (0)
exit()
cnt = 0
for i in range(1,26):
x = pow(5,i)
x *= 2
if x > n:
continue
cnt += n//x
print (cnt) | 0 | null | 109,561,369,499,010 | 248 | 258 |
import bisect
import itertools
import numpy as np
def search_cut(N, M, A):
high_cut = A[-1] * 2
low_cut = A[0] * 2
while high_cut > low_cut + 1:
mid = (high_cut + low_cut) // 2
count = (N - np.searchsorted(A, mid - A, side = 'left')).sum()
if count > M:
low_cut = mid
else:
high_cut = mid
return low_cut, high_cut
def happiness(N, M, A, low_cut, high_cut):
A_sum = np.zeros(N + 1)
A_sum[1:] = np.cumsum(A)
X = np.searchsorted(A, high_cut - A, side = 'left')
happiness = (A_sum[-1] - A_sum[X]).sum()
happiness += ((N - X) * A).sum()
happiness += (M - (N - X).sum()) * low_cut
return int(happiness)
N, M = map(int, input().split())
A = np.array(list(map(int, input().split())))
A = np.sort(A)
low_cut, high_cut = search_cut(N, M, A)
ans = happiness(N, M, A, low_cut, high_cut)
print(ans)
| from bisect import bisect_left
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
def get_count(tot):
'''
tot以上を満たす幸福度の握手の個数を数える
'''
ret = 0
for i in range(N):
cnt = bisect_left(A, tot-A[i])
ret += N - cnt
return ret
# 右からの累積和
Asum = A[:]
for i in range(N-2, -1, -1):
Asum[i] += Asum[i+1]
def get_sum(tot):
'''
左端を固定した時の右端の個数分だけ左端を足し、右端の区間和（累積和）も足す。
'''
ret = 0
for i in range(N):
idx = bisect_left(A, tot-A[i])
cnt = N - idx
ret += A[i]*cnt
# print(idx)
if idx == N:
continue
ret += Asum[idx]
# print(f'ret = {ret}')
return ret
# M回握手できる上限を求める
ok = 0
ng = 10**12
while ok + 1 != ng:
md = (ok + ng)//2
if M <= get_count(md):
ok = md
else:
ng = md
# print(ok)
# print(get_sum(ok+1))
# print(M - get_count(ok+1))
# print(Asum)
ans = get_sum(ok+1) + (M - get_count(ok+1))*ok
print(ans)
| 1 | 108,277,852,888,140 | null | 252 | 252 |
N = int(input())
h = [2,4,5,7,9]
p = [0,1,6,8]
b = [3]
if h.count(N%10)==1:
print('hon')
if p.count(N%10)==1:
print('pon')
if b.count(N%10)==1:
print('bon') | s = input()
if(s == 'AAA' or s == 'BBB'):
print("No")
else:
print("Yes")
| 0 | null | 37,106,709,461,870 | 142 | 201 |
while True:
n = int(input())
if n == 0:
break
s = list(map(int, input().split()))
m = sum(s) / n
b = 0
for i in range(n):
b += (s[i] - m) ** 2
ans = (b / n) ** 0.5
print(ans)
| n, r = input().split()
n = int(n)
r = int(r)
if n < 10:
print(r + 100*(10-n))
else:
print(r) | 0 | null | 31,701,126,364,194 | 31 | 211 |
n = int(input())
X = [[] for _ in range(n)]
for i in range(n):
x,l = list(map(int, input().split()))
X[i] = [x-l,x+l]
X.sort(key = lambda x: x[1])
cnt = 1
mx = X[0][1]
for i in range(1,n):
if mx <= X[i][0]:
cnt += 1
mx = X[i][1]
print(cnt) | n=int(input())
itv=[]
for i in range(n):
x,l=map(int,input().split())
itv+=[(x+l,x-l)]
itv=sorted(itv)
l=-10**18
cnt=0
for t,s in itv:
if l<=s:
l=t
cnt+=1
print(cnt) | 1 | 90,141,052,357,200 | null | 237 | 237 |
L = int(input())
L /= 3
print(L**3)
| n = int(input())
A = [0]+list(map(int,input().split()))
d = {}
ans = 0
for i in range(1,n+1):
if i+A[i] not in d:
d[i+A[i]] = 1
else:
d[i+A[i]] += 1
if i-A[i] in d:
ans += d[i-A[i]]
print(ans) | 0 | null | 36,646,470,048,980 | 191 | 157 |
n = int(input())
if n % 2 == 0:
n5 = 1
y = 10
c = []
while y <= n:
c.append(n//y)
if len(c) > 1:
c[-2] -= c[-1]
y *= 5
cnt = 0
for i in range(len(c)):
cnt += c[i]*(i+1)
print(cnt)
else:
print(0) | import sys
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]
def main():
N, M = MI()
p = ["0"]*(M)
S = ["0"]*(M)
for i in range(M):
p[i], S[i] = map(str,input().split())
ans = [0]*(N+1)
error = [0]*(N+1)
e = [0]*(N+1)
for i in range(M):
if ans[int(p[i])] == 0:
if S[i] == "WA":
error[int(p[i])] += 1
elif S[i] == "AC":
ans[int(p[i])] = 1
sum_ans = sum(ans)
sum_error = 0
for i in range(N+1):
if ans[i] == 1:
sum_error += error[i]
print(sum_ans, sum_error)
if __name__ == "__main__":
main() | 0 | null | 104,777,622,771,030 | 258 | 240 |
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_2_A
x = int(input())
y = list(map(int,input().split()))
z = 0
flag = 1
while flag:
flag = 0
i = x - 1
while i > 0:
if y[i] < y[i - 1]:
y[i], y[i - 1] = y[i - 1], y[i]
flag = 1
z += 1
i -= 1
print(" ".join(list(map(str,y))))
print(z) | #coding:utf-8
n = int(input())
numbers = list(map(int, input().split()))
count = 0
for i in range(n-1):
for j in range(n-1, i, -1):
if numbers[j] < numbers[j-1]:
numbers[j], numbers[j-1] = numbers[j-1], numbers[j]
count += 1
print(*numbers)
print(count) | 1 | 17,487,208,160 | null | 14 | 14 |
s=input()
s_list=list(s)
s_list.append('0')
for i in range(len(s)):
if s_list[i]=='?':
if s_list[i+1]=='D':
if s_list[i-1]=='P':
s_list[i]='D'
else:
s_list[i]='P'
elif s_list[i+1]=='?':
if s_list[i-1]=='P':
s_list[i]='D'
else :
s_list[i]='P'
else :
s_list[i]='D'
s_list.pop()
a="".join(s_list)
print(a) | T=input()
ans=""
if T=="?":
print("D")
exit()
for i in range(len(T)):
if T[i]=="P" or T[i]=="D":
ans+=T[i]
else:
if i==0:
if T[i+1]=="P":
ans+="D"
elif T[i+1]=="D":
ans+="P"
elif T[i+1]=="?":
ans+="P"
elif i!=len(T)-1:
if ans[-1]=="P" and T[i+1]=="P":
ans+="D"
elif ans[-1]=="P" and T[i+1]=="D":
ans+="D"
elif ans[-1]=="P" and T[i+1]=="?":
ans+="D"
elif ans[-1]=="D" and T[i+1]=="P":
ans+="D"
elif ans[-1]=="D" and T[i+1]=="D":
ans+="P"
elif ans[-1]=="D" and T[i+1]=="?":
ans+="P"
else:
if ans[-1]=="P":
ans+="D"
else:
ans+="D"
print(ans) | 1 | 18,483,955,706,228 | null | 140 | 140 |
h, w = map(int, input().split())
if h == 1 or w == 1:
print(1)
else:
print((-(-w//2)) * (-(-h//2)) + (w//2) * (h//2))
| S = input()
k = len(S)
if k%2==1:
print("No")
exit()
frag = True
for i in range(0,k,2):
if S[i]+S[i+1]!="hi":
frag = False
if frag:
print("Yes")
else:
print("No")
| 0 | null | 51,928,193,967,452 | 196 | 199 |
raw_input()
a = raw_input().split(" ")
a.reverse()
print " ".join(a) | S,T = (x for x in input().split())
A,B = map(int,input().split())
U = input()
if S == U:
A -= 1
else:
B -= 1
print(A,B) | 0 | null | 36,479,082,596,420 | 53 | 220 |
n = int(input())
a = list(map(int, input().split()))
x = 0
for a_i in a:
x ^= a_i
for a_i in a:
print(x ^ a_i) | N = int(input())
As = list(map(int,input().split()))
array = []
B = 0
for i in range(N):
B ^= As[i]
ans_array = []
for i in range(N):
ans_array.append(B^As[i])
print(*ans_array) | 1 | 12,554,744,743,398 | null | 123 | 123 |
k = int(input())
string = "ACL"
s = string * k
print(s) | k=int(input())
for i in range(k):
print('ACL', end='') | 1 | 2,223,562,292,678 | null | 69 | 69 |
from math import pi
print(int(input())*2*pi) | def resolve():
num = list(map(int, input().split()))
time = num[0] // num[1]
if num[0] % num[1] > 0:
print(num[2]*(time+1))
else:
print(num[2]*time)
resolve() | 0 | null | 17,882,903,436,708 | 167 | 86 |
def main():
a,b,c,k = list(map(int,input().split()))
if k<=a:
print(k)
elif k<=a+b:
print(a)
elif k < a+b+c:
print(a-(k-(a+b)))
else:
print(a-c)
main() | #create date: 2020-07-03 10:10
import sys
stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def main():
a, b, c, k = na()
if k <= a:
print(k)
elif k <= a + b:
print(a)
else:
print(a-(k-(a+b)))
if __name__ == "__main__":
main() | 1 | 21,864,582,447,840 | null | 148 | 148 |
# 与えられた数値の桁数と桁値の総和を計算する.
def calc_digit_sum(num):
digits = sums = 0
while num > 0:
digits += 1
sums += num % 10
num //= 10
return digits, sums
length = len(input())
print("x" * length) | l = len(input())
print("".join(["x" for x in range(l)])) | 1 | 73,086,426,171,390 | null | 221 | 221 |
from math import gcd
from itertools import product
N = int(input())
print(sum(gcd(gcd(a,b),c) for a, b, c in product(range(1,N+1), repeat=3))) | s = input()[::-1]
MOD = 2019
cum = 0
cnt = [0] * 2019
cnt[0] = 1
d = 1
for c in s:
cum += int(c) * d
cum %= MOD
cnt[cum] += 1
d *= 10
d %= MOD
ans = 0
for v in cnt:
ans += v * (v - 1) // 2
print(ans)
| 0 | null | 33,039,838,123,280 | 174 | 166 |
import itertools, math
N = int(input())
lst1 = []
for _ in range(N):
x, y = map(int, input().split())
lst1.append((x, y))
lst2 = list(itertools.combinations(lst1, 2))
p = math.factorial(N) * (N - 1)
c = len(list(itertools.combinations(lst1, 2)))
total = 0
for i in lst2:
d = ((i[1][0] - i[0][0]) ** 2 + (i[1][1] - i[0][1]) ** 2) ** 0.5
total += d
num = int(p/c)
fct = math.factorial(N)
print(total * num / fct) | a = list(map(int,input().split(' ')))
if a[0] < a[1] and a[1] < a[2]:
print('Yes')
else:
print('No')
| 0 | null | 74,136,509,992,780 | 280 | 39 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, U, V, AB):
g = defaultdict(list)
for a, b in AB:
g[a].append(b)
g[b].append(a)
def dfs(u):
s = [u]
d = {u: 0}
while s:
u = s.pop()
for v in g[u]:
if v in d:
continue
d[v] = d[u] + 1
s.append(v)
return d
du = dfs(U)
dv = dfs(V)
ans = 0
for v in sorted(du.keys()):
if du[v] < dv[v]:
ans = max(ans, dv[v] - 1)
return ans
def main():
N, U, V = read_int_n()
AB = [read_int_n() for _ in range(N-1)]
print(slv(N, U, V, AB))
if __name__ == '__main__':
main()
| a= int(input())
ans_list = []
for i in range(a):
ans_list.append(input())
print(len(list(set(ans_list)))) | 0 | null | 73,587,032,717,438 | 259 | 165 |
import math
y = int(input())
print(360//math.gcd(y,360)) | n, k = map(int, input().split())
A = set([])
for i in range(k):
d = input()
A = A | set(map(int, input().split()))
ans = 0
for i in range(n):
if i+1 not in A:
ans += 1
print(ans) | 0 | null | 18,873,539,424,530 | 125 | 154 |
str = input()
str2 = input()
nums = str.split()
nums2 = str2.split()
if len(nums2) != int(nums[1]):
print("error")
else:
totalDamege = 0
for num in nums2:
totalDamege += int(num)
if int(nums[0]) <= totalDamege:
print("Yes")
else:
print("No")
| print(int(input())*6.2832) | 0 | null | 54,648,935,976,810 | 226 | 167 |
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
A, B = LI()
print(A * B) | x,y=input().split();x=int(x);y=float(y);print(int(x*y)) | 1 | 15,832,886,303,860 | null | 133 | 133 |
li =list(map(int,input().split()))
n =li[0]
m =li[1]
k =li[2]
count =0
for i in range(n,m+1):
if i%k ==0:
count +=1
print(count)
| main=list(map(int,input().split()));count=0
for i in range(main[0],main[1]+1):
if(i%main[2]==0): count=count+1
print(count) | 1 | 7,609,637,400,310 | null | 104 | 104 |
from itertools import product
def max2(x,y):
return x if x > y else y
N = int(input())
data = [[] for _ in range(N)]
res = 0
for i in range(N):
for _ in range(int(input())):
data[i].append(tuple(map(int, input().split())))
for a in product((0,1), repeat=N):
flg = False
for i in range(N):
for x, y in data[i]:
x -= 1
if a[i] == 1:
if a[x] != y:
flg = True
break
if flg:
break
if i == N-1:
res = max2(res, sum(a))
print(res)
| s=list(map(int,list(input())))
if sum(s)%9==0:
print('Yes')
else:
print('No') | 0 | null | 63,115,279,877,502 | 262 | 87 |
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
from collections import Counter
def resolve():
N, K, C = lr()
S = [i+1 for i, s in enumerate(sr()) if s == 'o']
l = [S[0]]
for i in S[1:]:
if l[-1]+C >= i or len(l) > K:
continue
l.append(i)
S = S[::-1]
r = [S[0]]
for i in S[1:]:
if r[-1]-C <= i or len(r) > K:
continue
r.append(i)
r = r[::-1]
for i in range(K):
if l[i] == r[i]:
print(l[i])
resolve() | N, K, C = map(int,input().split())
S = list(input())
def solve(List):
ans = []
i = 0
while i < N:
if List[i] == 'o':
ans.append(i+1)
i += C
i += 1
return ans
n = solve(S)
if len(n) > K:
pass
else:
r = solve(S[::-1])
r = list(map(lambda x: N+1-x, r[::-1]))
ans = list(set(n) & set(r))
ans.sort()
for i in ans:
print(i) | 1 | 40,420,671,046,166 | null | 182 | 182 |
import sys
from collections import deque
input = sys.stdin.readline
n, m, k = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
cd = [list(map(int, input().split())) for _ in range(k)]
ff = [[] for _ in range(n+1)]
for a, b in ab:
ff[a].append(b)
ff[b].append(a)
visited = [False] * (n+1)
visited[0] = True
com = [-1] * (n+1)
def dfs(v, ff, visited, com, g):
q = deque([v])
visited[v] = True
com[v] = g
k = 1
while len(q) > 0:
w = q.pop()
for x in ff[w]:
if not visited[x]:
q.append(x)
visited[x] = True
com[x] = g
k += 1
return k
g = 0
group_num = []
for i in range(1, n+1):
if visited[i]:
pass
else:
k = dfs(i, ff, visited, com, g)
group_num.append(k)
g += 1
#print(com)
friends = [0] * (n+1)
for i in range(1, n+1):
friends[i] += group_num[com[i]] - 1
for a, b in ab:
if com[a] == com[b]:
friends[a] -= 1
friends[b] -= 1
for c, d in cd:
if com[c] == com[d]:
friends[c] -= 1
friends[d] -= 1
print(" ".join(map(str, friends[1:]))) | from sys import setrecursionlimit
setrecursionlimit(10 ** 5)
def find(parent, i):
t = parent[i]
if t < 0:
return i
t = find(parent, t)
parent[i] = t
return t
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[j] += parent[i]
parent[i] = j
n, m, k = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
cd = [list(map(int, input().split())) for _ in range(k)]
parent = [-1] * n
friends = [[] for _ in range(n)]
for a, b in ab:
unite(parent, a-1, b-1)
friends[a-1].append(b-1)
friends[b-1].append(a-1)
blocks = [[] for _ in range(n)]
for c, d in cd:
blocks[c-1].append(d-1)
blocks[d-1].append(c-1)
result = []
for i in range(n):
p = find(parent, i)
t = -parent[p] - 1
t -= len(friends[i])
for b in blocks[i]:
if p == find(parent, b):
t -= 1
result.append(t)
print(*result) | 1 | 61,481,559,457,020 | null | 209 | 209 |
n=int(input())
li=list(map(int,input().split()))
for i in li:
if i%2==0:
if i%3==0 or i%5==0:
pass
else:
print("DENIED")
break
else:
print("APPROVED") | import numpy as np
N = int(input())
A = list(map(int,input().split()))
a = np.array(A)
odd = a[a%2 == 0]
if np.sum((odd%3 != 0)&(odd%5 != 0)) == 0:
print('APPROVED')
else:
print('DENIED')
| 1 | 69,333,408,018,772 | null | 217 | 217 |
s=input()[::-1]+'0'
d=[0,1]
for c in s:
x=int(c)
d=[x+min(d[0],1+d[1]),min(1+d[0],d[1])+9-x]
print(min(d))
| T = str(input())
print(T.replace('?', 'D')) | 0 | null | 44,897,670,752,560 | 219 | 140 |
def merge_sort(left, right):
if right-left > 1:
mid = (left + right) // 2
merge_sort(left, mid)
merge_sort(mid, right)
merge(left, mid, right)
def merge(left, mid, right):
left_part = S[left:mid]
right_part = S[mid:right]
left_part.append(inf)
right_part.append(inf)
l, r = 0, 0
for i in range(left, right):
if left_part[l] < right_part[r]:
S[i] = left_part[l]
l += 1
else:
S[i] = right_part[r]
r += 1
num[0] += right-left
if __name__ == "__main__":
num = [0]
inf = float('inf')
n = int(input())
S = list(map(int, input().split()))
merge_sort(0, n)
print(' '.join(list(map(str, S))))
print(num[0])
| n = int(input())
A = list(map(int, input().split()))
MAX_N = max(A)+ 1
cnt = [0] * MAX_N
for a in A:
for i in range(a, MAX_N, a):
if cnt[i] <= 2:
cnt[i] += 1
ans = 0
for a in A:
if cnt[a] == 1:
ans += 1
print(ans)
| 0 | null | 7,259,186,626,170 | 26 | 129 |
N = int(input())
S, T = list(map(str, input().split()))
A = ''
for i in range(N):
A += S[i]
A += T[i]
print(A) | from collections import Counter
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N, P = map(int, readline().split())
S = [int(i) for i in readline().strip()[::-1]]
ans = 0
if P == 2 or P == 5:
for i, s in enumerate(S):
if s % P == 0:
ans += N - i
print(ans)
exit()
a = [0]
s = 0
for i in range(N):
s += S[i] * pow(10, i, P)
a.append(s % P)
t = Counter(a)
ans = 0
for v in t.values():
ans += v * (v-1) // 2
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 85,313,595,311,142 | 255 | 205 |
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
class Fibonacci(object):
memo = [1, 1]
def get_nth(self, n):
if n < len(Fibonacci.memo):
return Fibonacci.memo[n]
# print('fib({0}) not found'.format(n))
for i in range(len(Fibonacci.memo), n+1):
result = Fibonacci.memo[i-1] + Fibonacci.memo[i-2]
Fibonacci.memo.append(result)
# print('fib({0})={1} append'.format(i, result))
return Fibonacci.memo[n]
if __name__ == '__main__':
# ??????????????\???
num = int(input())
# ?????£??????????????°????¨????
#f = Fibonacci()
#result = f.get_nth(num)
result = fib(num+1)
# ???????????????
print('{0}'.format(result)) | import math
x1,y1,x2,y2=map(float,input().split(' '))
res=math.sqrt((x1-x2)**2+(y1-y2)**2)
print(res)
| 0 | null | 83,637,752,000 | 7 | 29 |
HP, N = map(int, input().split())
ATK = list(map(int, input().split()))
print('Yes' if sum(ATK) >= HP else 'No') | N = int(input())
A = list(map(int,input().split()))
sum_height = 0
max_height = A[0]
for i in range(1,len(A)):
if A[i] < max_height:
sum_height += max_height - A[i]
else:
max_height = A[i]
print(sum_height)
| 0 | null | 41,480,576,840,990 | 226 | 88 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, d, a = list(map(int, readline().split()))
xh = [list(map(int, readline().split())) for _ in range(n)]
from operator import itemgetter, add
import bisect
xh.sort(key=itemgetter(0))
coordinate = [xh[i][0] for i in range(n)]
hp = [xh[i][1] for i in range(n)]
ans = 0
dmg_cur = 0
dmg_cum = [0] * (n + 1)
for i in range(n):
x = coordinate[i]
h = hp[i]
dmg_cur += dmg_cum[i]
h -= dmg_cur
if h > 0:
num = (h + a - 1) // a
ans += num
dmg = a * num
dmg_cur += dmg
range_left = x
range_right = x + 2 * d
index_right = bisect.bisect_right(coordinate, range_right)
dmg_cum[index_right] -= dmg
print(ans)
if __name__ == '__main__':
main()
| n,d,a = map(int,input().split())
xh = [list(map(int,input().split())) for _ in range(n)]
xh.sort()
ans = 0
att = [0]*n
cnt = 0
f = []
f1 = [0]*n
for x,h in xh:
f.append(h)
for i in range(n):
tmp = xh[i][0] + 2 * d
while cnt < n:
if xh[cnt][0] <= tmp:
cnt += 1
else:
break
att[i] = min(cnt-1, n-1)
for i in range(n):
if f[i] > 0:
da = -(-f[i]//a)
ans += da
f1[i] -= da * a
if att[i]+1 < n:
f1[att[i]+1] += da * a
if i < n-1:
f1[i+1] += f1[i]
f[i+1] += f1[i+1]
print(ans)
| 1 | 82,349,374,446,430 | null | 230 | 230 |
# A - Duplex Printing
from math import ceil
print(ceil(int(input()) / 2))
| # coding: utf-8
# Here your code !
import math
i = input()
count=0
def isPrime(x):
global count
if x == 2:
return True
if x>2 and x%2==0:
return False
i = 3
while i<=math.sqrt(x):
if x%i==0:
return False
i+=2
return True
for j in range(int(i)):
j=int(input())
if isPrime(j):
count+=1
print(count) | 0 | null | 29,311,023,519,932 | 206 | 12 |
import sys
from collections import defaultdict
def solve():
input = sys.stdin.readline
N, P = map(int, input().split())
S = input().strip("\n")
modSum = 0
modDict = defaultdict(int)
modDict[0] += 1
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):
modSum += int(S[N-i-1]) * pow(10, i, P)
modSum %= P
modDict[modSum] += 1
for key in modDict:
v = modDict[key]
ans += v * (v - 1) // 2
print(ans)
return 0
if __name__ == "__main__":
solve() | #!python3
LI = lambda: list(map(int, input().split()))
# input
N, P = LI()
S = input()
def solve2():
ans = 0
for i in range(N):
if int(S[i]) % 2 == 0:
ans += i + 1
return ans
def solve5():
ans = 0
for i in range(N):
if int(S[i]) % 5 == 0:
ans += i + 1
return ans
def solve():
d = [0] * P
d[0] = 1
w = 0
ans = 0
m = 1
for s in S[::-1]:
x = int(s)
v = x * m % P
w = (w + v) % P
ans += d[w]
d[w] += 1
m = 10 * m % P
return ans
def main():
if P == 2:
ans = solve2()
elif P == 5:
ans = solve5()
else:
ans = solve()
print(ans)
if __name__ == "__main__":
main()
| 1 | 57,900,007,114,628 | null | 205 | 205 |
def resolve():
def lcm(X, Y):
x = X
y = Y
if y > x:
x, y = y, x
while x % y != 0:
x, y = y, x % y
return X * Y // y
n = int(input())
a = list(map(int, input().split()))
mod = 10**9 + 7
lsd = a[0]
for i in range(1, n):
lsd = lcm(lsd, a[i])
lsd = lsd % mod
ans = 0
for i in range(n):
ans += (lsd * pow(a[i], mod-2, mod)) % mod
print(int(ans % mod))
resolve() | N = int((input()))
C_p = []
C_m = []
for i in range(N):
kakko = input()
temp = 0
temp_min = 0
for s in kakko:
if s == "(":
temp += 1
else:
temp -= 1
temp_min = min(temp, temp_min)
if temp >= 0:
C_p.append((temp_min, temp))
else:
C_m.append((temp_min - temp, temp_min, temp))
C_p.sort(reverse=True)
flag = 0
final = 0
for l, f in C_p:
if final + l < 0:
flag = 1
final += f
C_m.sort()
for _, l, f in C_m:
if final + l < 0:
flag = 1
final += f
if final != 0:
flag = 1
print("Yes" if flag == 0 else "No") | 0 | null | 55,433,483,824,388 | 235 | 152 |
n=int(input())
a=[int(i) for i in input().split()]
cnt={}
for i in range(n):
cnt[a[i]]=0
ok=1
for i in range(n):
cnt[a[i]]+=1
if cnt[a[i]]==2:
print("NO")
ok=0
break
if ok==1:
print("YES")
| N = int(input())
arr = list(map(int, input().split()))
s = 0
for i in range(N):
s ^= arr[i]
for i in range(N):
arr[i] ^= s
print(' '.join(map(str, arr))) | 0 | null | 43,301,160,689,138 | 222 | 123 |
M,N = map(int,input().rstrip().split(" "))
ans=False
for a in range(M + 1):
b=M-a
if 2 * a + 4 * b == N:
ans=True
if ans:
print("Yes")
else:
print("No") | # 2019-11-19 10:28:31(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
import numpy as np
def main():
n, m, l = map(int, sys.stdin.readline().split())
ABCQST = np.array(sys.stdin.read().split(), np.int64)
ABC = ABCQST[:m * 3]
A, B, C = ABC[::3], ABC[1::3], ABC[2::3]
ST = ABCQST[m * 3 + 1:]
S, T = ST[::2], ST[1::2]
dist = csr_matrix((C, (A, B)), (n+1, n+1))
min_dist = floyd_warshall(dist, directed=False)
filling_times = np.full((n+1, n+1), np.inf)
np.diagonal(filling_times, 0)
filling_times[min_dist <= l] = 1
min_filling_times = floyd_warshall(filling_times, directed=False)
min_filling_times[min_filling_times == np.inf] = 0
# 最後に-1する
min_filling_times = min_filling_times.astype(int)
res = min_filling_times[S, T] - 1
print('\n'.join(res.astype(str)))
if __name__ == "__main__":
main()
| 0 | null | 93,992,085,557,920 | 127 | 295 |
#coding:utf-8
n = int(input())
A = list(map(int, input().split()))
times = 0
for i in range(n):
minj = i
for j in range(i,n):
if A[j] < A[minj]:
minj = j
if i != minj:
A[i], A[minj] = A[minj], A[i]
times += 1
B = " ".join([str(num) for num in A])
print(B)
print(times)
| import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 二分探索
N, K = lr()
A = np.array(lr())
F = np.array(lr())
A.sort()
F = np.sort(F)[::-1]
def check(x):
count = np.maximum(0, (A - (x // F))).sum()
return count <= K
left = 10 ** 12 # 可能
right = -1 # 不可能
while left > right + 1:
mid = (left+right) // 2
if check(mid):
left = mid
else:
right = mid
print(left)
# 51 | 0 | null | 82,623,759,511,748 | 15 | 290 |
def main():
n = int(input())
l_0 = []
r_0 = []
ls_plus = []
ls_minus = []
sum_l = 0
sum_r = 0
for i in range(n):
s = input()
left, right = 0, 0
for j in range(len(s)):
if s[j] == '(':
right += 1
else:
if right > 0:
right -= 1
else:
left += 1
if left == right == 0:
continue
if left == 0:
l_0.append((left, right))
elif right == 0:
r_0.append((left, right))
elif left < right:
ls_plus.append((left, right))
else:
ls_minus.append((left, right))
sum_l += left
sum_r += right
if len(ls_plus) == len(ls_minus) == len(l_0) == len(r_0) == 0:
print("Yes")
return
if len(l_0) == 0 or len(r_0) == 0:
print("No")
return
if sum_l != sum_r:
print("No")
return
# r-lの大きい順
ls_plus.sort(key=lambda x: x[1] - x[0], reverse=True)
# lの小さい順
ls_plus.sort(key=lambda x: x[0])
# l-rの小さい順
ls_minus.sort(key=lambda x: x[0] - x[1])
# lの大さい順
ls_minus.sort(key=lambda x: x[0], reverse=True)
now_r = 0
for ll in l_0:
now_r += ll[1]
for _ in ls_plus:
r = _[1]
x = now_r - _[0]
if x >= 0:
now_r = x + r
else:
print("No")
return
for _ in ls_minus:
r = _[1]
x = now_r - _[0]
if x >= 0:
now_r = x + r
else:
print("No")
return
print("Yes")
main()
| def Yes():
print('Yes')
exit()
def No():
print('No')
exit()
def parse(s):
ret = [0, 0]
for c in s:
if c == ')':
if ret[0]:
ret[0] -= 1
else:
ret[1] -= 1
else:
ret[0] += 1
return ret
N = int(input())
S = [parse(input()) for _ in range(N)]
S.sort(key=lambda a: -a[0] - a[1])
S1 = []
S2 = []
for s in S:
if s[0] + s[1] >= 0:
S1 += [s]
else:
S2 += [s]
S1.sort(key=lambda a: -a[1])
S2.sort(key=lambda a: -a[0])
cnt = 0
for s in S1:
cnt += s[1]
if cnt < 0:
No()
cnt += s[0]
for s in S2:
cnt += s[1]
if cnt < 0:
No()
cnt += s[0]
if cnt:
No()
Yes()
| 1 | 23,522,783,322,840 | null | 152 | 152 |
temp = int(input())
if temp >= 30:
print("Yes")
else:
print("No") | def main():
print(int(input())**2)
if __name__ == "__main__":
main() | 0 | null | 75,495,032,061,100 | 95 | 278 |
n = input()
if '7' in n:
print('Yes')
exit()
else:
print('No') | from collections import defaultdict
def main():
_, _, m = map(int, input().split())
row_dict = defaultdict(int)
col_dict = defaultdict(int)
row_col_dict = defaultdict(set)
for _ in range(m):
row, col = map(int, input().split())
row_dict[row] += 1
col_dict[col] += 1
row_col_dict[row].add(col)
max_row_val = max(row_dict.values())
max_col_val = max(col_dict.values())
max_rows = {k for k, v in row_dict.items() if v == max_row_val}
max_cols = {k for k, v in col_dict.items() if v == max_col_val}
ans = max_row_val + max_col_val - 1
flg = False
if ans < m:
for row in max_rows:
for col in max_cols:
if not col in row_col_dict[row]:
ans += 1
flg = True
break
if flg:
break
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 19,419,320,506,212 | 172 | 89 |
H, N = map(int, input().split())
l = []
for i in range(N):
l.append(list(map(int, input().split())))
dp = [0] * 20000
for i in range(1, 20001):
dp[i] = min(dp[i-a]+b for a, b in l)
if i == H:
break
print(dp[H]) | def num():
from sys import stdin
h, n = map(int, input().split())
magic = [list(map(int, stdin.readline().split())) for _ in range(n)]
INF = float('inf')
ans = [INF]*(h+1)
ans[-1] = 0
for i in range(h, 0, -1):
if ans[i] != INF:
for j, k in magic:
if i-j < 0:
num = ans[i]+k
if ans[0] > num:
ans[0] = num
else:
num = ans[i]+k
if ans[i-j] > num:
ans[i-j] = num
return ans[0]
print(num())
| 1 | 80,777,827,344,380 | null | 229 | 229 |
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
N = I()
S,T = LS()
ans = ""
for i in range(N):
ans += S[i]
ans += T[i]
print(ans)
main()
| import sys
N = int(input())
S,T = input().split()
if not ( 1 <= N <= 100 ): sys.exit()
if not ( len(S) == len(T) and len(S) == N ): sys.exit()
if not ( S.islower() and T.islower() ): sys.exit()
for I in range(N):
print(S[I],end='')
print(T[I],end='') | 1 | 111,639,412,732,640 | null | 255 | 255 |
import random
name = input()
name_lenght = len(name)
start = random.randint(0, name_lenght - 3)
end = start + 3
print(name[start:end]) |
def main():
# a, b = list(map(float, input().split()))
s = input()
return s[:3]
if __name__ == '__main__':
result = main()
print(result) | 1 | 14,777,584,687,612 | null | 130 | 130 |
H, W = map(int, input().split())
S = [[i for i in input()] for j in range(H)]
dp = [[0 for i in range(W)] for j in range(H)]
if S[0][0] == "#":
dp[0][0] = 1
for i in range(1, H):
if S[i-1][0] == "." and S[i][0] == "#":
dp[i][0] = dp[i-1][0] + 1
else:
dp[i][0] = dp[i-1][0]
for j in range(1, W):
if S[0][j-1] == "." and S[0][j] == "#":
dp[0][j] = dp[0][j-1] + 1
else:
dp[0][j] = dp[0][j-1]
for h in range(1, H):
for w in range(1, W):
if S[h][w] == "#":
if S[h-1][w] == ".":
c1 = dp[h-1][w] + 1
else:
c1 = dp[h-1][w]
if S[h][w-1] == ".":
c2 = dp[h][w-1] + 1
else:
c2 = dp[h][w-1]
dp[h][w] = min(c1, c2)
else:
dp[h][w] = min(dp[h-1][w], dp[h][w-1])
print(dp[H-1][W-1]) | a, b ,c = [int(i) for i in input().split()]
total = 0
for d in range(a, b + 1):
if c % d == 0:
total += 1
print(total) | 0 | null | 25,056,939,132,002 | 194 | 44 |
while True:
data = input().split()
m = int(data[0])
f = int(data[1])
r = int(data[2])
if m == -1 and f == -1 and r == -1:
break
elif m == -1 or f == -1:
print('F')
else:
if m + f >= 80:
print('A')
elif m + f >= 65:
print('B')
elif m + f >= 50:
print('C')
elif m + f >= 30:
if r >= 50:
print('C')
else:
print('D')
else:
print('F') | while True:
m,f,r=map(int,input().split())
a=0
if m ==-1 and f==-1 and r==-1:
break
elif m==-1 or f==-1:
a="F"
elif m+f>=80:
a="A"
elif m+f>=65 and m+f<=79:
a="B"
elif m+f>=50 and m+f<=65:
a="C"
elif m+f>=30 and m+f<=49:
if r>=50:
a="C"
else:
a="D"
elif m+f<=29:
a="F"
print(a)
| 1 | 1,201,584,987,692 | null | 57 | 57 |
l = [1,2,3]
l.remove(int(input()))
l.remove(int(input()))
print(l[0])
| a = int(input())
b = int(input())
if a == 2 and b == 3 or b == 2 and a == 3:
print('1')
elif a == 1 and b == 2 or b == 1 and a == 2:
print('3')
else:
print('2')
| 1 | 110,621,419,626,130 | null | 254 | 254 |
s = input()
t = input()
n = len(s)
m = len(t)
ans = 2000
for i in range(n):
if i+m > n:
break
u = s[i:i+m]
cnt = 0
for j in range(m):
if t[j] != u[j]:
cnt += 1
ans = min(ans, cnt)
print(ans) | S = input()
T = input()
l = len(S) - len(T) + 1
ans = len(T)
t = len(T)
for i in range(l):
s = S[i:i+t]
ans = min(ans, len([0 for i in range(t) if T[i] != s[i]]))
print(ans) | 1 | 3,696,038,211,942 | null | 82 | 82 |
n,k = map(int,input().split())
a = [0]+list(map(int,input().split()))
for i in range(n):
a[i+1] += a[i]
a[i+1] %=k
cnt = {}
ans = 0
for i in range(n+1):
left = i-k
if left >=0:
ldiff = (a[left] - left)%k
cnt[ldiff] -= 1
x = (a[i] - i)%k
if x <0:x+=k
if x not in cnt:cnt[x] = 0
ans+= cnt[x]
cnt[x] +=1
print(ans)
| a, b = map(int, input().split(' '))
if a < b:
print('a < b')
elif a > b:
print('a > b')
else:
print('a == b')
| 0 | null | 68,992,276,865,230 | 273 | 38 |
import string
import sys
input_str = ""
for i in sys.stdin:
input_str += i
for i in range(26):
char = string.ascii_lowercase[i]
CHAR = string.ascii_uppercase[i]
cnt = input_str.count(char) + input_str.count(CHAR)
print("{0} : {1}".format(char, cnt)) | 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()
| 0 | null | 13,801,058,879,720 | 63 | 157 |
sec_input = int(input())
hour = sec_input // (60 * 60)
remain = sec_input % (60 * 60)
min = remain // 60
sec = remain % 60
print('%d:%d:%d' % (hour, min, sec)) | from copy import copy
import random
import math
import sys
input = sys.stdin.readline
D = int(input())
c = list(map(int,input().split()))
s = [list(map(int,input().split())) for _ in range(D)]
last = [0]*26
ans = [0]*D
score = 0
for i in range(D):
ps = [0]*26
for j in range(26):
pl = copy(last)
pl[j] = i+1
ps[j] += s[i][j]
for k in range(26):
ps[j] -= c[k]*(i+1-pl[k])
idx = ps.index(max(ps))
last[idx] = i+1
ans[i] = idx+1
score += max(ps)
for k in range(1,40001):
na = copy(ans)
x = random.randint(1,365)
y = random.randint(1,365)
na[x-1] = na[y-1]
last = [0]*26
ns = 0
for i in range(D):
last[na[i]-1] = i+1
ns += s[i][na[i]-1]
for j in range(26):
ns -= c[j]*(i+1-last[j])
if k%100 == 1:
T = 80-(79*k/40000)
p = pow(math.e,-abs(ns-score)/T)
if ns > score or random.random() < p:
ans = na
score = ns
for a in ans:
print(a) | 0 | null | 5,063,082,868,850 | 37 | 113 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
????????????
"""
inp = input().strip().split(" ")
n = int(inp[0])
m = int(inp[1])
l = int(inp[2])
# ?????????????????????????¢????
# A[n][m] B[m][l] C[n][l]
A = [[0 for i in range(m)] for j in range(n)]
B = [[0 for i in range(l)] for j in range(m)]
C = [[0 for i in range(l)] for j in range(n)]
# A???????????°??????????????????
for i in range(n):
inp = input().strip().split(" ")
for j in range(m):
A[i][j] = int(inp[j])
# B???????????°??????????????????
for i in range(m):
inp = input().strip().split(" ")
for j in range(l):
B[i][j] = int(inp[j])
# A x B
for i in range(n):
for j in range(l):
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
print(" ".join(map(str,C[i]))) | n,m,l=map(int,input().split())
A = [tuple(map(int,input().split())) for _ in range(n)]
B = [tuple(map(int,input().split())) for _ in range(m)]
BT = tuple(map(tuple,zip(*B)))
for a in A:
temp=[]
for b in BT:
temp.append(sum([x*y for (x,y) in zip(a,b)]))
print(*temp) | 1 | 1,436,529,760,292 | null | 60 | 60 |
x = input().split()
x_int = [int(i) for i in x]
d = x_int[0]//x_int[1]
r = x_int[0] % x_int[1]
f = (x_int[0]) / (x_int[1])
print('{0} {1} {2:f}'.format(d,r,f)) |
N = int(input())
X = list(map(int, input().split()))
MAX = 10 ** 6 + 1
prime = [True] * MAX
counted = set()
for v in X:
if v in counted:
prime[v] = False
continue
for j in range(2 * v, MAX, v):
prime[j] = False
counted.add(v)
ans = 0
for v in X:
ans += int(prime[v])
print(ans)
| 0 | null | 7,599,256,675,140 | 45 | 129 |
from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
import math
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math as M
MOD=10**9+7
import random
#####################################
k=int(input())
if k%2==0:
print("{:.10f}".format(1/2))
else:
print("{:.10f}".format((k//2+1)/k))
| import math
n = int(input())
answer = (n - math.floor(n / 2)) / n
print(answer)
# nums = list(range(1, n + 1))
#
# odds = [x for x in nums if x % 2 == 1]
#
# if len(nums) % 2 == 0:
# print(0.5)
# else:
# print(len(odds) / len(nums))
| 1 | 177,224,292,297,820 | null | 297 | 297 |
n = int(input())
l = [int(input()) for _ in range(n)]
minval = l[0]
maxp = -1000000000
for val in l[1:]:
if maxp < val - minval:
maxp = val - minval
if minval > val:
minval = val
print(maxp)
| import sys
sys.setrecursionlimit(10**8)
def find(x):
if par[x]==x:
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
a=find(a)
b=find(b)
if a==b:
return
if rank[a]<rank[b]:
par[a]=b
rank[b]+=rank[a]
rank[a]=rank[b]
else:
par[b]=a
rank[a]+=rank[b]
rank[b]=rank[a]
return
def chk(a,b):
if par[a]==par[b]:
print('Yes')
else:
print('No')
return
N,M=map(int, input().split())
par=(list(range(N+1)))
rank=[1]*(N+1)
for _ in range(M):
A,B=map(int, input().split())
union(A,B)
print(max(rank)) | 0 | null | 1,957,101,915,442 | 13 | 84 |
from collections import deque
import sys
deq = deque()
q = int(input())
for _ in range(q):
s = input()
if s == 'deleteFirst':
deq.popleft()
elif s == 'deleteLast':
deq.pop()
else:
ss, num = s.split()
if ss == 'insert':
deq.appendleft(num)
else:
try:
deq.remove(num)
except:
pass
print(" ".join(deq))
| N, S = map(int,input().split())
A = list(map(int,input().split()))
mod = 998244353
dp = [0 for j in range(S + 1)]
dp[0] = 1
for i in range(N) :
for j in range(S, -1, -1) :
if j + A[i] <= S :
dp[j + A[i]] += dp[j]
dp[j + A[i]] %= mod
dp[j] *= 2
dp[j] %= mod
print(dp[S])
| 0 | null | 8,936,172,787,070 | 20 | 138 |
x = int(input())
print(int(x/2)+ 1 if x % 2 != 0 else int(x/2)) | n = int(input())
ans = int(n/2) + n%2
print(ans) | 1 | 58,835,855,419,740 | null | 206 | 206 |
import sys
chash = {}
for i in range( ord( 'a' ), ord( 'z' )+1 ):
chash[ chr( i ) ] = 0
lines = sys.stdin.readlines()
for i in range( len( lines ) ):
for j in range( len( lines[i] ) ):
if lines[i][j].isalpha():
chash[ lines[i][j].lower() ] += 1
for i in range( ord( 'a' ), ord( 'z' )+1 ):
print( "{:s} : {:d}".format( chr( i ), chash[ chr( i ) ] ) ) | dic = {}
while True:
try:
line = raw_input()
except:
break
for i in line.lower():
if i in dic:
dic[i] += 1
else:
dic[i] = 1
for i in xrange(97, 123):
output = 0
if chr(i) in dic:
output = dic[chr(i)]
print "%s : %d" % (chr(i), output) | 1 | 1,635,074,845,882 | null | 63 | 63 |
inp = input().split()
A = int(inp[0])
B = int(inp[1].replace('.',''))
print(A*B//100) | import bisect,collections,copy,heapq,itertools,math,string
import sys
from decimal import Decimal
def S(): return sys.stdin.readline().rstrip()
def M(): return map(Decimal,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b = M()
ab = a*b
print(math.floor(ab))
| 1 | 16,511,985,569,118 | null | 135 | 135 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.