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
|
|---|---|---|---|---|---|---|
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
X, Y, Z = MI()
A = [Z, X, Y]
print(' '.join(map(str, A)))
if __name__ == "__main__":
main() | x,y,z = map(int, input().split())
a = x
b = y
c = z
a = y
b = x
a = z
c = y
print(a,b,c) | 1 | 38,115,504,520,100 | null | 178 | 178 |
import sys
from collections import deque
#import numpy as np
import math
#sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())
def solve():
ans = 0
flag = True
for rep in discount:
pay = a[rep[0]-1] + b[rep[1]-1] - rep[2]
if flag:
ans = pay
flag = False
else:
ans = min(ans,pay)
ans = min(ans,min(a)+min(b))
print(ans)
return
if __name__=='__main__':
A,B,M = IL()
a = list(IL())
b = list(IL())
discount = [list(IL()) for _ in range(M)]
solve() | A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = [list(map(int, input().split())) for _ in range(M)]
buy = [min(a)+min(b)]
for i in range(M):
C = a[c[i][0]-1]+b[c[i][1]-1]-c[i][2]
buy.append(C)
print(min(buy))
| 1 | 53,959,666,789,980 | null | 200 | 200 |
def breathSerch(P,N):
n=len(P)-1
m=1
QQ=[N[1]]
while(QQ != []):
R=[]
for Q in QQ:
for i in range(1,n+1):
if Q[i]==1 and P[i]==-1:
P[i]=m
R.append(N[i])
QQ = R
m=m+1
n = int(input())
A = [[0 for j in range(n+1)] for i in range(n+1)]
for i in range(n):
vec = input().split()
u = int(vec[0])
k = int(vec[1])
nodes = vec[2:]
for i in range(int(k)):
v = int(nodes[i])
A[u][v] = 1
P=[-1 for i in range(n+1)]
P[1]=0
breathSerch(P,A)
for i in range(1,n+1):
print(i,P[i]) | #abc167_e
n = int(input())
pos = []
neg = []
for _ in range(n):
s = input()
low_pos = 0
increase= 0
for v in s:
if v=="(":
increase += 1
else:
increase -= 1
low_pos = min(low_pos, increase)
if increase >= 0:
pos.append((low_pos, increase))
else:
#reverse left from right
low_pos, increase = low_pos - increase, -increase
neg.append((low_pos, increase))
pos.sort()
pos.reverse() #lowが高い順にする.
neg.sort()
neg.reverse() #lowが高い順にする.
now_pos = 0
for low_pos, increase in pos:
if now_pos + low_pos < 0:
print("No") #impossible
exit()
else:
now_pos += increase
right_pos = 0
for low_pos, increase in neg:
if right_pos + low_pos < 0:
print("No") #impossible
exit()
else:
right_pos += increase
if right_pos != now_pos:
print("No")
exit()
else:
print("Yes") | 0 | null | 11,749,960,119,128 | 9 | 152 |
"""
最小公倍数LCMを求めて、LCMを各Aで除した商を合計すればよい
"""
from math import gcd
def lcm(a,b):
return a*b//gcd(a,b)
def main():
mod = 10**9 +7
N = int(input())
A = list(map(int,input().split()))
l = A[0]
for i in range(1,N):
l = lcm(l,A[i])
ans = 0
for a in A:
ans += l//a
print(ans%mod)
main() | from functools import lru_cache
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, K = map(int,read().split())
@lru_cache(None)
def F(N, K):
if N < 10:
if K == 0:
return 1
if K == 1:
return N
return 0
q, r = divmod(N, 10)
ret = 0
if K >= 1:
ret += F(q, K-1) * r
ret += F(q-1, K-1) * (9-r)
ret += F(q, K)
return ret
print(F(N, K)) | 0 | null | 82,115,955,268,890 | 235 | 224 |
from collections import Counter
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
result = []
for i in range(K):
result.append(T[i])
for j in range(K, N):
if result[j-K] == T[j]:
result.append("d")
else:
result.append(T[j])
result = Counter(result)
print(result["r"]*P+result["s"]*R+result["p"]*S)
| n,k = map(int, input().split())
r, s, p = map(int, input().split())
T = list(str(input()))
ans = 0
S = [-1]*n
for i in range(n):
if i <= k-1:
if T[i] == 'r':
S[i] = 'p'
ans += p
elif T[i] == 's':
S[i] = 'r'
ans += r
else:
S[i] = 's'
ans += s
else:
if T[i] == 'r':
if S[i-k] != 'p':
S[i] = 'p'
ans += p
else:
if i+k <= n-1:
if T[i+k] == 's':
S[i] = 's'
elif T[i+k] == 'p':
S[i] = 'r'
else:
S[i] = 'r'
else:
S[i] = 'r'
elif T[i] == 's':
if S[i-k] != 'r':
S[i] = 'r'
ans += r
else:
if i+k <= n-1:
if T[i+k] == 'p':
S[i] = 'p'
elif T[i+k] == 'r':
S[i] = 's'
else:
S[i] = 's'
else:
S[i] = 's'
else:
if S[i-k] != 's':
S[i] = 's'
ans += s
else:
if i+k <= n-1:
if T[i+k] == 's':
S[i] = 'p'
elif T[i+k] == 'r':
S[i] = 'r'
else:
S[i] = 'p'
else:
S[i] = 'p'
print(ans)
| 1 | 106,637,776,556,220 | null | 251 | 251 |
s = []
F = {
'+': lambda: s.append(s.pop() + s.pop()),
'-': lambda: s.append(-s.pop() + s.pop()),
'*': lambda: s.append(s.pop() * s.pop())
}
for op in input().split():
if op in F:
F[op]()
else:
s.append(int(op))
print(s.pop()) |
Stack=[]
def push(x):
Stack.append(x)
def pop():
return Stack.pop()
def solve():
s_list=raw_input().split()
for i in range(len(s_list)):
if s_list[i]=='+':
b=pop()
a=pop()
push(a+b)
elif s_list[i]=='-':
b=pop()
a=pop()
push(a-b)
elif s_list[i]=='*':
b=pop()
a=pop()
push(a*b)
else:
push(int(s_list[i]))
print(pop())
def main():
if __name__=="__main__":
solve()
main() | 1 | 37,062,364,220 | null | 18 | 18 |
import sys
input = sys.stdin.readline
from collections import defaultdict, deque
n, s = int(input()), list(map(int, input().split()))
res = [0 for i in range(n)]
for i in range(n): res[s[i]-1] = i + 1
print(' '.join(str(i) for i in res)) | N = int(input())
a = []
b = []
for i in range(N):
x,y = (list(map(int,input().split())))
a.append(x+y)
b.append(x-y)
a.sort()
b.sort()
ans = max(a[-1]-a[0],b[-1]-b[0])
print(ans)
| 0 | null | 91,999,177,020,838 | 299 | 80 |
input()
xs = list(map(int, input().split()))
def insertion_sort(xs):
for i in range(1, len(xs)):
v = xs[i]
j = i - 1
while j >= 0 and xs[j] > v:
xs[j + 1] = xs[j]
j -= 1
xs[j + 1] = v
print(*xs)
print(*xs)
insertion_sort(xs) | a, b, c = map(int, input().split())
k = int(input())
for i in range(k):
if a < b < c:
break
elif b <= a:
b = b*2
elif c <= b:
c = c*2
if a < b < c:
print("Yes")
else:
print("No") | 0 | null | 3,501,884,341,658 | 10 | 101 |
import collections
# 素因数分解の結果を返す
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
N = int(input())
res = collections.Counter(prime_factorize(N)) # Counter({2: 4, 3: 1})
keys = list(res.keys()) # [2, 3]
length = len(keys)
ans = 0
# 因数に関する処理
for i in range(length):
num = keys[i] # 因数
beki = res[num] # 因数numの個数
temp = 1
while(beki >= temp):
beki -= temp
ans += 1
temp += 1
print(ans) | from collections import Counter
def aprime_factorize(n: int) -> list:
return_list = []
while n % 2 == 0:
return_list.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
return_list.append(f)
n //= f
else:
f += 2
if n != 1:
return_list.append(n)
return return_list
judge = []
cnt = 0
while len(judge) <= 40:
for i in range(cnt+1):
judge.append(cnt)
cnt += 1
N = int(input())
list = Counter(aprime_factorize(N)).most_common()
res = 0
for i, li in enumerate(list):
res += judge[li[1]]
print(res)
| 1 | 16,798,982,786,020 | null | 136 | 136 |
class UnionFind:
def __init__(self, sz: int):
self._par: list[int] = [-1] * sz
def root(self, a: int):
if self._par[a] < 0:
return a
self._par[a] = self.root(self._par[a])
return self._par[a]
def size(self, a: int):
return -self._par[self.root(a)]
def unite(self, a, b):
a = self.root(a)
b = self.root(b)
if a != b:
if self.size(a) < self.size(b):
a, b = b, a
self._par[a] += self._par[b]
self._par[b] = a
if __name__ == '__main__':
N, M = map(int, input().split())
uf = UnionFind(N + 1)
for i in range(M):
a, b = map(int, input().split())
uf.unite(a, b)
ans = 1
for i in range(1, N + 1):
ans = max(ans, uf.size(i))
print(ans) | from collections import Counter
class UnionFind:
def __init__(self,num:int):
self.r = [-1 for i in range(num)]
def root(self,x:int):
if(self.r[x] < 0):
return x
self.r[x] = self.root(self.r[x])
return self.r[x]
def unite(self,x:int,y:int):
rx = self.root(x)
ry = self.root(y)
if(rx == ry):
return False
if(self.r[rx] > self.r[ry]):
rx,ry = ry,rx
self.r[rx] += self.r[ry]
self.r[ry] = rx
return True
def size(self,x:int):
return -self.r[self.root(x)]
N,M = map(int,input().split())
group = UnionFind(N)
for i in range(M):
A,B = map(int,input().split())
group.unite(A-1,B-1)
ans = 0
for i in range(N):
ans = max(ans,group.size(i))
print(ans)
| 1 | 3,991,711,811,542 | null | 84 | 84 |
a = int(input())
b_list = list(map(int, input().split()))
count = 0
mini=a
for i in range(len(b_list)):
if b_list[i] <= mini:
count += 1
mini = b_list[i]
print(count) | import sys
def main():
N = int(input())
P = list(map(int, input().split()))
min_so_far = sys.maxsize
ans = 0
for p in P:
if p <= min_so_far:
ans += 1
min_so_far = p
print(ans)
if __name__ == '__main__':
main()
| 1 | 85,639,818,304,220 | null | 233 | 233 |
s=input()
n=len(s)//2
s1=s[:n]
s2=s[-n:]
s2=s2[::-1]
cnt=0
for i in range(len(s1)):
if s1[i]!=s2[i]:
cnt+=1
print(cnt)
| s = str(input())
count = 0
for i, j in zip(s, s[::-1]):
if i != j:
count += 1
else:
pass
print(count//2) | 1 | 120,099,806,385,590 | null | 261 | 261 |
K, X = map(int, input().split())
print('Yes' if 500 * K >= X else 'No') | a,X=map(int, input().split())
if(a*500>=X):
print('Yes')
else:
print('No')
| 1 | 98,341,688,039,518 | null | 244 | 244 |
def main():
n, k = map(int, input().split())
d_lst = [0 for _ in range(k)]
a_lst = [0 for _ in range(k)]
for i in range(k):
d_lst[i] = int(input())
a_lst[i] = list(map(int, input().split()))
snuke_lst = [0 for _ in range(n)]
for i in range(k):
for a in a_lst[i]:
snuke_lst[a - 1] = 1
ans = n - sum(snuke_lst)
print(ans)
if __name__ == "__main__":
main()
|
N,k = map(int,input().split())
A = [0] * N
#print(A)
#print(type(A))
for okashi_number in range(k):
di = int(input())
D = list(map(int,input().split()))
for x in range(di):
A[D[x]-1]= 1
#print(A)
count = 0
for i in range(N):
if A[i] == 0:
count = count + 1
print(count) | 1 | 24,515,433,736,028 | null | 154 | 154 |
x = input()
a, b, c = tuple(x.split())
a = int(a)
b = int(b)
c = int(c)
abc = sorted([a, b, c])
print(abc[0], abc[1], abc[2]) | N = map( int , raw_input().split() )
N.sort()
print "%d %d %d" %( N[0] , N[1] , N[2] ) | 1 | 433,297,885,020 | null | 40 | 40 |
if __name__ == '__main__':
n = int(input())
if n % 2 == 0:
print(int(n/2 - 1))
else:
print(int((n-1)/2)) | def solve(n):
return (n - 1) // 2
assert solve(4) == 1
assert solve(999999) == 499999
n = int(input())
print(solve(n)) | 1 | 153,336,417,000,800 | null | 283 | 283 |
a,b = map(int,raw_input().split())
print a/b
print a%b
print "%.5f" % (a/float(b)) | n = int(input())
cnt = 0
for i in range(n):
if (i + 1) % 2 == 1:
cnt += 1
print(cnt/n)
| 0 | null | 89,285,955,347,778 | 45 | 297 |
s = input()
cnt_l = [0]*(len(s)+1)
cnt_r = [0]*(len(s)+1)
for i in range(1, len(s)+1):
if s[i-1] == "<":
cnt_l[i] = cnt_l[i-1] + 1
else:
cnt_l[i] = 0
for i in range(len(s)-1, -1, -1):
if s[i] == ">":
cnt_r[i] = cnt_r[i+1]+1
else:
cnt_r[i] = 0
ans = 0
for l, r in zip(cnt_l, cnt_r):
ans += max(l, r)
print(ans)
| from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
INF = float("inf")
import bisect
N = int(input())
a = [0] + list(map(int, input().split()))
o = [a[2*i+1] for i in range(N//2)]
o = list(itertools.accumulate(o))
dp = [0 for i in range(N+1)]
dp[0] = dp[1] = 0
dp[2] = max(a[1], a[2])
if N > 2: dp[3] = max([a[1], a[2], a[3]])
if N > 3:
for i in range(4, N+1):
if i % 2 == 0:
dp[i] = max(dp[i-2] + a[i], o[(i-3)//2] + a[i-1])
else:
dp[i] = max([dp[i-2] + a[i], dp[i-3] + a[i-1], o[(i-2)//2] ])
print(dp[N])
| 0 | null | 97,184,746,901,484 | 285 | 177 |
def solve():
K = int(input())
S = input()
if len(S) > K:
print("{}...".format(S[:K]))
else:
print(S)
if __name__ == "__main__":
solve() | k = int(input())
s = str(input())
if len(s) <= k:
print(s)
else:
ans = s[0:k] + '...'
print(ans) | 1 | 19,540,309,836,768 | null | 143 | 143 |
import math
a,b,x=map(int,input().split())
volume=a*a*b
if volume>=2*x:
theta=(a*b*b)/(2*x)
else:
theta=2*(volume-x)/(a*a*a)
print(math.degrees(math.atan(theta))) | n = int(input())
s = []
t = []
for i in range(n):
s_, t_ = map(str, input().split())
s.append(s_)
t.append(int(t_))
x = input()
for i in range(n):
if s[i] == x:
break
ans = 0
for j in range(n-1, i, -1):
ans += t[j]
print(ans) | 0 | null | 130,746,810,213,646 | 289 | 243 |
n = int(input())
xy_sum = []
xy_dif = []
for i in range(n) :
x, y = map(int, input().split())
xy_sum.append(x + y)
xy_dif.append(x - y)
print(max(abs(max(xy_sum) - min(xy_sum)), abs(max(xy_dif) - min(xy_dif)))) | N = int(input())
A = list(map(int, input().split()))
A_MAX = 10 ** 5
idx = [0] * (A_MAX + 1)
sum = 0
for i in A:
idx[i] += 1
sum += i
Q = int(input())
for i in range(Q):
B, C = list(map(int, input().split()))
sub = C - B
num = idx[B]
idx[B] = 0
idx[C] += num
sum += (sub * num)
print(sum) | 0 | null | 7,788,082,814,788 | 80 | 122 |
n=list(map(int,input()))
if 7 in n:
print("Yes")
else:
print("No")
| def main():
h,w = map(int,input().split(" "))
s = [list(input()) for i in range(h)]
dp = [[0]*w for i in range(h)]
dp[0][0] = 1 if s[0][0]=="#" else 0
for i in range(1,h):
sgmdown = 1 if s[i][0]=="#" and s[i-1][0]=="." else 0
dp[i][0] = dp[i-1][0] + sgmdown
for j in range(1,w):
sgmright = 1 if s[0][j]=="#" and s[0][j-1]=="." else 0
dp[0][j] = dp[0][j-1] + sgmright
for i in range(1,h):
for j in range(1,w):
sgmdown = 1 if s[i][j]=="#" and s[i-1][j]=="." else 0
sgmright = 1 if s[i][j]=="#" and s[i][j-1]=="." else 0
dp[i][j] = min(dp[i-1][j]+sgmdown, dp[i][j-1]+sgmright)
print(dp[h-1][w-1])
main() | 0 | null | 41,773,529,873,322 | 172 | 194 |
n = int(input())
memo = {}
for i in range(n):
man_idx = i
count = int(input())
comment = [ list(map(int,input().split())) for _ in range(count) ]
memo[man_idx] = comment
ans = 0
for i in range(2**n):
sub_ans = 0
is_true = True
for j in range(n):
if i >> j & 1:
sub_ans += 1
for x, y in memo[j]:
if (i >> (x-1) & 1) != int(y):
is_true = False
break
if is_true:
ans = max(sub_ans, ans)
print(ans) | import sys
sys.setrecursionlimit(10 ** 8)
ni = lambda: int(sys.stdin.readline())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
ns = lambda: sys.stdin.readline().rstrip()
MOD = 10 ** 9 + 7
N, K = nm()
def solve():
ans = 0
tbl = [0] * (K + 1)
for i in range(K, 0, -1):
m = K // i
p = pow(m, N, MOD)
j = 2
while j * i <= K:
p += MOD - tbl[j * i] % MOD
p %= MOD
j += 1
tbl[i] = p
ans += i * p % MOD
ans %= MOD
return ans
print(solve())
| 0 | null | 79,454,966,954,592 | 262 | 176 |
import sys
n = int(sys.stdin.readline()[:-1])
S = sorted(list(map(int, (sys.stdin.readline()[:-1]).split())))
q = int(sys.stdin.readline()[:-1])
T = sorted(list(map(int, (sys.stdin.readline()[:-1]).split())))
count = 0
for i in T:
x = 0
while x < len(S):
if i == S[x]:
count += 1
S = S[x:]
break
x += 1
print(count) | N = int(input())
S,T = input().split()
print(''.join([X+Y for (X,Y) in zip(S,T)])) | 0 | null | 55,974,684,404,000 | 22 | 255 |
def f(n):
ans=1
while n!=0:
ans+=1
n%=bin(n).count("1")
return ans
n=int(input())
x=input()
o=x.count("1")
if o==0:exit(print(*[1]*n))
if o==1:
if x[-1]=="1":
ans=[2]*n
ans[-1]=0
else:
ans=[1]*n
ans[-1]=2
ans[x.index("1")]=0
exit(print(*ans))
mo=0
mz=0
for i in range(n):
if x[n-i-1]=="1":
mo=(pow(2,i,o+1)+mo)%(o+1)
mz=(pow(2,i,o-1)+mz)%(o-1)
for i in range(n):
if x[i]=="1":
m=(mz-pow(2,n-i-1,o-1))%(o-1)
else:
m=(mo+pow(2,n-i-1,o+1))%(o+1)
print(f(m)) | dic = set()
n = int(input())
for i in range(n):
s = input()
if s[0] == 'i':
dic.add(s[7:])
else: print("yes" if s[5:] in dic else "no")
| 0 | null | 4,122,934,660,712 | 107 | 23 |
from itertools import combinations
n = int(input())
a = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
answer = ['no']*q
for i in range(1, n+1):
for nums in combinations(a, i):
val = sum(nums)
if val in m:
index = [i for i, num in enumerate(m) if val == num]
for i in index:
answer[i] = 'yes'
for i in answer:
print(i)
| def subset_sum(s, a):
dict = {}
return subset_rec(0, s, a, dict)
def subset_rec(i, s, a, dict):
key = str(i) + '-' + str(s)
ret = False
if key in dict:
ret = dict[key]
elif s == 0:
ret = True
elif i >= len(a):
ret = False
else:
ret = subset_rec(i+1, s-a[i], a, dict) or subset_rec(i+1, s, a, dict)
dict[key] = ret
return ret
n = int(input())
a = list(map(int, input().split()))
p = int(input())
q = list(map(int, input().split()))
for i in range(p):
if subset_sum(q[i], a):
print('yes')
else:
print('no')
| 1 | 96,219,344,530 | null | 25 | 25 |
N = int(input())
a = list(map(int, input().split()))
mod = 10**9 + 7
s = 0
for i in a:
s += i
ans = 0
for i in range(N):
s -= a[i]
ans += a[i] * s % mod
print(ans%mod)
| n = int(input())
a = list(map(int, input().split()))
m = 1000000007
print(((sum(a)**2 - sum(map(lambda x: x**2, a))) // 2) % m) | 1 | 3,763,646,494,240 | null | 83 | 83 |
h, w = map(int, input().split())
if h == 1 or w == 1:
print(1)
else:
print((-(-w//2)) * (-(-h//2)) + (w//2) * (h//2))
| '''
いちばん簡単なのは建物とフロアごとにリスト作って、足し引き
'''
#部屋、フロア、建物をクラスで定義。まあ、クラスにしなくてもいいんだけど
a = int(input())
n = 10
m = 3
o = 4
h = [
[
[0 for i in range(n)]
for j in range(m)]
for k in range(o)]
#w, x, y, z = 3, 1, 8, 4
for i in range(a):
w,x,y,z = map(int, input().split())
h[w-1][x-1][y-1] += z
#print(h[1][1])
#建物と建物仕切り
def makeFence():
fence = '#' * 20
print(fence)
#部屋を表示する関数
def showRoom(f):
for k in range(len(f)-1):
print(' ' + str(f[k]), end='')
print(' ' + str(f[len(f)-1]))
#フロアを表示する関数
def showFloor(b):
j = 0
while j < len(b):
f = b[j]
showRoom(f)
j += 1
def statusShow(h):
for i in range(len(h)-1):
b = h[i]
showFloor(b)
makeFence()
showFloor(h[len(h)-1])
statusShow(h)
#b = statusShow(h)
#makeFence()
#print(b)
| 0 | null | 25,829,600,224,182 | 196 | 55 |
a, b = map(int, input().split())
d = int(a / b)
r = a % b
f = float(a / b)
print("{0} {1} {2:.6f}".format(d, r, f)) | (n,k),p,c=[[*map(int,t.split())]for t in open(0)]
a=-9e9
for i in range(n):
s=f=m=0;x,*l=i,
while~f:x=p[x]-1;s+=c[x];l+=s,;m+=1;f-=x==i
for j in range(min(m,k)):a=max(a,l[j]+(~j+k)//m*s*(s>0))
print(a) | 0 | null | 3,022,592,324,320 | 45 | 93 |
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
N = int(input())
A = list(map(int, input().split()))
def get_primenumber(number): # エラトステネスの篩
prime_list = []
search_list = list(range(2, number + 1))
# search_listの先頭の値が√nの値を超えたら終了
while search_list[0] <= math.sqrt(number):
# search_listの先頭の値が√nの値を超えたら終了
# search_listの先頭をprime_listに入れて、先頭をリストに追加して削除
head_num = search_list.pop(0)
prime_list.append(head_num)
# head_numの倍数を除去
search_list = [num for num in search_list if num % head_num != 0]
# prime_listにsearch_listを結合
prime_list.extend(search_list)
return prime_list
def prime_factor_table(n):
table = [0] * (n + 1)
for i in range(2, n + 1):
if table[i] == 0:
for j in range(i + i, n + 1, i):
table[j] = i
return table
def prime_factor(n, prime_factor_table):
prime_count = collections.Counter()
while prime_factor_table[n] != 0:
prime_count[prime_factor_table[n]] += 1
n //= prime_factor_table[n]
prime_count[n] += 1
return prime_count
table = prime_factor_table(10**6+10)
numset = set()
for i in A:
thedic = prime_factor(i, table)
for l in thedic.keys():
flag = True
if l in numset and l != 1:
flag = False
break
if flag:
tmpset = set(thedic.keys())
numset |= tmpset
else:
break
if flag:
print('pairwise coprime')
sys.exit()
else:
flag = True
theset = set(prime_factor(A[0], table).keys())
for i in A[1:]:
thedic = prime_factor(i, table)
theset = theset & set(thedic.keys())
if len(theset) == 0:
print('setwise coprime')
flag = False
break
if flag:
print('not coprime')
if __name__ == '__main__':
solve() | a,b,c=map(int,input().split())
print(['No','Yes'][4*a*b<(c-a-b)**2 and a+b<c]) | 0 | null | 27,670,311,372,638 | 85 | 197 |
s = raw_input().split()
[N] = s
N = int(N)
print ((N-1)/2)
| N,M = map(int,input().split())
A = [int(x) for x in input().split()]
if N - sum(A) >= 0 :
print(N-sum(A))
else :
print("-1") | 0 | null | 92,152,490,761,760 | 283 | 168 |
r=int(input())
print(2*3.14*r) | a = int(input())
b = int(input())
n = int(input())
t = max(a, b)
print((n + t - 1) // t) | 0 | null | 60,151,054,569,732 | 167 | 236 |
from math import log, floor
N, K = map(int, input().split())
print(floor(log(N, K))+1) | from math import sqrt, ceil
n = int(input())
def ans(n):
if n == 2:
return 1
# divisors of n-1
count = sum(2*int((n-1)%i==0) for i in range(2, ceil(sqrt(n-1))))
# check the square root of n-1
if ceil(sqrt(n-1)) == int(sqrt(n-1)):
count += 1
# n-1 is always a divisor of n-1
count += 1
# divisors of n
for i in range(2, ceil(sqrt(n))):
if n%i==0:
x = n
while x%i == 0:
x = x//i
count += int((x-1)%i==0)
other_divisor = n//i
x = n
while x%other_divisor == 0:
x = x//other_divisor
count += int((x-1)%other_divisor==0)
# check the square root of n
if ceil(sqrt(n)) == int(sqrt(n)):
i = int(sqrt(n))
x = n
while x%i == 0:
x = x//i
count += int((x-1)%i==0)
# n is always a divisor of n that reduces to 1 by division once
count += 1
return(count)
print(ans(n)) | 0 | null | 52,691,560,228,132 | 212 | 183 |
temp = input()
n = int(input())
for _ in range(n):
order,a,b,*value = input().split()
a = int(a)
b = int(b)
if order == "print":
print(temp[a:b+1])
elif order == "reverse":
rev = temp[a:b+1]
temp = temp[:a] + rev[::-1] + temp[b+1:]
else:#replace
temp = temp[:a] + value[0] + temp[b+1:]
| import bisect
import statistics
n = int(input())
a = list((int(x) for x in input().split()))
a.sort()
incl = []
score = 0
for i in range(len(a)):
ain = a.pop()
incl.append(ain)
if i==0: continue
if (len(incl)%2 == 1):
score += incl[ int(len(incl)/2) ]
else:
# smaller of middle two
score += incl[ int(len(incl)/2)-1 ]
print(score) | 0 | null | 5,617,812,420,950 | 68 | 111 |
S = input()
ans = ''.join(set(S))
if len(ans) == 1:
print('No')
else:
print('Yes')
| s = input()
if 'A' in s and 'B' in s:
print('Yes')
else:
print('No') | 1 | 54,585,415,004,640 | null | 201 | 201 |
class UnionFind:
def __init__(self, n=1):
self.parent = [i for i in range(n)]
self.rank = [0] * n
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.parent[y] = x
def is_same(self, x, y):
return self.find(x) == self.find(y)
N, M = map(int, input().split())
uf = UnionFind(N)
for i in range(M):
a, b = map(int, input().split())
uf.union(a-1, b-1)
for i in range(N):
uf.find(i)
print(len(set([uf.find(i) for i in range(N)])) - 1) | #!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
S = readline().rstrip().decode()
print('x' * len(S))
if __name__ == '__main__':
main()
| 0 | null | 37,547,135,829,760 | 70 | 221 |
import sys
from operator import itemgetter
sys.setrecursionlimit(5000)
input = sys.stdin.readline
TIME = 0
VAL = 1
N, T = [int(a) for a in input().split()]
time_value = [None] * (N + 1)
time_value[0] = (-1, -1)
for i in range(1, N + 1):
time_value[i] = tuple(int(a) for a in input().split())
# Sort the array in the increasing order of value
time_value.sort(key = itemgetter(VAL))
# T by (N + 1) table for knapsack problem
# maximum possible time is T-1
dp_table = [[-1] * T for _ in range(N + 1)]
# Fill in dp_table i.e. solve knapsack problem
for t in range(0, T):
dp_table[0][t] = 0
for n in range(1, N + 1):
dp_table[n][0] = 0
for t in range(1, T):
if time_value[n][TIME] > t:
dp_table[n][t] = dp_table[n - 1][t]
else:
dp_table[n][t] = max(dp_table[n - 1][t],
time_value[n][VAL] + dp_table[n - 1][t - time_value[n][TIME]])
val_acum = time_value[N][VAL]
t = T - 1
max_val = val_acum + dp_table[N - 1][t]
for n in range(N - 1, 0, -1): # food to eat at the end
val_acum += time_value[n][VAL] # value[N] + value[N-1] + ... + value[n]
t -= time_value[n + 1][TIME] # T - 1 - (time[N] + time[N-1] + ... + time[n + 1])
if t < 0: break
tmp = val_acum + dp_table[n - 1][t]
max_val = max(max_val, tmp)
print(max_val) | X = int(input())
for k in range(3, 361):
if (k*X)%360==0:
print(k)
exit() | 0 | null | 82,378,302,620,822 | 282 | 125 |
A,B,C,D = map(int, input().split())
n = 0
if C%B ==0:
if A-(C//B-1)*D > 0:
print('Yes')
else:
print('No')
elif C%B != 0:
if A-(C//B)*D > 0:
print('Yes')
else:
print('No')
| a, b, c, d = map(int, input().split())
while a > 0 and c > 0:
a = a - d
c = c - b
if c <= 0:
print('Yes')
else:
print('No') | 1 | 29,857,471,689,212 | null | 164 | 164 |
N = int(input())
S = input()
assert len(S) == N
count = 0
# j-i = k-jを探す
for i in range(0, len(S)-2):
for j in range(i+1, len(S)-1):
k = j + (j - i)
if k < len(S):
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
count += 1
numR = 0
numG = 0
numB = 0
for s in S:
if s == 'R':
numR += 1
elif s == 'G':
numG += 1
else:
numB += 1
print(numR * numG * numB - count) | l =int(input())
s =input()
r = s.count("R")
g = s.count("G")
b = s.count("B")
A = r * g * b
B = 0
gapmax = (l - 3) // 2
for _ in range(gapmax+1):
for i in range(l-2-2*_):
c1, c2, c3 = s[i], s[i+1+_],s[i+2+2*_]
if not (c1 == c2) and not (c1 == c3) and not (c2 ==c3):
B += 1
print(A-B) | 1 | 36,155,176,352,740 | null | 175 | 175 |
def resolve():
s = input()
print('x'*len(s))
resolve() | S = input()
a = ['x']*len(S)
print(''.join(a)) | 1 | 72,904,759,929,298 | null | 221 | 221 |
s = list(input())
sur_list = [0 for i in range(2019)]
sur = 0
keta = 1
ans = 0
s.reverse()
for i in range(len(s)):
keta = (keta*10)%2019
sur_list[sur] += 1
sur = (int(s[i]) * keta + sur) % 2019
ans += sur_list[sur]
print(ans)
| def main():
P = 2019
S = [int(s) for s in input()]
ans = 0
if P == 2:
for i, v in enumerate(S, start=1):
if v % 2 == 0:
ans += i
elif P == 5:
for i, v in enumerate(S, start=1):
if v == 0 or v == 5:
ans += i
else:
cnt = [0]*P
d = 1
pre = 0
cnt[pre] += 1
for v in S[::-1]:
v *= d
v += pre
v %= P
cnt[v] += 1
d *= 10
d %= P
pre = v
ans = sum(cnt[i]*(cnt[i]-1)//2 for i in range(P))
print(ans)
if __name__ == '__main__':
main()
| 1 | 30,728,043,299,360 | null | 166 | 166 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
As = list(mapint())
mod = 10**9+7
bits = [0]*70
for a in As:
for l in range(a.bit_length()):
if (a>>l)&1:
bits[l] += 1
ans = 0
for i in range(70):
one = bits[i]
zero = N-one
mul = pow(2, i, mod)
ans += one*zero*mul
ans %= mod
print(ans) | def main():
N = int(input())
A = list(map(int, input().split()))
MOD = 10**9+7
# Aの中でd桁目が0,1であるものの個数を求める(p,qとする)
# 全部のd桁目についてループして、ans+=(2**d)*(p*q)
ans = 0
for d in range(60):
p,q = 0,0
for i in range(N):
if A[i]%2==0: p+=1
else: q+=1
A[i] //= 2
ans += ((2**d)*p*q)%MOD
ans %= MOD
print(ans)
main()
| 1 | 122,764,824,287,622 | null | 263 | 263 |
while True:
try:
a, b = raw_input().strip().split(" ")
print len(str(int(a) + int(b)))
except:
break; | # coding: utf-8
import sys
def digit_check(n):
i = 10
digit = 1
while int(n/i) != 0:
i *= 10
digit += 1
return digit
def main():
for line in sys.stdin:
ls = list(map(int, line.split(' ')))
print(digit_check(ls[0]+ls[1]))
if __name__ == '__main__':
main() | 1 | 149,732,860 | null | 3 | 3 |
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n = int(ipt())
a = [int(i) for i in ipt().split()]
suma = sum(a)
ans = 0
can = 1
for i,ai in enumerate(a):
if ai > can:
print(-1)
exit()
suma -= ai
ans += can
if (can-ai)*2 >= suma:
can = suma
else:
can = (can-ai)*2
print(ans)
return
if __name__ == '__main__':
main()
| N=int(input())
A=list(map(int,input().split()))
ans=0
tree=1
node=sum(A)
flag=0
for i in A:
ans+=i
node-=i
if i>tree:
ans=-1
break
tree-=i
if tree<node:
ans+=tree
else:
ans+=node
tree=2*tree
print(ans) | 1 | 18,793,378,400,448 | null | 141 | 141 |
import numpy as np
R = int(input())
print(R * 2 * np.pi) | import math
R = int(input())
circum = R * 2 * math.pi
print(circum) | 1 | 31,460,606,103,744 | null | 167 | 167 |
from operator import itemgetter
n = int(input())
s = []
for i in range(n):
l = list(map(int, input().split()))
rang = [l[0] - l[1], l[0] + l[1]]
s.append(rang)
s_sort = sorted(s, key=itemgetter(1))
ans = 0
last = -float("inf")
for i in range(n):
if last <= s_sort[i][0]:
ans += 1
last = s_sort[i][1]
print(ans)
| n = int(input())
n_l = list(map(int, input().split()))
VORDER = 10 ** 18
ans = 1
if 0 in n_l:
ans = 0
else:
for i in n_l:
ans = i * ans
if ans > VORDER:
ans = -1
break
print(ans)
| 0 | null | 53,067,456,467,392 | 237 | 134 |
a = int(input())
if a >= 30 :
print("Yes")
else:print("No") | a=int(input(''))
if a>=30:
print('Yes')
else:
print('No') | 1 | 5,795,867,557,450 | null | 95 | 95 |
N = int(input())
A = list(map(int,input().split()))
m = max(A) + 1
cnt = [0]*m
for i in A:
cnt[i] += 1
ans = 0
for i in range(1,m):
if cnt[i]:
if cnt[i]==1:
ans += 1
for j in range(i,m,i):
cnt[j] = 0
print(ans) | import sys
sys.setrecursionlimit(10**9)
n,m = list(map(int,input().split()))
d = {}
for i in range(m):
fr, to = list(map(int,input().split()))
d[fr] = d.get(fr, []) + [to]
d[to] = d.get(to, []) + [fr]
visited = [0 for i in range(n+1)]
def connect(node, i):
visited[node] = i
if node in d:
for neig in d[node]:
if visited[neig] == 0:
connect(neig, i)
ans = 1
for key in range(1,n+1):
if visited[key] == 0:
connect(key, ans)
ans += 1
print(max(visited)-1)
| 0 | null | 8,299,116,023,908 | 129 | 70 |
def main():
n = int(input())
a = list(map(int,input().split()))
ki = [0 for i in range(n+1)]
ki[0] = 1
for i in range(1,n+1):
ki[i] = 2*(ki[i-1] - a[i-1])
if ki[i]<=0:
print(-1)
return
if ki[-1]<a[-1]:
print(-1)
return
ki[-1] = a[-1]
for i in range(n):
ki[n-1-i] = min(ki[n-1-i],ki[n-i]+a[n-1-i])
print(sum(ki))
if __name__ == "__main__":
main()
| from math import ceil
n = int(input())
A = list(map(int,input().split()))[::-1]
mn,mx = A[0], A[0]
step = [[mn,mx]]
for i in range(1, n+1):
mn = ceil(mn/2) + A[i]
mx = mx + A[i]
step.append([mn,mx])
if not mn<=1 and 1<=mx:
print(-1)
else:
step = step[::-1]
A = A[::-1]
now = 1
ans = 1
for i in range(1, n+1):
now = min(step[i][1],
(now-A[i-1])*2)
ans += now
print(ans) | 1 | 18,990,278,692,332 | null | 141 | 141 |
a=int(input())
b=100
i=0
while b<a:
b+= b // 100
i+=1
print(i) | import sys
def input(): return sys.stdin.readline().rstrip()
import math
X = int(input())
ans = False
money = 100
year = 0
while money < X:
money += money // 100
year += 1
print(year)
| 1 | 27,160,321,293,440 | null | 159 | 159 |
square = input()
down = []
edge = []
pool = []
for i, strings in enumerate(square):
if strings == "\\":
down.append(i)
elif down and strings == "/":
left = down.pop()
area = i - left
while edge:
if edge[-1] < left:
break
edge.pop()
area += pool.pop()
edge.append(left)
pool.append(area)
print(sum(pool))
print(len(pool), *pool) | S = raw_input()
S1, S2 = [], []
ans = pool = 0
for i in xrange(len(S)):
if S[i] == "/" and len(S1) > 0:
j = S1.pop()
ans += i - j
a = i - j
while (len(S2) > 0 and S2[-1][0] > j):
a += S2.pop()[1]
S2.append([j, a])
if S[i] == "\\":
S1.append(i)
print ans
if len(S2) > 0:
print len(S2), " ".join(map(str, [a for j, a in S2]))
else:
print 0 | 1 | 58,408,814,910 | null | 21 | 21 |
A = list(map(float, input().split()))
if(A[0]/A[2] <= A[1]):
print("Yes")
else:
print("No") | # A - Don't be late
D, T, S = map(int, input().split())
if (D + S - 1) // S <= T:
print('Yes')
else:
print('No') | 1 | 3,570,920,660,806 | null | 81 | 81 |
import sys
N,K=map(int,input().split())
plist=[0]+list(map(int,input().split()))
clist=[-float("inf")]+list(map(int,input().split()))
if max(clist)<=0:
print(max(clist))
sys.exit(0)
if K<=N:
max_answer=0
for i in range(1,N+1):
pos=i
max_score=0
score=0
for c in range(K):
pos=plist[pos]
score+=clist[pos]
max_score=max(score,max_score)
#print(i,max_score)
max_answer=max(max_answer,max_score)
print(max_answer)
sys.exit(0)
max_answer=0
for i in range(1,N+1):
pos=i
cycle_list=[]
score_list=[]
for _ in range(N):
pos=plist[pos]
cycle_list.append(pos)
score_list.append(clist[pos])
if pos==i:
break
num_cycle=K//len(cycle_list)
cycle_score=sum(score_list)
#print(cycle_list,score_list,num_cycle,cycle_score)
score=0
max_score=0
if cycle_score>=0:
score+=(num_cycle-1)*cycle_score
K2=K-len(cycle_list)*(num_cycle-1)
for _ in range(K2):
pos=plist[pos]
score+=clist[pos]
max_score=max(score,max_score)
#print(i,max_score)
max_answer=max(max_answer,max_score)
print(max_answer) | import sys
import resource
sys.setrecursionlimit(10000)
n,k=map(int,input().rstrip().split())
p=list(map(int,input().rstrip().split()))
c=list(map(int,input().rstrip().split()))
def find(start,now,up,max,sum,count,flag):
if start==now:
flag+=1
if start==now and flag==2:
return [max,sum,count]
elif count==up:
return [max,sum,count]
else:
count+=1
sum+=c[p[now-1]-1]
if max<sum:
max=sum
return find(start,p[now-1],up,max,sum,count,flag)
kara=[-10000000000]
for i in range(1,n+1):
m=find(i,i,n,c[p[i-1]-1],0,0,0)
if m[2]>=k:
m=find(i,i,k,c[p[i-1]-1],0,0,0)
if m[0]>kara[0]:
kara[0]=m[0]
result=kara[0]
elif m[1]<=0:
if m[0]>kara[0]:
kara[0]=m[0]
result=kara[0]
else:
w=k%m[2]
if w==0:
w=m[2]
spe=find(i,i,w,c[p[i-1]-1],0,0,0)[0]
if m[1]+spe>m[0] and m[1]*(k-w)//m[2]+spe>kara[0]:
kara[0]=m[1]*(k-w)//m[2]+spe
elif m[1]+spe<=m[0] and m[1]*((k-w)//m[2]-1)+m[0]>kara[0]:
kara[0]=m[1]*((k-w)//m[2]-1)+m[0]
result=kara[0]
print(result) | 1 | 5,407,866,142,360 | null | 93 | 93 |
N = int(input())
def func(x):
if len(x) == N:
print("".join(x))
return
last = ord(max(x)) - ord("a") + 1 if x else 0
for i in range(min(26, last) + 1):
x.append(chr(ord("a") + i))
func(x)
x.pop()
func([])
| # coding: utf-8
# Your code here!
import math
while True:
n = int(input())
if n == 0:
break
s = list(map(int,input().split()))
sum = 0
for i in range(len(s)):
sum += s[i]
m = sum/len(s)
a = 0
for i in range(len(s)):
a += s[i]*s[i]
a = a/len(s)
print("{0:.8f}".format(math.sqrt(a-m*m)))
| 0 | null | 26,106,908,893,592 | 198 | 31 |
from sys import stdin
def readline_from_stdin() -> str:
return stdin.readline().rstrip
if __name__ == '__main__':
N, K, = input().split()
A = [int(i) for i in input().split()]
N, K = int(N), int(K)
for i in range(N-K):
if A[i] < A[K+i]:
print("Yes")
else:
print("No") | n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(0, n - k):
print("Yes" if a[i + k] > a[i] else "No") | 1 | 7,089,699,725,580 | null | 102 | 102 |
a,b = input().split()
t = a*int(b)
q = b*int(a)
if t < q:
print(t)
else:
print(q) | import sys
input = sys.stdin.readline
S = input()
print(S[:3])
| 0 | null | 49,682,150,638,890 | 232 | 130 |
n,k=map(int,input().split())
h=[int(x) for x in input().split() if int(x)>=k]
print(len(h)) | n, k = map(int, input().split())
h = list(map(int, input().split()))
ans = len([i for i in h if i >= k])
print(ans)
| 1 | 179,002,426,414,990 | null | 298 | 298 |
def main():
a = list(map(int, list(input())))
n = len(a)
dp = [[0, 0] for _ in [0]*(n+1)]
dp[0][1] = 1
for i in range(n):
dp[i+1][0] = min(dp[i][0]+a[i], dp[i][1]+10-a[i])
dp[i+1][1] = min(dp[i][0]+a[i]+1, dp[i][1]+9-a[i])
print(dp[n][0])
main()
| arr = list([input() for _ in range(10)])
arr.sort(reverse=True)
for i in range(3):
print arr[i]
| 0 | null | 35,378,025,958,750 | 219 | 2 |
s = input()
n = len(s) // 2
j = -1
t = 0
for i in range(n):
if s[i] != s[j]:
t += 1
j -= 1
print(t) | s=input()
ans = 0
for i in range(len(s)):
j = len(s)-i-1
if i > j: break
if s[i] != s[j]: ans += 1
print(ans) | 1 | 119,901,953,189,568 | null | 261 | 261 |
class Factorial():
def __init__(self, mod=10**9 + 7):
self.mod = mod
self._factorial = [1]
self._size = 1
self._factorial_inv = [1]
self._size_inv = 1
def __call__(self, n):
return self.fact(n)
def fact(self, n):
''' n! % mod '''
if n >= self.mod:
return 0
self._make(n)
return self._factorial[n]
def _make(self, n):
if n >= self.mod:
n = self.mod
if self._size < n+1:
for i in range(self._size, n+1):
self._factorial.append(self._factorial[i-1]*i % self.mod)
self._size = n+1
def fact_inv(self, n):
''' n!^-1 % mod '''
if n >= self.mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
self._make(n)
if self._size_inv < n+1:
self._factorial_inv += [-1] * (n+1-self._size_inv)
self._size_inv = n+1
if self._factorial_inv[n] == -1:
self._factorial_inv[n] = self.modinv(self._factorial[n])
return self._factorial_inv[n]
@staticmethod
def xgcd(a, b):
'''
Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
'''
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(self, n):
g, x, _ = self.xgcd(n, self.mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % self.mod
def comb(self, n, r):
''' nCr % mod '''
if r > n:
return 0
t = self(n)*self.fact_inv(n-r) % self.mod
return t*self.fact_inv(r) % self.mod
def comb_with_repetition(self, n, r):
''' nHr % mod '''
t = self(n+r-1)*self.fact_inv(n-1) % self.mod
return t*self.fact_inv(r) % self.mod
def perm(self, n, r):
''' nPr % mod '''
if r > n:
return 0
return self(n)*self.fact_inv(n-r) % self.mod
x, y = sorted(map(int, input().split()))
q, r = divmod(x+y, 3)
if r != 0:
print(0)
else:
comb = Factorial().comb
print(comb(q, y-q))
| import sys
from functools import reduce
X, Y = map(int, input().split())
mod = 10**9 + 7
if (X+Y)%3 != 0:
print(0)
sys.exit()
if 2 * min(X, Y) < max(X, Y):
print(0)
sys.exit()
def f(n, A):
if A == 0:
return 1
bunsi = reduce(lambda x, y: x*y%mod, range(n, n-A, -1))
bunbo = reduce(lambda x, y: x*y%mod, range(1, A+1))
return bunsi * pow(bunbo, mod-2, mod) % mod
ans = 0
r, d = 0, 0
if X == Y:
r, d = X//3, Y//3
ans = f(r+d, d)%mod
else:
r = abs(X-Y) + ((X+Y) - 3*abs(X-Y))//6
d = ((X+Y) - 3*abs(X-Y))//6
ans = f(r+d, d)%mod
print(ans) | 1 | 150,164,053,853,662 | null | 281 | 281 |
n,k=map(int,input().split())
p=list(map(int,input().split()))
dp=[0]*(n-k+1)
dp[0]=sum(p[:k])
for i in range(n-k):
dp[i+1]=dp[i]+p[k+i]-p[i]
print((max(dp)+k)/2) | n,m = map(int,input().split())
v1 = [ list(map(int,input().split())) for i in range(n) ]
v2 = [ int(input()) for i in range(m) ]
for v in v1:
print( sum([ v[i] * v2[i] for i in range(m) ])) | 0 | null | 38,059,260,123,584 | 223 | 56 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, 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 = 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):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, 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()}
n, m, k = map(int, input().split())
fr = UnionFind(n)
bl = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
bl[a-1].append(b-1)
bl[b-1].append(a-1)
fr.union(a-1, b-1)
for _ in range(k):
c, d = map(int, input().split())
if fr.same(c-1, d-1):
bl[c-1].append(d-1)
bl[d-1].append(c-1)
ans = []
for i in range(n):
s = fr.size(i) - len(bl[i]) - 1
ans.append(s)
print(*ans) | def Find(x, par):
if par[x] < 0:
return x
else:
par[x] = Find(par[x], par)
return par[x]
def Unite(x, y, par, rank):
x = Find(x, par)
y = Find(y, par)
if x != y:
if rank[x] < rank[y]:
par[y] += par[x]
par[x] = y
else:
par[x] += par[y]
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
def Same(x, y, par):
return Find(x, par) == Find(y, par)
def Size(x, par):
return -par[Find(x, par)]
import sys
input = sys.stdin.readline
n, m, k = map(int, input().split())
par = [-1]* n
rank = [0]*n
C = [0]*n
for i in range(m):
a, b = map(int, input().split())
a, b = a-1, b-1
C[a] += 1
C[b] += 1
Unite(a, b, par, rank)
ans = [0]*n
for i in range(n):
ans[i] = Size(i, par)-1-C[i]
for i in range(k):
c, d = map(int, input().split())
c, d = c-1, d-1
if Same(c, d, par):
ans[c] -= 1
ans[d] -= 1
print(*ans)
| 1 | 61,552,704,745,620 | null | 209 | 209 |
N = int(input())
A = list(map(int, input().split()))
cnt = [0] * (10**6 + 1)
for i in range(N):
cnt[A[i]] += 1
flag = True
for i in range(2, 10**6 + 1):
multiple = 0
for j in range(i, 10**6 + 1, i):
multiple += cnt[j]
if multiple == N:
print("not coprime")
exit()
if multiple >= 2:
flag = False
print("pairwise coprime" if flag else "setwise coprime")
| N = int(input())
for _ in range(N):
a = sorted(map(int, input().split()))
if a[2]**2 == a[0]**2 + a[1]**2:
print("YES")
else:
print("NO") | 0 | null | 2,082,633,046,380 | 85 | 4 |
import sys
N = int(input())
S = list(input())
if len(S)%2 != 0:
print("No")
sys.exit(0)
else:
i = int(len(S)/2)
T = S[0:i]
if T*2 == S:
print("Yes")
else:
print("No") | n,k = map(int,input().split())
p = list(map(int,input().split()))
pp = list(map(lambda x:(x+1)/2,p))
p_rui = [pp[0]]
for i in range(1,n):
p_rui.append(p_rui[i-1]+pp[i])
walist=[p_rui[k-1]]
for i in range(0,n-k):
walist += [p_rui[k+i]-p_rui[i]]
print(max(walist))
| 0 | null | 110,721,847,368,468 | 279 | 223 |
from collections import deque
from bisect import bisect_right
n, d, a = map(int, input().split())
xh = [tuple(map(int, input().split())) for _ in range(n)]
xh.sort()
x, h = zip(*xh)
h = list(map(lambda x: -(-x//a), h))
s = [0] * (n+1)
ans = 0
for i in range(n):
add = max(0, h[i] - s[i])
j = bisect_right(x, x[i]+d*2)
if j < n: s[j] -= add
s[i] += add
ans += add
s[i+1] += s[i]
print(ans)
| import sys
import math
import copy
from heapq import heappush, heappop, heapify
from functools import cmp_to_key
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = float("inf")
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def zaatsu(nums):
ref = list(set(copy.copy(nums)))
ref.sort()
dic = dict()
for i, num in enumerate(ref):
dic[num] = i
return [dic[num] for num in nums]
def solve():
n, d, a = getList()
li = []
for i in range(n):
li.append(getList())
li.sort()
ichi = [x[0] for x in li]
imos = [0] * n
cur = 0
ans = 0
for i, (x, h) in enumerate(li):
cur -= imos[i]
hp = h - cur * a
if hp <= 0:
continue
thr = hp // a
if hp % a != 0:
thr += 1
ans += thr
cur += thr
owari = bisect_right(ichi, x + 2 * d)
if owari != n:
imos[owari] += thr
print(ans)
def main():
n = getN()
for _ in range(n):
solve()
return
if __name__ == "__main__":
# main()
solve()
| 1 | 82,359,672,423,940 | null | 230 | 230 |
from math import ceil
n = int(input())
a = [chr(i) for i in range(97, 97+26)]
s = 0
for i in range(1,100):
l = n - s
s += 26**i
if n <= s:
m = i
break #第m群l番目
name = [0] * m
div = [0] * m
rem = [0] * m
rem[-1] = l
for j in range(m):
div[j] = ceil(rem[j-1] / (26**(m-j-1)))
rem[j] = rem[j-1] % (26**(m-j-1))
if rem[j] == 0:
rem[j] == 26**(m-j-1)
name[j] = a[div[j]-1]
print(''.join(name)) | n = int(input())
digit = 1
while n > 26 ** digit:
n -= 26 ** digit
digit += 1
ans = []
n -= 1
char = 'abcdefghijklmnopqrstuvwxyz'
for i in list(range(digit)):
ans.append(char[n % 26])
n -= n%26
n = int(n/26)
print(''.join(reversed(ans))) | 1 | 11,842,785,054,912 | null | 121 | 121 |
import sys
N, K = (int(x) for x in input().split())
H = list(map(int, input().split()))
ans=0
if K>=N:
print(0)
sys.exit(0)
H.sort(reverse=True)
del H[0:K]
for i in range(len(H)):
ans+=H[i]
print(ans) | N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H.sort()
remain = max(0, N-K)
H = H[:remain]
print(sum(H))
| 1 | 78,851,442,162,180 | null | 227 | 227 |
def main():
n,m,k = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
import itertools
sum_a = list(itertools.accumulate(a))
sum_b = list(itertools.accumulate(b))
if sum_a[-1] + sum_b[-1] <= k:
print(n+m)
return
if a[0] > k and b[0] > k:
print(0)
return
for i in range(n):
if sum_a[i] > k:
break
s_a = i - 1
if sum_a[-1] <= k:
s_a = n-1
now_sum = 0
if s_a >= 0:
now_sum = sum_a[s_a]
for i in range(m):
if now_sum + sum_b[i] > k:
break
s_b = i - 1
ans = s_a + 1 + s_b + 1
now_sum = 0
for a_i in range(s_a-1, -2, -1):
for b_i in range(s_b+1,m):
if a_i < 0:
now_sumtime = sum_b[b_i]
else:
now_sumtime = sum_a[a_i] + sum_b[b_i]
if b_i == m-1 and now_sumtime <= k:
now_sum = a_i + m + 1
break
if now_sumtime > k:
now_sum = a_i + b_i + 1
break
s_b = b_i-1
ans = max(ans, now_sum)
print(ans)
if __name__=='__main__':
main()
| N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
idx_B = M-1
m = sum(B)
an = M
ans = 0
for a in [0] + A:
m += a
while idx_B >= 0 and m > K:
m -= B[idx_B]
idx_B -= 1
an -= 1
if m > K:
break
if an > ans:
ans = an
an += 1
print(ans)
| 1 | 10,698,678,781,466 | null | 117 | 117 |
import math
a,b,c,d=map(int,input().split())
print("Yes") if math.ceil(c/b)<=math.ceil(a/d) else print("No") | a, b, c, d = map(int, input().split())
for i in range(101):
x = c - b*i
y = a - d*i
if x <= 0:
print("Yes")
break
elif y <= 0:
print("No")
break | 1 | 29,721,741,870,830 | null | 164 | 164 |
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, T = lr()
AB = [lr() for _ in range(N)]
AB.sort()
# 時間のかかる物は後ろへ
dp = np.zeros(T, np.int64)
answer = 0
for a, b in AB:
answer = max(answer, dp.max() + b)
prev = dp
dp[a:] = np.maximum(prev[a:], prev[:-a] + b)
print(answer)
| import sys
def input(): return sys.stdin.readline().strip()
def main():
N, T = map(int, input().split())
cv = [tuple(map(int, input().split())) for _ in range(N)]
cv = sorted(cv, key=lambda x : x[0])
dp = [[0]*(T+1) for _ in range(N+1)]
dp_ext = [[0]*(T+1) for _ in range(N+1)]
values = [v for c, v in cv]
max_values = [max(values[i:]) for i in range(N)]
# 貰うdp
for i in range(N):
cost, value = cv[i]
for now in range(cost, T+1):
old = now - cost
dp[i+1][now] = max(dp[i][now], dp[i][old] + value)
for j in range(1, T+1):
dp[i+1][j] = max(dp[i+1][j], dp[i+1][j-1])
for j in range(1, T+1):
dp_ext[i+1][j] = max(dp[i+1][j], dp[i][j-1] + max_values[i], dp_ext[i][j])
print(dp_ext[N][T])
if __name__ == "__main__":
main() | 1 | 151,239,795,318,550 | null | 282 | 282 |
l = map (int, raw_input().split())
if l[0]<l[1]:
if l[1]<l[2]:
print 'Yes'
else:
print 'No'
else:
print 'No' | inp=input().split()
if inp[0] < inp[1] and inp[1] < inp[2]:
print("Yes")
else:
print("No") | 1 | 385,595,492,766 | null | 39 | 39 |
#
# author sidratul Muntaher
# date: Aug 19 2020
#
n = int(input())
from math import pi
print(pi* (n*2))
| import math
n = int(input())
print(2 * n * math.pi) | 1 | 31,564,172,089,658 | null | 167 | 167 |
R, C, T = map(int, input().split())
RC = []
for _ in range(T):
RC.append(list(map(int, input().split())))
TR = [0] * (R + 1)
TC = [0] * (C + 1)
mxr=0
mxc=0
for r, c in RC:
TR[r] += 1
TC[c] += 1
if(TR[r]>mxr):
mxr=TR[r]
if(TC[c]>mxc):
mxc=TC[c]
ct = TR.count(mxr) * TC.count(mxc) - len([0 for r, c in RC if TR[r] == mxr and TC[c] == mxc])
print(mxc + mxr - (ct == 0)) | taro_p = 0
hana_p = 0
for i in range(input()):
taro,hana = raw_input().split(' ')
if taro > hana:
taro_p = taro_p + 3
hana_p = hana_p + 0
elif taro < hana:
taro_p = taro_p + 0
hana_p = hana_p + 3
else:
taro_p = taro_p + 1
hana_p = hana_p + 1
print taro_p,hana_p | 0 | null | 3,372,311,978,692 | 89 | 67 |
# -*- coding: utf-8 -*-
import sys
import os
def input_to_list():
return list(map(int, input().split()))
H, W = input_to_list()
M = []
for i in range(H):
lis = input_to_list()
s = sum(lis)
lis.append(s)
M.append(lis)
# vertical sum
last = []
for i in range(W + 1):
s = 0
for j in range(H):
s += M[j][i]
last.append(s)
M.append(last)
# print
for i in range(H + 1):
print(*M[i]) | def lcm(x, y):
import math
return (x * y) // math.gcd(x, y)
def main():
A, B = map(int, input().split())
ans = lcm(A, B)
print(ans)
main() | 0 | null | 57,459,314,028,728 | 59 | 256 |
def insert(S, string):
S.add(string)
def find(S, string):
if string in S:
print 'yes'
else:
print 'no'
n = input()
S = set()
for i in range(n):
tmp1, tmp2 = map(str, raw_input().split())
if tmp1 == 'insert':
insert(S, tmp2)
elif tmp1 == 'find':
find(S, tmp2)
else:
print 'error!' | # cook your dish here
a,b,c = map(int, input().split())
k = int(input())
c1, c2 = 0, 0
while b<=a:
b=b*2
c1 = c1 + 1
while c <= b:
c=c*2
c2 = c2 +1
if c1 + c2 <= k:
print('Yes')
else:
print('No')
| 0 | null | 3,451,161,137,050 | 23 | 101 |
k, x = input().split()
K = int(k)
X = int(x)
result = 500 * K
if result >= X:
print("Yes")
else:
print("No") | import sys
sys.setrecursionlimit(1000000)
input = lambda: sys.stdin.readline().rstrip()
K, X = map(int, input().split())
if K * 500 >= X:
print("Yes")
else:
print("No") | 1 | 98,514,741,896,028 | null | 244 | 244 |
def breathSerch(P,N):
n=len(P)-1
m=1
QQ=[N[1]]
while(QQ != []):
R=[]
for Q in QQ:
for i in range(1,n+1):
if Q[i]==1 and P[i]==-1:
P[i]=m
R.append(N[i])
QQ = R
m=m+1
n = int(input())
A = [[0 for j in range(n+1)] for i in range(n+1)]
for i in range(n):
vec = input().split()
u = int(vec[0])
k = int(vec[1])
nodes = vec[2:]
for i in range(int(k)):
v = int(nodes[i])
A[u][v] = 1
P=[-1 for i in range(n+1)]
P[1]=0
breathSerch(P,A)
for i in range(1,n+1):
print(i,P[i]) | import sys
line = sys.stdin.readline()
n =[]
while line:
if int(line) == 0:
break;
else:
n.append(line)
line = sys.stdin.readline()
c = 1
for i in n:
print "Case",str(c)+":",str(i),
c+=1 | 0 | null | 249,699,053,608 | 9 | 42 |
s = int(input())
MOD = 10**9 + 7
dp = [0] * (s+10)
dp[0] = 1
for i in range(3, s+10):
dp[i] = sum(dp[:i-2])
dp[i] %= MOD
print(dp[s]%MOD) | def gcd(x,y):
if x%y==0: return y
else : return gcd(y,x%y)
if __name__=='__main__':
x,y=list(map(int,input().split()))
print(gcd(x,y)) | 0 | null | 1,658,677,835,990 | 79 | 11 |
D = {"SUN":7,"MON":6,"TUE":5,"WED":4,"THU":3,"FRI":2,"SAT":1}
print(D[input().strip()]) | s = input()
l = [0,'SAT','FRI','THU','WED','TUE','MON','SUN']
print(l.index(s)) | 1 | 132,811,632,026,710 | null | 270 | 270 |
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
s = int(input())
if s >= 30:
print('Yes')
else:
print('No')
if __name__ == "__main__":
main() | n = int(input())
s = input()
ans = 'No'
if n%2 == 0:
mid = int(n/2)
if s[:mid] == s[mid:]:
ans = 'Yes'
print(ans) | 0 | null | 76,109,923,044,378 | 95 | 279 |
num = (1,0,0)
for _ in range(int(input()) - 2):
num = (num[1],num[2],num[0]+num[2])
print(num[2]%(10**9+7)) | n=int(input())
s=list(input())
for x in range(n-1):
if s[x]==s[x+1]:
s[x]='1'
print(len(s)-s.count('1')) | 0 | null | 86,866,413,489,990 | 79 | 293 |
class SegTree:
""" segment tree with point modification and range product. """
# # https://yukicoder.me/submissions/452850
def __init__(self, N, data_f = min, data_unit=1<<30):
self.N = N
self.data_f = data_f
self.data_unit = data_unit
self.data = [self.data_unit] * (N + N)
def build(self, raw_data):
data = self.data
f = self.data_f
N = self.N
data[N:] = raw_data[:]
for i in range(N - 1, 0, -1):
data[i] = f(data[i << 1], data[i << 1 | 1])
def set_val(self, i, x):
data = self.data
f = self.data_f
i += self.N
data[i] = x
while i > 1:
data[i >> 1] = f(data[i], data[i ^ 1])
i >>= 1
def fold(self, L, R):
""" compute for [L, R) """
vL = vR = self.data_unit
data = self.data
f = self.data_f
L += self.N
R += self.N
while L < R:
if L & 1:
vL = f(vL, data[L])
L += 1
if R & 1:
R -= 1
vR = f(data[R], vR)
L >>= 1
R >>= 1
return f(vL, vR)
N=int(input())
S=input()
data = [[0]*N for _ in range(26)]
di = {}
for i in range(N):
data[ord(S[i])-97][i] = 1
di[i] = S[i]
seg = [SegTree(N,max,0) for _ in range(26)]
for i in range(26):
seg[i].build(data[i])
Q=int(input())
for i in range(Q):
*q, = input().split()
if q[0] == '1':
i, c = q[1:]
i = int(i)-1
c_old = di[i]
di[i] = c
seg[ord(c_old)-97].set_val(i,0)
seg[ord(c)-97].set_val(i,1)
else:
l,r = map(int,q[1:])
ans=0
for i in range(26):
ans += seg[i].fold(l-1,r)
print(ans) | import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9
def main():
l = int(input())
print((l/3)**3)
if __name__ == '__main__':
main()
| 0 | null | 55,093,883,705,608 | 210 | 191 |
a = input().split()
v = 2
while int(v) >= 1:
if int(a[int(v)-1]) < int(a[int(v)]):
pass
else:
b = int(a[int(v)-1])
a[int(v)-1] = int(a[int(v)])
a[int(v)] = int(b)
v = int(v) - 1
if int(a[1]) < int(a[2]):
pass
else:
b = int(a[1])
a[1] = int(a[2])
a[2] = int(b)
print('%d %d %d' % (int(a[0]),int(a[1]),int(a[2])))
| n = input().split()
a = int(n[0])
b = int(n[1])
c = int(n[2])
if a > b:
bf = a
a = b
b = bf
if b > c:
bf = b
b = c
c = bf
if a > b:
bf = a
a = b
b = bf
print(str(a) + " " + str(b) + " " + str(c)) | 1 | 423,099,380,450 | null | 40 | 40 |
import collections
h,w,m = map(int,input().split())
gyou = [0 for i in range(h)]
retu = [0 for i in range(w)]
l = []
for i in range(m):
y,x = map(int,input().split())
gyou[y-1] += 1
retu[x-1] += 1
l.append((y-1,x-1))
ymax = max(gyou)
xmax = max(retu)
c_ymax = gyou.count(ymax)
c_xmax = retu.count(xmax)
ans = ymax + xmax
c = 0
for y,x in l:
if gyou[y] == ymax and retu[x] == xmax:
c += 1
if c == c_ymax*c_xmax:
print(ans-1)
else:
print(ans) | h , w , m = map(int,input().split())
retu = [0 for i in range(w)]
gyo = [0 for i in range(h)]
basyo = set()
for i in range(m):
a , b = map(lambda x:int(x)-1,input().split())
retu[b] += 1
gyo[a] += 1
basyo.add((a,b))
t = max(retu)
mare = [i for i, v in enumerate(retu) if v == t]
s = max(gyo)
magy = [i for i, v in enumerate(gyo) if v == s]
for i in magy:
for j in mare:
if not (i,j) in basyo:
print(s+t)
exit()
print(s+t-1) | 1 | 4,696,382,829,282 | null | 89 | 89 |
n = int(input())
a = list(map(int,input().split()))
# i個使う時の要素の和の最大値
dp = [0]*(n+1)
dp[1] = 0
dp[2] = max(a[0],a[1])
# 奇数の番号の累積和
b = [0]*(n+1)
b[1] = a[0]
for i in range(1,n-1,2):
b[i+2] = b[i] + a[i+1]
# print(b)
for i in range(3,n+1):
if i % 2 == 0:
dp[i] = max(dp[i-2] + a[i-1], b[i-1])
else:
dp[i] = max(dp[i-2] + a[i-1], dp[i-3] + a[i-2], b[i-2])
# print(dp)
print(dp[n]) | f = list(map(str, [1, 2, 3]))
f.remove(input())
f.remove(input())
print(f[0]) | 0 | null | 74,487,170,891,910 | 177 | 254 |
s = input()
iters = len(s) // 2
count=0
for i in range(iters):
if s[i] != s[-(i+1)]:
count+=1
print(count) | n = int(input())
base = [mark + str(rank) for mark in ["S ", "H ", "C ", "D "] for rank in range(1,14)]
for card in [input() for i in range(n)]:
base.remove(card)
for elem in base:
print(elem) | 0 | null | 60,311,067,552,112 | 261 | 54 |
x, k, d = map(int, input().split())
x = -x if x <= 0 else x
if x - d * k >= 0:
print(x - d * k)
else:
a = x // d
b = a + 1
rest_cnt = k - a
if rest_cnt % 2 == 0:
print(abs(x - d * a))
else:
print(abs(x - d * b))
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
x,k,d = map(int, input().split())
x = abs(x)
if x == 0:
if k % 2 == 0:
print(0)
exit()
else:
print(abs(d))
exit()
bai = x//d
if bai >= k:
print(x-k*d)
exit()
else:
x -= bai*d
if (k-bai)%2==0:
print(x)
exit()
else:
print(abs(x-d))
| 1 | 5,182,261,594,660 | null | 92 | 92 |
class UnionFind():
"""
unionfindtree のクラス
グループを管理するデータ構造.
全てのメソッドの計算量が O(log(n)) よりも小さい
init: 管理対象の個数 n を用いて初期化
find: ある要素 x の親がどの要素か返す
union: ある要素 x と y が属しているグループを結合して1つのグループとする
msize: ある要素 x が属するグループの大きさを返す
"""
def __init__(self, n):
self.n = n
self.parents = [-1]*n
self.rank = [0]*n
self.size = [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 と y のランク(子の数)の小さい方が結合先の親となる
"""
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.size[y] += self.size[x]
self.parents[x] = y
else:
self.size[x] += self.size[y]
self.parents[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def msize(self, x):
"""
ある要素 x の属するグループの大きさを返すメソッド
"""
return self.size[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def main():
N, Q = map(int, input().split())
uf = UnionFind(N)
for _ in range(Q):
u, v = map(int, input().split())
uf.union(u-1, v-1)
print(uf.group_count()-1)
if __name__ == "__main__":
main()
| class uf():
def __init__(self,n):
self.size=n
self.parents=list(range(n))
def find(self,x):
if self.parents[x]==x:
return x
self.parents[x]=self.find(self.parents[x])
return self.find(self.parents[x])
def union(self,a,b):
x=self.find(a)
y=self.find(b)
if x==y:
return
if x>y:
x,y=y,x
self.parents[y]=x
def roots(self):
s=0
for c in range(self.size):
if self.find(c)==c:
s+=1
return s-1
n,m=map(int,input().split())
city=uf(n)
for c in range(m):
a,b=map(int,input().split())
a-=1
b-=1
city.union(a,b)
print(city.roots()) | 1 | 2,274,807,481,998 | null | 70 | 70 |
N, K = map(int, input().split())
W = [0] * (N + 1)
W[1] = 1
R = []
for i in range(K):
l, r = map(int, input().split())
R.append((l, r))
MOD = 998244353
for i in range(1, N):
for l, r in R:
a = max(i - r, 0)
b = i - l
if b < 0:
continue
W[i + 1] += (W[b + 1] - W[a])
W[i + 1] %= MOD
W[i + 1] += W[i]
print(W[N] - W[N - 1])
| n,k=list(map(int,input().split()))
s=[]
b=[0]*k
for x in range(k):
l,r=list(map(int,input().split()))
s.append((l,r))
d=[0]*n
d[0]=1
for i in range(1,n):
j=0
for l,r in s:
if i-l>=0:
b[j]+=d[i-l]
if i-r-1>=0:
b[j]-=d[i-r-1]
d[i]+=b[j]
j+=1
d[i]%=998244353
print(d[-1]) | 1 | 2,704,061,954,710 | null | 74 | 74 |
n=int(input())
s,t = map(str, input().split())
print(''.join([s[i] + t[i] for i in range(0,n)])) | n = int(input())
s, t = map(str, input().split())
for i in range(n):
print(s[i]+t[i], end="") | 1 | 112,021,670,342,930 | null | 255 | 255 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import math
def get_input() -> int:
"""
標準入力の取得
Returns:\n
int: 標準入力
"""
N = int(input())
return N
def main(N: int) -> None:
"""
求解処理
Args:
N (int): ページ数
"""
result = math.ceil(N/2)
# 結果出力
print(result)
if __name__ == "__main__":
N = get_input()
main(N)
| N, M=map(int, input().split())
mat = [[0 for m in range(M)]for n in range(N)]
vec = [0 for m in range(M)]
for n in range(N):
mat[n] = list(map(int , input().split()))
for m in range(M):
vec[m] = int(input())
c = 0
for n in range(N):
for m in range(M):
c += mat[n][m] * vec[m]
print(c)
c = 0 | 0 | null | 30,031,470,933,926 | 206 | 56 |
x = int(input())
for i in range(-200,201):
for j in range(-200,201):
if i**5 - j**5 == x:
print(i,j)
exit()
| X = int(input())
# Xの素因数分解をうまくつかう
# A^5 - B^5 =(A-B)(A^4+A^3B+A^2B^2+AB^3+B^4)
# どっちが正負かは決まらない
# AB(A^2+B^2)+(A^2+B^2)^2-A^2B^2
# AB((A-B)^2+2AB)+((A-B)^2+2AB)^2 - A^2B^2
# A-B = P
# AB = Q
# A^5-B^5 = P(Q(P^2+2Q)+(P^2+2Q)^2-Q^2) = P(P^4+5P^2Q+5Q^2) = P(5Q^2+5P^2Q+P^4)
# Qは整数解なので
# 5Q^2+5P^2Q+P^4が整数解を持つ楽な方法は(Q+P)^2の形の時、つまり2P = P^2+2,
# X = PRとする
# R-P^4は5の倍数になる
#Aの上限を求める
# X<10^9
# A-B = 1がAを最大にできる
maxA = 126
maxX = pow(10, 9)
flag = 0
for A in range(-126, 126):
for B in range(-127, A):
result = pow(A, 5) - pow(B, 5)
if result > maxX:
next
if result == X:
print(A, B)
flag = 1
break
if flag == 1:
break | 1 | 25,673,481,227,602 | null | 156 | 156 |
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,K = map(int,readline().split())
H = list(map(int,readline().split()))
ans = 0
for h in H:
if h >= K:
ans += 1
print(ans) | n,k=[int(s) for s in input().split()]
h=[int(j) for j in input().split()]
r=0
for i in range(n):
if k<=h[i]:
r=r+1
print(r) | 1 | 179,247,386,905,910 | null | 298 | 298 |
s = input()
n = len(s)
if n % 2 == 1:
print("No")
exit(0)
for i in range(n):
if i % 2 == 0:
if s[i] != "h":
print("No")
break
elif s[i] != "i":
print("No")
break
else:
print("Yes")
| import re
S=input()
pattern = '^(hi)+$'
result = re.match(pattern, S)
if result:
print('Yes')
else:
print('No') | 1 | 52,908,539,599,850 | null | 199 | 199 |
class Dice:
def __init__(self):
self.faces=[]
def rotate(self, direction):
tmp = self.faces.copy()
if direction =="N":
self.faces[5-1] = tmp[1-1]
self.faces[1-1] = tmp[2-1]
self.faces[2-1] = tmp[6-1]
self.faces[6-1] = tmp[5-1]
if direction =="S":
self.faces[5-1] = tmp[6-1]
self.faces[1-1] = tmp[5-1]
self.faces[2-1] = tmp[1-1]
self.faces[6-1] = tmp[2-1]
if direction =="W":
self.faces[4-1] = tmp[1-1]
self.faces[1-1] = tmp[3-1]
self.faces[3-1] = tmp[6-1]
self.faces[6-1] = tmp[4-1]
if direction =="E":
self.faces[3-1] = tmp[1-1]
self.faces[1-1] = tmp[4-1]
self.faces[4-1] = tmp[6-1]
self.faces[6-1] = tmp[3-1]
return 0
def spin(self):
self.faces[4-1], self.faces[2-1],self.faces[5-1],self.faces[3-1] =\
self.faces[2-1], self.faces[3-1],self.faces[4-1],self.faces[5-1]
return 0
d1 = Dice()
d1.faces=[int(x) for x in input().split(" ")]
lines = int(input())
for i in range(lines):
up, front = map(int, input().split(" "))
#set up side
for _ in range(3):
if d1.faces[0] == up:
break
d1.rotate("N")
for _ in range(3):
if d1.faces[0] == up:
break
d1.rotate("W")
#set front side
for _ in range(3):
if d1.faces[1] == front:
break
d1.spin()
print(d1.faces[2]) | def right(a,b,a1,a2,a3,a4,a5,a6):
b1=a6
b2=a5
b3=a4
b4=a3
b5=a2
b6=a1
if a>b:
tmp_a=a
a=b
b=tmp_a
if [a,b]==[a1,a2]:
right_side=[a3,b3]
elif [a,b]==[a1,a3]:
right_side=[a5,b5]
elif [a,b]==[a1,a4]:
right_side=[a2,b2]
elif [a,b]==[a1, a5]:
right_side=[a4,b4]
elif [a,b]==[a2, a3]:
right_side=[a1,b1]
elif [a, b]==[a2, a4]:
right_side=[a6,b6]
elif [a,b]==[a2,a6]:
right_side=[a3,b3]
elif [a,b]==[a3, a5]:
right_side=[a1,b1]
elif [a,b]==[a3, a6]:
right_side=[a5,b5]
elif [a, b]==[a4, a5]:
right_side=[a6,b6]
elif [a,b]==[a4,a6]:
right_side=[a2,b2]
elif [a,b]==[a5,a6]:
right_side=[a4,b4]
return right_side
initial=list( map(int,input().split()))
num_of_q=int(input())
for i in range(0, num_of_q):
a=list(map(int, input().split()))
flag=0
if a[0]>a[1]:
flag=1
answer=right(*a,*initial)
print(answer[flag])
| 1 | 254,179,600,930 | null | 34 | 34 |
num=int(input())
print(3.14159265359*num*2) | A, B, C, D = map(int, input().split())
result = False
while A > 0 and C > 0:
C -= B
if C <= 0:
result = 'Yes'
break
A -= D
if A <= 0:
result = 'No'
break
print(result) | 0 | null | 30,687,480,678,480 | 167 | 164 |
import math
N = int(input())
s = 0
# def devisor(x):
# count = 0
# for i in range(1,math.floor(math.sqrt(x))+1):
# if (x % i) == 0:
# count += 2
# if i**2 == x:
# count -= 1
# return count
# for i in range(1, N+1):
# s += i * devisor(i)
for i in range(1,N+1):
y = math.floor(N/i)
s += y*(y+1)*i//2
print(s) | # 正整数Xの正約数個数をf(X)とするときの \sum_(K=1)^N {K*f(K)}
# 正整数jの倍数でありN以下のものの総和をg(j)とするときの \sum_(j=1)^N g(j)
N = int(input())
ans = 0
for j in range(1, N+1):
# Y = N/j とすると g(j) = j+2j+...+Yj = (1+2+...+Y)j = Y(Y+1)/2 *j
g = (N//j)*(N//j+1)*j//2
ans += g
print(ans) | 1 | 11,050,126,179,988 | null | 118 | 118 |
import math
a,b,c=map(int,input().split())
s=a/2*b*math.sin(math.radians(c))
l=a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(math.radians(c)))
h=b*math.sin(math.radians(c))
print('{:.5f}\n{:.5f}\n{:.5f}'.format(s,l,h))
| import math
len_a, len_b, deg_C = map(int,input().split(" "))
rad_C = math.radians(deg_C)
#area
S = (1/2) * len_a * len_b * math.sin(rad_C)
#Length
L = len_a + len_b + math.sqrt(len_a ** 2 + len_b ** 2 - 2 * len_a * len_b * math.cos(rad_C))
#height
h = len_b * math.sin(rad_C)
print("{:.5f}\n{:.5f}\n{:.5f}".format(S,L,h)) | 1 | 174,242,983,772 | null | 30 | 30 |
import math
x = int(input())
ans = 0
y = 100
while y < x:
y += y//100
ans += 1
print(ans) | import sys
read = sys.stdin.readline
import time
import math
import itertools as it
def inp():
return int(input())
def inpl():
return list(map(int, input().split()))
start_time = time.perf_counter()
# ------------------------------
X = inp()
yen = 100
for i in range(10**4):
yen += (yen // 100)
if yen >= X:
print(i+1)
break
# -----------------------------
end_time = time.perf_counter()
print('time:', end_time-start_time, file=sys.stderr) | 1 | 27,058,189,826,528 | null | 159 | 159 |
import math
a, b, C = map(int, input().split())
print('{0}'.format(0.5 * a * b * math.sin(C * math.pi / 180)))
print('{0}'.format(a + b + (a ** 2 + b ** 2 - 2 * a * b * math.cos(C * math.pi / 180)) ** 0.5))
print('{0}'.format(b * math.sin(C * math.pi / 180))) | #coding: utf-8
n = int(input())
R = []
#input_value?????????
for i in range(n):
R.append(int(input()))
max_dif = -2000000000
min_value = R[0]
for i in range(1, n):
max_dif = max(max_dif, R[i] - min_value)
min_value = min(min_value, R[i])
print(max_dif) | 0 | null | 97,872,004,872 | 30 | 13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.