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
|
|---|---|---|---|---|---|---|
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
from sys import stdin
readline = stdin.readline
def readInts():
return list(map(int,readline().split()))
def readTuples():
return tuple(map(int,readline().split()))
def I():
return int(readline())
a,b = map(decimal.Decimal,input().split())
print(int(a*b))
| # -*- coding: utf-8 -*-
from decimal import Decimal
import math
a, b = input().split()
a = int(a)
b = Decimal(b)
x = a * b
print(math.floor(int(a) * Decimal(b)))
| 1 | 16,451,790,548,002 | null | 135 | 135 |
from collections import deque
inf=10**9
def BFS(num):
color=["white" for _ in range(n+1)]
D=[inf for _ in range(n+1)]
queue=deque([num])
color[num]="gray"
D[num]=0
while len(queue)>0:
u=queue.popleft()
for i in M[u]:
if color[i]=="white" and D[u]+1<D[i]:
D[i]=D[u]+1
color[i]="gray"
queue.append(i)
color[u]="black"
return D
n,x,y=map(int,input().split())
M=[[] for _ in range(n+1)]
for i in range(1,n):
M[i].append(i+1)
M[i+1].append(i)
M[x].append(y)
M[y].append(x)
ans=[0 for _ in range(n-1)]
for i in range(1,n+1):
for j in BFS(i)[i+1:]:
ans[j-1] +=1
for i in ans:
print(i) | def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j = j - g
cnt += 1
A[j + g] = v
def shellSort(A, n):
global cnt
G = []
g = 1
while g <= n:
G.append(g)
g = 3 * g + 1
G = G[::-1]
m = len(G)
for i in range(m):
insertionSort(A, n, G[i])
return m, G, cnt, A
n = int(input())
A = []
for _ in range(n):
A.append(int(input()))
cnt = 0
m, G, cnt, A = shellSort(A, n)
print(m)
for i in range(m):
if i == m - 1:
print(G[i])
else:
print(G[i], end=' ')
print(cnt)
for i in range(n):
print(A[i])
| 0 | null | 22,175,917,688,470 | 187 | 17 |
class BalancingTree:
def __init__(self, n):
self.N = n
self.root = self.node(1<<n, 1<<n)
def append(self, v):# v を追加（その時点で v はない前提）
v += 1
nd = self.root
while True:
if v == nd.value:
# v がすでに存在する場合に何か処理が必要ならここに書く
return 0
else:
mi, ma = min(v, nd.value), max(v, nd.value)
if mi < nd.pivot:
nd.value = ma
if nd.left:
nd = nd.left
v = mi
else:
p = nd.pivot
nd.left = self.node(mi, p - (p&-p)//2)
break
else:
nd.value = mi
if nd.right:
nd = nd.right
v = ma
else:
p = nd.pivot
nd.right = self.node(ma, p + (p&-p)//2)
break
def leftmost(self, nd):
if nd.left: return self.leftmost(nd.left)
return nd
def rightmost(self, nd):
if nd.right: return self.rightmost(nd.right)
return nd
def find_l(self, v): # vより真に小さいやつの中での最大値（なければ-1）
v += 1
nd = self.root
prev = 0
if nd.value < v: v = nd.value
while True:
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return prev - 1
else:
prev = nd.value
if nd.right:
nd = nd.right
else:
return prev - 1
def find_r(self, v): # vより真に大きいやつの中での最小値（なければRoot）
v += 1
nd = self.root
prev = 0
while True:
if v < nd.value:
prev = nd.value
if nd.left:
nd = nd.left
else:
return prev - 1
else:
if nd.right:
nd = nd.right
else:
return prev - 1
@property
def max(self):
return self.find_l((1<<self.N)-1)
@property
def min(self):
return self.find_r(-1)
def delete(self, v, nd = None, prev = None): # 値がvのノードがあれば削除（なければ何もしない）
v += 1
if not nd: nd = self.root
if not prev: prev = nd
while v != nd.value:
prev = nd
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return
else:
if nd.right:
nd = nd.right
else:
return
if (not nd.left) and (not nd.right):
if nd.value < prev.value:
prev.left = None
else:
prev.right = None
elif not nd.left:
if nd.value < prev.value:
prev.left = nd.right
else:
prev.right = nd.right
elif not nd.right:
if nd.value < prev.value:
prev.left = nd.left
else:
prev.right = nd.left
else:
nd.value = self.leftmost(nd.right).value
self.delete(nd.value - 1, nd.right, nd)
def __contains__(self, v: int) -> bool:
return self.find_r(v - 1) == v
class node:
def __init__(self, v, p):
self.value = v
self.pivot = p
self.left = None
self.right = None
k = (500000+1).bit_length()
dic = {}
for i in range(97, 123):
dic[chr(i)] = BalancingTree(k)
n = int(input())
s = input()
lst = []
for i in range(n):
lst.append(s[i])
dic[s[i]].append(i)
ans = []
q = int(input())
for _ in range(q):
que = input()
if que[0] == '1':
kind, i, c = que.split()
i = int(i) - 1
dic[lst[i]].delete(i)
dic[c].append(i)
lst[i] = c
else:
kind, l, r = map(int, que.split())
l -= 2; r -= 1
temp = 0
for key in dic.keys():
if dic[key].find_r(l) <= r:
temp += 1
ans.append(temp)
for i in ans:
print(i) | #####segfunc######
def segfunc(x, y):
return x | y
def init(init_val):
# set_val
for i in range(n):
seg[i + num - 1] = set(init_val[i])
# built
for i in range(num - 2, -1, -1):
seg[i] = segfunc(seg[2 * i + 1], seg[2 * i + 2])
def update(k, x):
k += num - 1
seg[k] = set(x)
while k:
k = (k - 1) // 2
seg[k] = segfunc(seg[k * 2 + 1], seg[k * 2 + 2])
def query(p, q):
if q <= p:
return ide_ele
p += num - 1
q += num - 2
res = ide_ele
while q - p > 1:
if p & 1 == 0:
res = segfunc(res, seg[p])
if q & 1 == 1:
res = segfunc(res, seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = segfunc(res, seg[p])
else:
res = segfunc(segfunc(res, seg[p]), seg[q])
return res
#####単位元######
ide_ele = set()
n = int(input())
S = input().strip()
Q = int(input())
num = 2 ** (n - 1).bit_length()
seg = [set()] * 2 * num
init(S)
for _ in range(Q):
a, b, c = [x for x in input().split()]
if a == "1":
update(int(b) - 1, c)
else:
print(len(query(int(b) - 1, int(c))))
| 1 | 62,455,518,782,272 | null | 210 | 210 |
# coding:utf-8
import math
N=int(input())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
manh_dist=0.0
for i in range(0,N):
manh_dist=manh_dist+math.fabs(x[i]-y[i])
print('%.6f'%manh_dist)
eucl_dist=0.0
for i in range(0,N):
eucl_dist=eucl_dist+(x[i]-y[i])**2
eucl_dist=math.sqrt(eucl_dist)
print('%.6f'%eucl_dist)
mink_dist=0.0
for i in range(0,N):
mink_dist=mink_dist+math.fabs(x[i]-y[i])**3
mink_dist=math.pow(mink_dist,1.0/3)
print('%.6f'%mink_dist)
cheb_dist=0.0
for i in range(0,N):
if cheb_dist<math.fabs(x[i]-y[i]):
cheb_dist=math.fabs(x[i]-y[i])
print('%.6f'%cheb_dist) | n = int(input())
x = map(float, input().strip().split())
y = map(float, input().strip().split())
d = tuple(map(lambda x,y:abs(x-y), x, y))
print(sum(d))
print(sum(map(pow, d, [2]*n))**0.5)
print(sum(map(pow, d, [3]*n))**(1/3))
print(max(d)) | 1 | 212,857,589,880 | null | 32 | 32 |
n = int(input())
a = list(map(int,input().split(" ")))
answer = 0
for i in range(1,n):
if a[i] < a[i - 1]:
answer += a[i-1] - a[i]
a[i]= a[i - 1]
print(answer) | N = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(N-1):
if A[i] > A[i+1]:
diff = A[i] - A[i+1]
ans += diff
A[i+1] += diff
print(ans) | 1 | 4,549,635,749,266 | null | 88 | 88 |
[a,b,c] = map(int,input().split())
print("Yes" if a < b < c else "No") | a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
d = abs(a-b)
if v <= w:
print('NO')
else:
if (v-w)*t < d:
print('NO')
else:
print('YES')
| 0 | null | 7,752,197,123,800 | 39 | 131 |
N, K, C = map(int, input().split())
S = input()[::-1]
Top = []
Bottom = []
yasumi = 0
ans = []
k = K
for i in range(N):
if (yasumi == 0) and (S[i] == "o") and (k > 0):
Bottom.append(N-i)
yasumi += C
k -= 1
elif yasumi > 0:
yasumi -= 1
S_ = S[::-1]
Bottom.sort()
j = -1
yasumi = 0
for i in range(N):
if (yasumi == 0) and (S_[i] == "o") and (K > 0):
j += 1
yasumi += C
K -= 1
if j >= len(Bottom):
break
elif Bottom[j] == i+1:
ans.append(i+1)
elif yasumi > 0:
yasumi -= 1
for i in ans:
print(i) | n, k, c = map(int, input().split())
s = list(input())
count = 0
l, r = [], []
for i in range(n):
m = i + c * count
if m >= n:
break
if s[m] == 'o':
count += 1
if count > k:
break
l.append(m)
count = 0
for i in range(n - 1, -1, -1):
m = i - c * count
if m < 0:
break
if s[m] == 'o':
count += 1
if count > k:
break
r.append(m)
l.sort()
r.sort()
for i in range(k):
if l[i] == r[i]:
print(l[i] + 1) | 1 | 40,543,320,894,142 | null | 182 | 182 |
# -*- coding: utf-8 -*-
N = int(input())
S = list()
words = {}
for i in range(N):
s = input()
S.append(s)
if s in words:
words[s] += 1
else:
words[s] = 1
max_value = max(words.values())
max_list = list()
for k,v in words.items():
if v == max_value:
max_list.append(k)
ans_list = sorted(max_list)
for ans in ans_list:
print(ans) | q=int(input())
dic={}
for i in range(q):
s=input()
if not s in dic:
dic[s]=1
else:
dic[s]+=1
max_val=max(dic.values())
a=sorted([i for i, k in dic.items() if k == max_val])
for i in a:
print(i)
| 1 | 69,870,655,865,482 | null | 218 | 218 |
h, n = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
print('Yes' if sum(a) >= h else 'No') | h,n=map(int, input().split())
a_list=[int(i) for i in input().split()]
if sum(a_list)>=h:
print("Yes")
else:
print("No") | 1 | 77,620,321,065,572 | null | 226 | 226 |
from collections import deque
H, W, K = map(int, input().split())
mp = [input() for _ in range(H)]
rlt = 1010
h = deque([[1]])
while h:
t = h.pop()
if len(t) == H:
t.append(1)
tmp = sum(t) - 2
bs = tmp
lst = [0]*H
j = -1
for i in range(len(t)-1):
if t[i] == 1:
j += 1
lst[i] = j
cnt = [0]*(lst[-1]+1)
for j in range(W):
tcnt = [0]*(lst[-1]+1)
f = 0
for i in range(H):
tcnt[lst[i]] += int(mp[i][j])
for k in range(lst[-1]+1):
if tcnt[k] > K:
f = 2
break
cnt[k] += tcnt[k]
if cnt[k] > K:
f = 1
break
if f == 2:
break
if f == 1:
tmp += 1
for k in range(lst[-1]+1):
cnt[k] = tcnt[k]
if f < 2:
rlt = min(rlt, tmp)
else:
for i in range(2):
h.append(t+[i])
print(rlt) | from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, range(n, n - r, -1))
under = reduce(mul, range(1,r + 1))
return over // under
s= int(input())
box_max =s//3
ans =0
if box_max ==0:
print(ans)
else:
for i in range(1, box_max +1):
ball_and_bar =(s-3*i)+i-1
bar =i-1
ans += cmb(ball_and_bar, bar)%(10**9 +7)
print(ans%(10**9 + 7)) | 0 | null | 26,026,303,135,558 | 193 | 79 |
s = input()
n = int(input())
def f(s):
prev = ''
ct = 0
for i in s:
if i == prev:
ct += 1
prev = ''
else:
prev = i
return ct
if len(set(s)) == 1:
print(len(s) *n//2)
elif s[0]!=s[-1]:
print(f(s) * n)
else:
ans = f(s) + (f(s*2) - f(s)) * (n-1)
print(ans)
| a,b,c=map(int,input().split())
a1=b
b1=a
a2=c
c1=a1
print(a2, b1, c1) | 0 | null | 106,251,997,745,820 | 296 | 178 |
import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
def Main():
n = read_int()
a = read_int_list()
ans = 1
cnt = [3] + [0] * n
for x in a:
ans = ans * cnt[x] % MOD
cnt[x] -= 1
cnt[x + 1] += 1
print(ans)
if __name__ == '__main__':
Main() | M = 10**9 + 7
n = int(input())
a = [int(i) for i in input().split()] #; print(a)
counter = [0] * (n+1) ; counter[0] = 3
ans = 1
for i in range(n):
ans *= counter[a[i] - 1 +1] - counter[a[i] +1]
ans = ans % M
counter[a[i] +1] += 1
print(ans) | 1 | 129,978,144,078,530 | null | 268 | 268 |
n = int(input())
*li, = map(int, input().split())
input()
*Q, = map(int, input().split())
bits = 1
for i in li:
# print(f"{i=}")
# print(f"{bin(bits)=}")
bits |= bits << i
# print(f"{bin(bits)=}")
# print()
# print()
for q in Q:
# print(f"{bin(bits)=}")
print("yes"*((bits >> q) & 1) or "no")
# print()
| input()
nlist=map(int, raw_input().split())
input()
qlist=map(int, raw_input().split())
n = len(nlist)
dic = {}
def func(idx, m):
try:
return dic[m][idx]
except:
pass
if m==0:
tmp=dic.get(m,{})
tmp.update({idx: True})
dic.update({m:tmp})
elif idx > n-1:
tmp=dic.get(m,{})
tmp.update({idx: False})
dic.update({m:tmp})
elif func(idx+1, m):
tmp=dic.get(m,{})
tmp.update({idx: True})
dic.update({m:tmp})
elif func(idx+1, m-nlist[idx]):
tmp=dic.get(m,{})
tmp.update({idx: True})
dic.update({m:tmp})
else:
tmp=dic.get(m,{})
tmp.update({idx: False})
dic.update({m:tmp})
return dic[m][idx]
for q in qlist:
# print dic
print "yes" if func(0, q) else "no" | 1 | 100,854,149,588 | null | 25 | 25 |
N=int(input())
*A,=map(int,input().split())
M=max(A)
B=[1]*(M+1)
B[0]=B[1]=1
i=2
while i<=M:
if B[i]:
j=2
while i*j<=M:
B[i*j]=0
j+=1
i+=1
C=[0]*(M+1)
for a in A:
C[a]=1
from math import*
now=A[0]
for a in A:
now=gcd(now,a)
if now==1:
ans='pairwise coprime'
i=2
while i<=M:
if B[i]:
count=0
j=1
while i*j<=M:
count+=C[i*j]
j+=1
if count>1:
ans='setwise coprime'
i+=1
print(ans)
else:
print('not coprime') | from collections import defaultdict
from math import gcd
N = int(input())
A = list(map(int, input().split()))
A_set = set(A)
num = 10 ** 6
primes = [0] * (num + 1)
primes[0] = 1
primes[1] = 1
for i in range(2, num + 1):
if primes[i] != 0:
continue
cnt = 1
while i * cnt <= num:
primes[i * cnt] = i
cnt += 1
def func(n):
res_dic = defaultdict(int)
while n > 1:
x = primes[n]
res_dic[x] += 1
n //= x
return res_dic
pairwise = True
cnt_dic = defaultdict(int)
for a in A:
dic = func(a)
for k in dic.keys():
cnt_dic[k] += 1
if cnt_dic[k] > 1:
pairwise = False
break
g = A[0]
for a in A[1:]:
g = gcd(g, a)
if pairwise:
print('pairwise coprime')
elif g == 1:
print('setwise coprime')
else:
print('not coprime')
| 1 | 4,077,445,417,280 | null | 85 | 85 |
num = input()
num = int(num)
print(num**3) | a, b, k = map(int, input().split())
if (a >= k):
aa = a - k
bb = b
else:
aa = 0
bb = max(0, b - (k - a))
print(aa, bb)
| 0 | null | 52,445,408,839,352 | 35 | 249 |
from math import sin,cos,pi,sqrt
a,b,d=map(float,input().split())
S=a*b*sin(d*pi/180)/2
c=sqrt(a**2+b**2-2*a*b*cos(d*pi/180))
h=2*S/a
print(S)
print(a+b+c)
print(h)
| class UFTree:
def __init__(self, N):
self.nodes = [Node(i) for i in range(N)]
self.N = N
def find_max_child_num(self):
result = 0
for i in range(self.N):
result = max(result, self.nodes[i].child_num)
return result
class Node:
def __init__(self, ID):
self.ID = ID
self.parent = None
self.child_num = 0
self.rank = 1
def get_root(self):
if self.parent is None:
return self
return self.parent.get_root()
def concat(self, another):
sr = self.get_root()
ar = another.get_root()
# is in a same tree.
if sr.ID == ar.ID:
return
if sr.rank > ar.rank:
parent, child = sr, ar
else:
parent, child = ar, sr
parent.child_num += child.child_num + 1
parent.rank = max(parent.rank, child.rank + 1)
child.parent = parent
N, M = map(int, input().split())
tree = UFTree(N)
AB = []
for i in range(M):
l = list(map(int, input().split()))
AB.append(l)
for i in range(M):
a, b = AB[i][0], AB[i][1]
a -= 1;
b -= 1;
tree.nodes[a].concat(tree.nodes[b])
print(tree.find_max_child_num() + 1) | 0 | null | 2,096,866,226,252 | 30 | 84 |
a, b = map(int,input().split())
print(sorted([str(a)*b,str(b)*a])[0])
| a, b = input().split()
s1 = a*int(b)
s2 = b*int(a)
print(s1 if s1 < s2 else s2) | 1 | 84,441,197,787,714 | null | 232 | 232 |
N = int(input())
A = list(map(int, input().split()))
A.reverse()
min_max = [[] for _ in range(N+1)]
def main():
min_max[0] = [A[0], A[0]]
for i in range(1, N+1):
a = A[i]
pre_min, pre_max = min_max[i-1]
min_max[i] = [(1+pre_min)//2 +a, pre_max +a]
min_max.reverse()
if min_max[0][0] != 1:
print(-1)
return
A.reverse()
ans = 1
pre = 1
for i in range(1, N+1):
a = A[i-1]
pre = min(2*(pre -a), min_max[i][1])
ans += pre
print(ans)
main() | n= int(input())
a = list(map(int, input().split()))
if n == 0 and a[0]==1:
print(1)
exit(0)
if a[0] != 0:
print(-1)
exit(0)
b=1
count=1
asum =sum(a)
alim = asum
for i in range(n):
if a[i+1] > 2*b:
print(-1)
exit(0)
else:
alim = alim - a[i+1]
b= min(2*b-a[i+1], alim)
count += b
print(count+ asum) | 1 | 18,922,059,042,300 | null | 141 | 141 |
N,K = map(int,input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
if sum(A) <= K:
print(0)
exit()
A.sort()
F.sort(reverse=True)
def check(x):
k = 0
for a,f in zip(A, F):
k += max(0, a-(x//f))
return k <= K
# AをX以下にできるか？?
ng,ok = 0, 10**18+1
while ok-ng > 1:
x = (ok+ng)//2
if check(x):
ok = x
else:
ng = x
print(ok)
| N = int(input())
X = input()
pop_X = sum(map(int,list(X)))
X_10 = int('0b'+X,2)
r_0 = X_10%(pop_X+1)
diff_0 = 1%(pop_X+1)
zero_flag = False
if pop_X == 1:
zero_flag = True
else:
r_1 = X_10%(pop_X-1)
diff_1 = 1%(pop_X-1)
answer = []
for i in range(N)[::-1]:
if X[i]=='0':
r = (r_0+diff_0)%(pop_X+1)
else:
if zero_flag:
answer.append(0)
diff_0 = (diff_0*2)%(pop_X+1)
continue
else:
r = (r_1-diff_1)%(pop_X-1)
count = 1
while True:
if r == 0:
break
pop = sum(map(int,list(bin(r)[2:])))
r = r % pop
count += 1
answer.append(count)
diff_0 = (diff_0*2)%(pop_X+1)
if zero_flag:
continue
diff_1 = (diff_1*2)%(pop_X-1)
for i in answer[::-1]:
print(i) | 0 | null | 86,845,991,048,608 | 290 | 107 |
a,b,c=map(int,input().split())
d={"a":a,"b":b,"c":c}
for i in range(int(input())+1):
if d["a"]<d["b"]<d["c"]:
print("Yes")
exit()
elif d["a"]>=d["c"]: d["c"]*=2
elif d["a"]>=d["b"]: d["b"]*=2
elif d["b"]>=d["c"]: d["c"]*=2
print("No")
| s = []
p = []
a = i = 0
for c in input():
if c == "\\":
s += [i]
elif c == "/" and s:
j = s.pop()
t = i-j
a += t
while p and p[-1][0] > j:
t += p[-1][1]
p.pop()
p += [(j,t)]
i += 1
print(a)
if p:
print(len(p),*list(zip(*p))[1])
else:
print(0)
| 0 | null | 3,437,683,444,590 | 101 | 21 |
ondo = int(input())
if 30 <= ondo:
print("Yes")
else:
print("No") | n,x,y=map(int,input().split())
ans=[0]*n
tree=[[] for _ in range(n)]
for i in range(1,n):
tree[i-1].append(i)
tree[i].append(i-1)
tree[x-1].append(y-1)
tree[y-1].append(x-1)
from collections import deque
ans=[0]*n
for i in range(n):
checked=[-1]*n
stack=deque([i])
checked[i]=0
while len(stack)>0:
tmp=stack.popleft()
for item in tree[tmp]:
if checked[item]==-1:
checked[item]=checked[tmp]+1
stack.append(item)
for item in checked:
ans[item]+=1
for item in ans[1:]:
print(item//2)
| 0 | null | 25,004,675,333,606 | 95 | 187 |
def solve():
s = input()
n = len(s)
if n%2 == 1:
print("No")
else:
tmp = "hi"*(n//2)
if s == tmp:
print("Yes")
else:
print("No")
solve() | import re
s = input()
if re.sub(r'hi', '', s) == '':
print('Yes')
else:
print('No')
| 1 | 53,244,993,277,982 | null | 199 | 199 |
import math
r = input()
print '%.6f' % (r*r*math.pi), '%.6f' % (2*r*math.pi) | N = int(input())
result = 0
for i in range(1, N+1):
if i % 3 == 0 and i % 5 == 0:
pass
elif i % 3 == 0:
pass
elif i % 5 == 0:
pass
else:
result += i
print(result)
| 0 | null | 17,822,609,264,160 | 46 | 173 |
N=[int(c) for c in input()][::-1]
dp=[[0]*2 for _ in range(len(N)+1)]
dp[0][1]=1
for i in range(len(N)):
dp[i+1][1]=min(dp[i][0]+N[i]+1,dp[i][1]+10-N[i]-1)
dp[i+1][0]=min(dp[i][0]+N[i],dp[i][1]+10-N[i])
print(dp[len(N)][0]) | s=list(map(int,input()[::-1]))
t=[[0,0]for i in range(len(s)+1)]
t[0]=[0,9]
for i in range(len(s)):
t[i+1][0]=min(t[i][0],t[i][1])+s[i]
t[i+1][1]=min(11-s[i]+t[i][0],9-s[i]+t[i][1])
print(min(t[-1])) | 1 | 70,875,910,329,490 | null | 219 | 219 |
import sys
from itertools import accumulate
n = int(sys.stdin.buffer.readline())
a = list(map(int, sys.stdin.buffer.readline().split()))
aa = list(accumulate(a))
MOD = 10**9+7
ans = 0
for i in range(n):
ans += a[i]*(aa[n-1] - aa[i])
print(ans%MOD)
| s = input()
stack = []
n = len(s)
ans = 0
prev = 0
each = []
for i in range(n):
if s[i] == '\\':
stack.append(i)
elif s[i] == '_':
pass
else:
if len(stack) != 0:
idx = stack.pop()
ans += (i - idx)
if len(stack) == 0:
each.append(ans - prev)
prev = ans
each2 = []
stack2 = []
ans2 = 0
prev2 = 0
if len(stack) >= 1:
for i in range(n-1,stack[0],-1):
if s[i] == '/':
stack2.append(i)
elif s[i] == '_':
pass
else:
if len(stack2) != 0:
idx = stack2.pop()
ans2 += (idx - i)
if len(stack2) == 0:
each2.append(ans2 - prev2)
prev2 = ans2
each2.reverse()
each.extend(each2)
print(ans)
if len(each) == 0:
print(len(each))
else:
print(len(each),end=" ")
print(*each)
| 0 | null | 1,936,161,379,552 | 83 | 21 |
#ABC146A
s = ["SUN","MON","TUE","WED","THU","FRI","SAT"]
ss = input()
print(7-s.index(ss)) | # -*- coding:utf-8 -*-
def solve():
"""しゃくとり法で解く"""
N = int(input())
As = list(map(int, input().split()))
# 数列Aの要素aが何個あるかを保持する辞書dic
dic = {}
for a in As:
if not a in dic:
dic[a] = 0
dic[a] += 1
S = sum(As) # 総和
# 各クエリでしゃくとりする
Q = int(input())
for q in range(Q):
b, c = list(map(int, input().split()))
if b in dic:
if not c in dic:
dic[c] = 0
S -= b*dic[b]
S += c*dic[b]
dic[c] += dic[b]
dic[b] = 0
print(S)
if __name__ == "__main__":
solve()
| 0 | null | 72,254,791,812,180 | 270 | 122 |
# https://atcoder.jp/contests/abc152/submissions/9693323
import sys
read = sys.stdin.read
N, *A = map(int, read().split())
mod = 10 ** 9 + 7
def min_factor(n):
sieve = list(range(n + 1))
sieve[2::2] = [2] * (n // 2)
for i in range(3, int(n ** 0.5) + 2, 2):
if sieve[i] == i:
sieve[i * i::2 * i] = [i] * ((n - i * i) // (2 * i) + 1)
return sieve
def prime_factorize(n):
a = {}
while n != 1:
b = table[n]
if b in a:
a[b] += 1
else:
a[b] = 1
n //= b
return a
table = min_factor(10**6)
dic = {}
for i in A:
for key, value in prime_factorize(i).items():
if key in dic:
dic[key] = max(dic[key], value)
else:
dic[key] = value
lcm = 1
for i, j in dic.items():
lcm *= pow(i, j, mod)
lcm %= mod
answer = sum(lcm * pow(i, mod - 2, mod) for i in A) % mod
print(answer)
| n = int(input())
s = input()
ans = ''
for c in s:
ans += chr((ord(c) - ord("A") + n) % 26 + ord("A"))
print(ans) | 0 | null | 110,775,392,220,090 | 235 | 271 |
N = int(input())
N %= 10
if N == 3:
print("bon")
elif N == 0 or N == 1 or N == 6 or N == 8:
print("pon")
else:
print("hon") | from itertools import accumulate
n,m,k = map(int,input().split())
deskA = list(map(int,input().split()))
deskB = list(map(int,input().split()))
cumA = list(accumulate(deskA))
cumB = list(accumulate(deskB))
cumA = [0] + cumA
cumB = [0] + cumB
ans = 0
l = m
for i in range(n+1):
tmp = k - cumA[i]
if tmp<0:
continue
j = l
tmp -= cumB[j]
while tmp < 0:
tmp += cumB[j]
j -= 1
tmp -= cumB[j]
l = j
ans = max(i+j,ans)
print(ans) | 0 | null | 14,986,986,504,000 | 142 | 117 |
n=int(input())
print(-~n//2/n) | n = int(input())
if n%2 == 0:
print(1/2)
else:
n2 = (n//2) + 1
print(n2/n) | 1 | 177,612,466,155,620 | null | 297 | 297 |
import sys
from itertools import combinations_with_replacement
input = sys.stdin.readline
def main():
N, M, Q = map(int, input().split())
abcd = [None] * Q
for i in range(Q):
abcd[i] = list(map(int, input().split()))
abcd[i][0] -= 1
abcd[i][1] -= 1
ans = 0
for A in combinations_with_replacement(range(1, M + 1), N):
score = 0
for a, b, c, d in abcd:
if A[b] - A[a] == c:
score += d
if score > ans:
ans = score
print(ans)
if __name__ == "__main__":
main()
| import sys
R, C, K = map(int, input().split())
item = [[0] * (C + 1) for _ in range(R + 1)] # dp配列と合わせるために, 0行目, 0列目を追加している.
for s in sys.stdin.readlines():
r, c, v = map(int, s.split())
item[r][c] = v
dp = [[[0] * (C + 1) for _ in range(R + 1)] for _ in range(4)]
for i in range(R + 1):
for j in range(C + 1):
for k in range(4):
here = dp[k][i][j]
# 次の行に移動する場合
if i + 1 <= R:
# 移動先のアイテムを取らない場合
dp[0][i + 1][j] = max(dp[0][i + 1][j], here)
# 移動先のアイテムを取る場合
dp[1][i + 1][j] = max(dp[1][i + 1][j], here + item[i + 1][j])
# 次の列に移動する場合
if j + 1 <= C:
# 移動先のアイテムを取らない場合
dp[k][i][j + 1] = max(dp[k][i][j + 1], here)
# 現在のkが3未満のときのみ, 移動先のアイテムを取ることが可能
if k < 3:
dp[k + 1][i][j + 1] = max(dp[k + 1][i][j + 1], here + item[i][j + 1])
ans = 0
for k in range(4):
ans = max(ans, dp[k][-1][-1])
print(ans) | 0 | null | 16,707,999,802,268 | 160 | 94 |
while True:
m, f, r = map(int, raw_input().split())
if m == -1 and f == -1 and r == -1:
break
elif m == -1 or f == -1:
print "F"
elif m + f >= 80:
print "A"
elif m + f >= 65:
print "B"
elif m + f >= 50:
print "C"
elif m + f >= 30 and r >= 50:
print "C"
elif m + f >= 30:
print "D"
else:
print "F" | def insetion_sort(A, n, g, cnt) :
cnt = 0
for i in range(g, n) :
v = A[i]
j = i - g
while j >= 0 and A[j] > v :
A[j+g] = A[j]
j = j -g
cnt += 1
A[j+g] = v
return cnt
def shell_sort(A, n) :
cnt = 0
count = 0
G_sub = []
h = 1
while h <= n :
G_sub.append(h)
h = 3 * h + 1
m = len(G_sub)
G = G_sub[::-1]
for i in range(m) :
count += insetion_sort(A, n, G[i], cnt)
print(m)
if len(G) == 1 :
print(G[0])
else :
print(" ".join(map(str, G)))
print(count)
def main() :
n = int(input())
nums = []
for i in range(n) :
nums.append(int(input()))
shell_sort(nums, n)
for i in range(n) :
print(nums[i])
if __name__ == '__main__' :
main() | 0 | null | 627,641,377,520 | 57 | 17 |
while True:
s = raw_input().split()
a = int(s[0])
b = int(s[2])
if s[1] == "?":
break
elif s[1] == '+':
print a + b
elif s[1] == '-':
print a - b
elif s[1] == '*':
print a * b
elif s[1] == '/':
print a / b | def main():
n = int(input())
for _ in range(n):
len_list = map(int, input().split())
check_tri(len_list)
def check_tri(len_list):
import itertools
import math
flag = False
for tmp in list(itertools.permutations(len_list)):
if (pow(tmp[0], 2) + pow(tmp[1], 2)) == pow(tmp[2], 2):
flag = True
break
if flag == True:
print('YES')
else:
print('NO')
if __name__ == '__main__':
main() | 0 | null | 346,276,639,972 | 47 | 4 |
from collections import *
import copy
N,v,u=map(int,input().split())
AB=[list(map(int,input().split())) for i in range(N-1)]
data=[[] for i in range(N+1)]
for A,B in AB:
data[A].append(B)
data[B].append(A)
stack=deque([[v,0]])
visited=set([v])
while stack:
a,m=stack.popleft()
for p in data[a]:
if p==u:
K=m+1
if not p in visited:
visited.add(p)
stack.append([p,m+1])
for i in range(len(data)):
if len(data[i])>1:
visited=set([i])
stack=deque([i])
End=set()
break
if N==2:
print(0)
exit()
while stack:
a=stack.popleft()
flag=0
for p in data[a]:
if not p in visited:
visited.add(p)
stack.append(p)
flag=1
if flag==0:
End.add(a)
Uvisited=set([u])
Vvisited=set([])
if not v in End:
Vvisited.add(v)
Ustack=deque([[u,0]])
Vstack=deque([[v,0]])
ans=[]
M=1
while Ustack:
while Vstack:
a,m=Vstack.popleft()
if m==M:
Vstack.append([a,m])
break
for p in data[a]:
if not p in End:
if p in Uvisited:
pass
#ans.append(m)
elif not p in Vvisited:
Vvisited.add(p)
Vstack.append([p,m+1])
while Ustack:
a,m=Ustack.popleft()
if m==M:
Ustack.append([a,m])
break
for p in data[a]:
if not p in Uvisited:
if p in Vvisited:
ans.append(m+1)
Uvisited.add(p)
Ustack.append([p,m+1])
M+=1
print(max(ans))
| f=lambda:map(int,input().split())
n,st,sa=f()
g=[set() for _ in range(n)]
for _ in range(n-1):
a,b=f()
g[a-1].add(b-1)
g[b-1].add(a-1)
def bfs(s):
l=[-1]*n; l[s]=0; q=[s]
while q:
v=q.pop(); d=l[v]+1
for c in g[v]:
if l[c]<0: l[c]=d; q+=[c]
return l
lt=bfs(st-1)
la=bfs(sa-1)
print(max(la[i] for i in range(n) if lt[i]<la[i])-1) | 1 | 117,420,152,475,124 | null | 259 | 259 |
a=[int(i) for i in input().split()]
if a[0]<=a[1]:
print("unsafe")
else:
print("safe") | s,w = list(map(int,input().split()))
if w >= s:
print('unsafe')
else:
print('safe') | 1 | 29,225,721,453,568 | null | 163 | 163 |
n,k=map(int,input().split())
n=list(map(int,input().split()))
a=0
for i in n:
if i>=k:
a+=1
print(a)
| from collections import deque
S=deque(input())
Q=int(input())
reverse=0
for q in range(Q):
Query=list(input().split())
T=Query[0]
if T=="1":
reverse+=1
if T=="2":
F,C=Query[1],Query[2]
if F=="1" and reverse%2==0 or F=="2" and reverse%2==1:
S.appendleft(C)
else:
S.append(C)
S="".join(S)
print(S if reverse%2==0 else S[::-1]) | 0 | null | 118,222,223,772,312 | 298 | 204 |
n = input()
lis = []
bot = 0
for i in xrange(n):
com = raw_input()
if com[0] == 'i':
lis.append(com[7:])
elif com[6] == ' ':
try:
lis.pop(~lis[::-1].index(com[7:]))
except:
pass
elif com[6] == 'F':
lis.pop()
else:
bot += 1
print ' '.join( map(str, reversed(lis[bot:])) ) | N,M,X=[int(s) for s in input().split()]
Book=[[int(s) for s in input().split()] for _ in range(N)]
INF=10**7
ans=set()
ans.add(INF)
for n in range(2**N):
#Bit全探索
Xls=[0 for i in range(M)]
cost=0
for i in range(N):
if ((n>>i)&1)==1:
cost+=Book[i][0]
for b in range(M):
Xls[b]+=Book[i][b+1]
if min(Xls)>=X:
ans.add(cost)
if min(ans)==INF:
print(-1)
else:
print(min(ans)) | 0 | null | 11,182,177,232,706 | 20 | 149 |
import math
X, Y = map(int, input().split())
if X > Y:
X, Y = Y, X
if ((2*X-Y) % 3 != 0) or (2*X-Y < 0):
print(0)
exit()
A = (2*X-Y)//3
B = Y-X+A
N = A+B
nu = 1
de = 1
for i in range(B+1, N+1):
nu = (nu * i) % (10 ** 9 + 7)
for i in range(1, A+1):
de = (de * i) % (10 ** 9 + 7)
print((nu * pow(de, -1, 10 ** 9 + 7) ) % (10 ** 9 + 7)) | def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10**9 + 7
N = 10**6 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N+1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
x,y=map(int,input().split())
if ((x+y)%3!=0):
print(0)
else:
xx=(2*x-y)//3
yy=(2*y-x)//3
if (xx<0 or yy<0):
print(0)
else:
ans=cmb(xx+yy,xx,p)
print(ans) | 1 | 149,993,825,788,668 | null | 281 | 281 |
n=input()
lst=[int(x) for x in input().split()]
print(min(lst),max(lst),sum(lst))
| num = int(input())
num_list = list(map(int,input().split(" ")))
print(min(num_list),max(num_list),sum(num_list))
| 1 | 735,518,775,278 | null | 48 | 48 |
N, M = map(int, input().split())
Alst = list(map(int, input().split()))
k = sum(Alst)
ans = N - k
if ans >= 0:
print(ans)
else:
print(-1) | N = int(input())
a = list(map(int, input().split()))
count = 0
for i in range(N):
minj = i
for j in range(i, N):
if a[j] < a[minj]:
minj = j
if a[i] != a[minj]:
a[minj], a[i] = a[i], a[minj]
count += 1
print(*a)
print(count) | 0 | null | 16,028,642,598,870 | 168 | 15 |
def merge(A, left, mid, right):
global c
n1 = mid - left
n2 = right - mid
L = [0 for e in range(n1+1)]
R = [0 for e in range(n2+1)]
L = A[left:mid] + [10 ** 9]
R = A[mid:right] + [10 ** 9]
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
c += right - left
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n = int(input())
S = [int(e) for e in input().split()]
c = 0
mergeSort(S,0,n)
print(*S)
print(c)
| import sys
input = sys.stdin.readline
n = int(input())
L = [int(x) for x in input().split()]
cnt = 0
def Merge(S, l, m, r):
global cnt
cnt += r - l
L = S[l:m] + [float('inf')]
R = S[m:r] + [float('inf')]
i, j = 0, 0
for k in range(l, r):
if L[i] < R[j]:
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
return
def MergeSort(S, l, r):
if r - l > 1:
m = (l + r) // 2
MergeSort(S, l, m)
MergeSort(S, m, r)
Merge(S, l, m, r)
return
MergeSort(L, 0, n)
print(*L)
print(cnt)
| 1 | 113,071,225,888 | null | 26 | 26 |
N = int(input())
print(N//2 + N % 2) | import math
x = int(input())
print(math.ceil(x/2)) | 1 | 59,078,918,233,100 | null | 206 | 206 |
n = input()
R = []
for i in range(n):
R.append(input())
min_v = R[0]
max_v = -1000000000000
for i in range(1, n):
temp = R[i] - min_v
if (temp >= max_v):
max_v = temp
temp = R[i]
if (min_v >= temp):
min_v = temp
print max_v | import sys
n = int(input())
r0 = int(input())
r1 = int(input())
mx = r1-r0
mn = min(r1,r0)
l = map(int,sys.stdin.readlines())
for i in l:
if mx < i - mn:
mx = i - mn
elif mn > i:
mn = i
print(mx) | 1 | 13,464,802,784 | null | 13 | 13 |
r = input()
print(r[0:3]) | #! -*- coding: utf-8 -*-
import random
import math
s = input()
nums = len(s) - 3
index = math.floor(random.random() * nums)
print(s[index: index + 3])
| 1 | 14,822,909,516,490 | null | 130 | 130 |
import math
a,b,c=map(int, input().split())
c=math.radians(c)
print(0.5*a*b*math.sin(c))
print(a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(c)))
print(b*math.sin(c)) | #!/usr/bin/env python
# coding: utf-8
# In[14]:
from collections import deque
# In[21]:
S = deque(input())
Q = int(input())
rev_cnt = 0
for _ in range(Q):
q = input().split()
if len(q) == 1:
rev_cnt += 1
else:
if (rev_cnt+int(q[1]))%2 == 0:
S.append(q[2])
else:
S.appendleft(q[2])
if rev_cnt%2 == 0:
print("".join(S))
else:
print("".join(list(reversed(S))))
# In[ ]:
| 0 | null | 28,550,262,757,160 | 30 | 204 |
X = list(map(int, input().split()))
ans = None
for i, xi in enumerate(X):
if xi == 0:
ans = i + 1
print(ans) | def main():
nums = list(map(int,input().split()))
for i,n in enumerate(nums):
if n == 0:
return i + 1
if __name__ == '__main__':
print(main()) | 1 | 13,356,256,214,222 | null | 126 | 126 |
A = int(input())
B = int(input())
if A != 1 and B != 1:
print('1')
elif A != 2 and B != 2:
print('2')
else:
print('3')
| n = int(input())
lst = []
for i in range(n):
tmp = input().split()
lst.append(tmp)
d = {}
for i in range(n):
if lst[i][0] == 'insert':
d[lst[i][1]] = d.get(lst[i][1], 0) + 1
elif lst[i][0] == 'find':
print('yes') if lst[i][1] in d else print('no')
| 0 | null | 55,666,484,477,538 | 254 | 23 |
n,k =map(int,input().split())
l = list(map(int,input().split()))
l = sorted(l)
print(sum(l[0:k]))
| import sys
n = int(input())
for i in range(n):
ns = [x * x for x in map(int, input().split())]
if ns[0] + ns[1] == ns[2] or ns[0] + ns[2] == ns[1] or ns[1] + ns[2] == ns[0]:
print("YES")
else:
print("NO") | 0 | null | 5,802,080,871,906 | 120 | 4 |
a, b, c = map(int, input().split())
if 2*(a*b + (a+b)*c) < a**2+b**2+c**2 and c > a + b:
print('Yes')
else:
print('No') | a, b, c = map(int, input().split())
d = c - a - b
if d >= 0 and d * d > 4 * a * b:
print("Yes")
else:
print("No")
| 1 | 51,570,421,632,092 | null | 197 | 197 |
H, N = map(int, input().split())
N = list(map(int, input().split()))
print("Yes") if(sum(N) >= H) else print("No")
| N = int(input())
S = input()
for s in S:
print(chr(65+(ord(s)+N-65)%26),end="") | 0 | null | 106,425,233,356,120 | 226 | 271 |
n = int(input())
s = list(input())
m = n//2
if n%2 != 0:
ans = "No"
else:
for i in range(m):
if s[i] != s[m+i]:
ans = "No"
break
ans = "Yes"
print(ans) | N = int(input())
s = input()
if N % 2 == 1:
print("No")
elif s[0:N//2] != s[N//2:]:
print("No")
else:
print("Yes") | 1 | 147,352,125,185,172 | null | 279 | 279 |
n = int(input())
a = sorted(list(map(int, input().split())))
x = 1
for i in range(n):
x = x * a[i]
if x == 0:
break
elif x > 10 ** 18:
x = -1
break
print(x)
| n=int(input())
r=[int(input()) for i in range(n)]
maxv=r[1]-r[0]
minv=r[0]
for i in range(1,n):
maxv=max(maxv,r[i]-minv)
minv=min(minv,r[i])
print(maxv)
| 0 | null | 8,055,653,133,022 | 134 | 13 |
# coding=utf-8
from __future__ import division
from math import sqrt
def mean(list_):
return sum(list_) / len(list_)
def std(list_):
m = mean(list_)
return sqrt(sum([(x - m) ** 2 for x in list_]) / len(list_))
def main():
n = input()
while n:
scores = map(int, raw_input().split())
print std(scores)
n = input()
if __name__ == '__main__':
main() | N=int(input())
S=input()
print(bytes((s-65+N)%26+65 for s in S.encode()).decode()) | 0 | null | 67,282,045,395,680 | 31 | 271 |
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import fractions
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
#2で何回割れるかを数える関数
def t_per2(k):
return format(k,'b')[::-1].find('1')
def main():
n,m = map(int,ipt().split())
a = [int(i) for i in ipt().split()]
k2 = t_per2(a[0])
l = a[0]//2
for ai in a[1::]:
if not k2 == t_per2(ai):
print(0)
exit()
l = l*(ai//2)//(fractions.gcd(l,ai//2))
if l > m:
print(0)
exit()
print((m+l)//(2*l))
return
if __name__ == '__main__':
main()
| import math
import sys
from functools import reduce
N, M = map(int, input().split())
A = list(map(int, input().split()))
for i in range(N):
A[i] = A[i] // 2
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
C = lcm_list(A)
B = [0 for _ in range(N)]
for i in range(N):
B[i] = C // A[i]
if B[i] % 2 == 0:
print(0)
sys.exit()
print( (M // C + 1) // 2) | 1 | 101,392,300,919,668 | null | 247 | 247 |
a1,a2,a3 = map(int,input().split())
print('bust' if (a1+a2+a3) >= 22 else 'win') | # ABC149
# B Greesy Takahashi
# takはA枚、aokiはB枚、TAKはK回
a, b, k = map(int, input().split())
if k > a:
if k - a > b:
print(0,0)
else:
print(0,b - (k - a))
else:
print(a-k,b)
| 0 | null | 111,715,509,935,360 | 260 | 249 |
N=int(input())
A=list(map(int, input().split()))
q=int(input())
Q=[list(map(int, input().split())) for _ in range(q)]
L=[0]*(10**5+1)
S=0
for i in range(N):
L[A[i]]+=1
S+=A[i]
for i in range(q):
S+=L[Q[i][0]]*(Q[i][1]-Q[i][0])
L[Q[i][1]]+=L[Q[i][0]]
L[Q[i][0]]=0
# print(L)
print(S) | n = int(input())
A = list(map(int, input().split()))
S = sum(A)
D = {c:0 for c in range(1, 10**5+1)}
for a in A:
D[a] += 1
for _ in range(int(input())):
B, C = map(int, input().split())
S += (C-B)*D[B]
D[C] += D[B]
D[B] = 0
print(S) | 1 | 12,175,955,433,978 | null | 122 | 122 |
def main():
S = input()
k = int(input())
if len(set(list(S))) == 1:
print(len(S) * k // 2)
exit()
A = []
cnt = 1
tmp = S[0]
for s in S[1::]:
if s == tmp:
cnt += 1
else:
A.append(cnt)
tmp = s
cnt = 1
A.append(cnt)
ans = sum([a // 2 for a in A])
if S[0] == S[-1]:
A[0] += A[-1]
A.pop()
ans += sum([a // 2 for a in A]) * (k - 1)
print(ans)
if __name__ == '__main__':
main()
| s=list(input())
a=int(input())
w = ""
c = 0
cnt = 0
for i in s:
if w != i:
#print(w)
cnt += c//2
c = 1
w = i
else:
c +=1
cnt += c//2
#print(cnt)
start = 0
start_w = s[0]
for i in s:
if start_w != i:
break
else:
start +=1
s.reverse()
end = 0
end_w = s[0]
for i in s:
if end_w != i:
break
else:
end +=1
same = len(list(set(s)))
#print(same)
if s[0] != s[-1]:
print(cnt*a)
elif same ==1:
print(len(s)*a//2)
else:
print(cnt*a-(a-1)*(start//2+end//2-(start+end)//2)) | 1 | 175,306,142,892,738 | null | 296 | 296 |
W,H,x,y,r = input().split()
W = int(W)
H = int(H)
x = int(x)
y = int(y)
r = int(r)
if x < 0 or y < 0:
print("No")
else:
if W - x >= r and H - y >= r:
print("Yes")
else:
print("No") | ins = input().split()
w = int(ins[0])
h = int(ins[1])
x = int(ins[2])
y = int(ins[3])
r = int(ins[4])
if x - r >= 0 and y - r >= 0 and x + r <= w and y + r <= h:
print("Yes")
else:
print("No") | 1 | 455,955,837,008 | null | 41 | 41 |
from collections import defaultdict
def prime_factor(n):
d = defaultdict(int)
for i in range(2, n + 1):
if i * i > n:
break
while n % i == 0:
d[i] += 1
n //= i
if n != 1:
d[n] += 1
return d
N = int(input())
d = prime_factor(N)
ans = 0
for v in d.values():
i = 1
cur = 1
cnt = 0
while cur <= v:
cnt += 1
i += 1
cur += i
ans += cnt
print(ans)
| #!/usr/bin/env python3
m1, d1 = [int(x) for x in input().split()]
m2, d2 = [int(x) for x in input().split()]
print('1' if m1 != m2 else '0')
| 0 | null | 70,507,638,228,262 | 136 | 264 |
K,X= map(int,input().split())
if 500*K >= X:
print("Yes")
else:
print("No") | l = input().split()
n,x = int(l[0]), int(l[1])
if 500*n >= x:
print("Yes")
else:
print("No") | 1 | 98,554,979,628,992 | null | 244 | 244 |
def resolve():
N = int(input())
S = input()
cnt = 0
for i in range(len(S)-2):
if S[i:i+3] == "ABC":
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve() | n = int(input())
S = list(input())
ans = 0
for i in range(len(S)-2):
if S[i] == "A":
if S[i+1] == "B":
if S[i+2] == "C":
ans += 1
print(ans) | 1 | 98,930,473,514,840 | null | 245 | 245 |
cin = open(0).read().strip().split('\n')
n = int(cin[0])
g = [list(map(lambda x: int(x)-1, a.split(' ')[2:])) for a in cin[1:]]
first_order = [-1] * n
last_order = [-1] * n
ptr = 1
def dfs(g, seen, idx):
global first_order, first_order, ptr
first_order[idx] = ptr
ptr += 1
seen[idx] = True
for i in g[idx]:
# idxから行ける各頂点について
if seen[i]: continue
dfs(g, seen, i)
last_order[idx] = ptr
ptr += 1
seen = [False] * n
dfs(g, seen, 0)
# 孤立している頂点対策
for i in range(n):
if not seen[i]:
ans = dfs(g, seen, i)
# 出力
for idx, (f, l) in enumerate(zip(first_order, last_order)):
print(idx+1, f, l)
| n = int(raw_input())
d = [0 for i in range(n)]
f = [0 for i in range(n)]
a = [[0 for i in range(n)] for j in range(n)]
st = [0 for i in range(n)]
time = [0]
g = [0 for i in range(n)]
def dfs_visit(s):
st[s] = 1
time[0] += 1
d[s] = time[0]
for k in range(n):
if a[s][k] == 1 and st[k] == 0:
dfs_visit(k)
st[s] ==2
time[0] += 1
f[s] = time[0]
def main():
for s in range(n):
if st[s] == 0:
dfs_visit(s)
for s in range(n):
print '%d %d %d' %(s+1, d[s], f[s])
for i in range(n):
g = map(int, raw_input().split())
for j in range(g[1]):
a[g[0]-1][g[2+j]-1] = 1
main() | 1 | 2,590,086,340 | null | 8 | 8 |
def insertionSort(A):
for i in range(1, len(A)):
j = A[i]
k = i
while k - 1 >= 0:
if A[k - 1] > j:
A[k] = A[k - 1]
A[k - 1] = j
k = k - 1
return A
def insertionSort(m, A, CNT):
for i in range(m, len(A)):
j = A[i]
k = i
while k - m >= 0 and A[k-m] > j:
A[k] = A[k - m]
A[k - m] = j
CNT = CNT + 1
k = k - m
# while k - m >= 0:
# if A[k - m] > j:
# A[k] = A[k - m]
# A[k - m] = j
# CNT = CNT + 1
# k = k - m
return A, CNT
n = int(input()) # 例:6
a = [] # 例:[1, 4, 3, 6, 2, 5]
for i in range(0, n):
a.append(int(input()))
cnt = 0
M = []
temp = 1
while temp <= n:
M.append(temp)
temp = 3 * temp + 1
M.sort(reverse=True)
#M=[1]
for j in M:
a, cnt = insertionSort(j, a, cnt)
print(len(M))
print(' '.join([str(n) for n in M]))
print(cnt)
for k in a:
print(k)
| #coding:utf-8
#1_2_D
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j -= g
cnt += 1
A[j+g] = v
def shellSort(A, n):
G = [1]
while True:
g = 3*G[0] + 1
if g > n:
break
G.insert(0, g)
m = len(G)
for i in range(m):
insertionSort(A, n, G[i])
return [m, G]
n = int(input())
A = [int(input()) for i in range(n)]
cnt = 0
m, G = shellSort(A, n)
print(m)
print(" ".join(map(str, G)))
print(cnt)
print("\n".join(map(str, A))) | 1 | 31,223,474,668 | null | 17 | 17 |
s,w = (int(x) for x in input().split())
if s <= w:
print("unsafe")
else:
print("safe") | s, w = list(map(int, input().split()))
output = "safe"
if s <= w:
output = "un" + output
print(output) | 1 | 29,132,736,525,632 | null | 163 | 163 |
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')
class BinaryIndexedTree:
def __init__(self,n,default=0):
self.s=[default]*(n+1)
self.n=n
def add(self,val,idx):
while idx<self.n+1:
self.s[idx]=self.s[idx]+val
idx+=idx&(-idx)
return
def get(self,idx):
res=0
while idx>0:
res=res+self.s[idx]
idx-=idx&(-idx)
return res
from collections import defaultdict
def main():
n=II()
s=input()
S=[0]+list(s)
d=defaultdict(lambda:BinaryIndexedTree(n))
for i,si in enumerate(s):
#print(i,si)
d[si].add(1,i+1)
q=II()
for _ in range(q):
f,a,b=input().split()
if int(f)==1:
a=int(a)
d[S[a]].add(-1,a)
d[b].add(1,a)
S[a]=b
else:
#print(S,a,b)
a=int(a)
b=int(b)
cnt=0
for bit in d.values():
if bit.get(b)-bit.get(a-1)>0:
cnt+=1
print(cnt)
if __name__=="__main__":
main()
| #from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
a,b = readInts()
print(a*b if (1 <= a <= 9 and 1 <= b <= 9) else '-1')
| 0 | null | 110,213,693,955,446 | 210 | 286 |
def abc169c_multiplication3():
a, b = input().split()
a = int(a)
b = int(b[0] + b[2] + b[3])
print(a * b // 100)
abc169c_multiplication3()
| # C問題
# 難しく考えず、入力された配列の先頭の要素から順に見に行く
# cur_maxという、①最大身長格納変数を用意、②①を更新して行く この2ステップの考え方が大事
N = int(input())
cur_max = 0
ans = 0
# 配列を入力
A = list(map(int, input().split()))
for i in A:
if cur_max > i:
ans += cur_max - i
# どんどん高いものに更新→max関数で処理
cur_max = max(i, cur_max)
print(ans) | 0 | null | 10,622,476,736,300 | 135 | 88 |
n = int(input())
ans = 0
if n%2 == 0:
ans = n//2
print(ans)
else:
ans = n//2 +1
print(ans) | N=int(input())
s=list()
t=list()
st=[]
for i in range(N):
st.append(input().split())
X=input()
ans=0
count=False
for j in range(N):
if count:
ans+=int(st[j][1])
if st[j][0]==X:
count=True
print(ans) | 0 | null | 78,086,082,402,272 | 206 | 243 |
inf = float("inf")
S = input()
N = len(S)
bestP = [None for i in range(N)]
bestD = [None for i in range(N)]
if S[0] in ["?", "D"]:
bestP[0] = 0
bestD[0] = 1
else:
bestP[0] = 0
bestD[0] = 0
for i in range(1, N):
bestP[i] = max(bestD[i - 1], bestP[i - 1])
bestD[i] = max(bestD[i - 1] + 1, bestP[i - 1] + 2)
if S[i] != "?":
if S[i] == "P":
bestD[i] = -inf
else:
assert S[i] == "D"
bestP[i] = -inf
ans = [None for i in range(N)]
if bestP[-1] > bestD[-1]:
ans[-1] = 'P'
else:
ans[-1] = 'D'
for i in range(N - 2, -1, -1):
if S[i] != '?':
ans[i] = S[i]
else:
prev = ans[i + 1]
if prev == 'D':
if bestP[i] + 2 > bestD[i] + 1:
ans[i] = 'P'
else:
ans[i] = 'D'
else:
if bestP[i] > bestD[i]:
ans[i] = 'P'
else:
ans[i] = 'D'
print(''.join(ans)) | R,C,K=map(int,input().split())
V=[[0 for _ in range(C)] for _ in range(R)]
for i in range(K):
r,c,v=map(int,input().split())
V[r-1][c-1]=v
dp=[[0 for _ in range(4)] for _ in range(C+1)]
for i in range(R):
ndp=[[0 for _ in range(4)] for _ in range(C+1)]
for j in range(C):
ndp[j][0]=max(dp[j])
for j in range(C):
v=V[i][j]
for n in range(1,4):
ndp[j][n]=max(ndp[j-1][n-1]+v,dp[j][3]+v,ndp[j-1][n])
dp=ndp
print(max(dp[C-1]))
| 0 | null | 12,032,478,518,690 | 140 | 94 |
import math
def str2list(str):
result = []
for value in str.split(' '):
result.append(int(value))
return result
def distance1(n, x, y):
result = 0
for i in range(n):
result += abs(x[i] - y[i])
return result
def distance2(n, x, y):
result = 0
for i in range(n):
result += (x[i] - y[i]) * (x[i] - y[i])
return math.sqrt(result) if result != 0 else 0
def distance3(n, x, y):
result = 0
for i in range(n):
result += math.pow(abs(x[i] - y[i]), 3)
return math.exp(math.log(result)/3) if result != 0 else 0
def distanceInf(n, x, y):
result = 0
for i in range(n):
new_result = abs(x[i] - y[i])
result = new_result if new_result > result else result
return result
n = int(input());
x = str2list(input())
y = str2list(input())
print('%.6f'%distance1(n, x, y))
print('%.6f'%distance2(n, x, y))
print('%.6f'%distance3(n, x, y))
print('%.6f'%distanceInf(n, x, y)) | import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
H, W = map(int, readline().split())
import math
if W == 1 or H == 1:
print(1)
exit()
w_can = W // 2
ans = w_can * H
if W % 2 != 0:
ans += math.ceil(H / 2)
print(ans) | 0 | null | 25,336,052,979,452 | 32 | 196 |
A = list(map(int, input().split()))
for i in range(len(A)):
if A[i] == 0: print(i+1) | import itertools
# import math
# N = int(input())
# S = input()
# n, *a = map(int, open(0))
N, M = map(int, input().split())
# P = list(map(int, input().split()))
# Q = list(map(int, input().split()))
# S = input()
aced = {}
waed = [0] * (N + 1)
cnt_ac = 0
for i in range(M):
p_i, S_i = input().split()
if S_i == 'WA':
if not p_i in aced:
waed[int(p_i)] += 1
else:
if not p_i in aced:
cnt_ac += 1
aced[p_i] = 1
cnt_pena = 0
for k in aced:
cnt_pena += waed[int(k)]
print(cnt_ac, cnt_pena)
# print(aced) | 0 | null | 53,551,104,398,580 | 126 | 240 |
def main():
n, k = map(int, input().split())
MOD = 10**9 + 7
a = [0]*(k+1)
for i in range(1, k+1):
a[i] = pow(k//i, n, MOD)
for i in reversed(range(1, k+1)):
for j in range(2*i, k+1, i):
a[i] -= a[j]
a[i] %= MOD
ans = 0
for i in range(1, k+1):
ans += a[i]*i
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | NNN = list(map(int,input().split()))
print('Yes'if NNN[1]*NNN[2]>=NNN[0] else 'No')
| 0 | null | 20,256,589,025,120 | 176 | 81 |
n,m = map(int, input().split())
#a = list(map(int, input().split()))
class UnionFind:
def __init__(self,n):
self.par=[i for i in range(n)]
self.siz=[1]*n
def root(self,x):
while self.par[x]!=x:
self.par[x]=self.par[self.par[x]]
x=self.par[x]
return x
def unite(self,x,y):
x=self.root(x)
y=self.root(y)
if x==y:
return False
if self.siz[x]<self.siz[y]:
x,y=y,x
self.siz[x]+=self.siz[y]
self.par[y]=x
return True
def is_same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return self.siz[self.root(x)]
uni = UnionFind(n)
for i in range(m):
a,b = map(int, input().split())
uni.unite(a-1, b-1)
cnt = [0]*(n)
for i in range(n):
cnt[uni.root(i)] = 1
print(sum(cnt)-1) | a, b = input().split(" ")
x = int(a)
y = int(b)
amt = 0
if x == 1:
amt += 300000
elif x == 2:
amt += 200000
elif x == 3:
amt += 100000
if y == 1:
amt += 300000
elif y == 2:
amt += 200000
elif y == 3:
amt += 100000
if x == 1 and y == 1:
amt += 400000
print (amt) | 0 | null | 71,748,655,090,140 | 70 | 275 |
S = int (input ())
print (S**2) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
r = int(readline())
print(r ** 2)
| 1 | 145,190,479,899,424 | null | 278 | 278 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
cnt=0
for i in range(n-k):
if a[cnt]<a[cnt+k]:
print("Yes")
else:
print("No")
cnt+=1
| n = list(input())
if n[0] == n[1] and n[1] == n[2]:
print("No")
else:
print("Yes") | 0 | null | 31,118,774,049,650 | 102 | 201 |
allst = list(input().split())
stk = []
ans = 0
for i in range(0, len(allst)):
if allst[i] == '+':
stk[len(stk)-2] = stk[len(stk)-2] + stk[len(stk)-1]
del stk[len(stk)-1]
elif allst[i] == '-':
stk[len(stk)-2] = stk[len(stk)-2] - stk[len(stk)-1]
del stk[len(stk)-1]
elif allst[i] == '*':
stk[len(stk)-2] = stk[len(stk)-2] * stk[len(stk)-1]
del stk[len(stk)-1]
else:
stk.append(int(allst[i]))
print(stk[len(stk)-1]) | s = input().split()
st = []
for i in range(len(s)):
c = s.pop(0)
if c == '+':
b = st.pop(0)
a = st.pop(0)
ans = a + b
st.insert(0,ans)
elif c == '-':
b = st.pop(0)
a = st.pop(0)
ans = a - b
st.insert(0,ans)
elif c == '*':
b = st.pop(0)
a = st.pop(0)
ans = a * b
st.insert(0,ans)
else:
st.insert(0, int(c))
print(st.pop(0))
| 1 | 34,227,492,378 | null | 18 | 18 |
if(int(input()) %2 == 1):
print("No")
exit()
t = input()
if(t[:len(t)//2] == t[len(t)//2:]):
print("Yes")
else:
print("No")
| N = int(input())
P = list(map(int, input().split()))
mini = 10 ** 9
count = 0
for i in range(N):
if P[i] <= mini:
mini = P[i]
count += 1
print(count) | 0 | null | 116,098,445,196,206 | 279 | 233 |
#import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
import heapq
from fractions import gcd
#input=sys.stdin.readline
#import bisect
n,m=map(int,input().split())
a=list(map(int,input().split()))
def lcm(a,b):
g=math.gcd(a,b)
return b*(a//g)
l=a[0]//2
for i in range(n):
r=a[i]//2
l=lcm(l,r)
for i in range(n):
if (l//(a[i]//2))%2==0:
print(0)
exit()
res=m//l
print((res+1)//2) | N,K=map(int,input().split())
P=list(map(int,input().split()))
P=[i-1 for i in P]
C=list(map(int,input().split()))
import math
ans=-10**18
for i in range(N):
x=i
tot=0
cycle=[]
while True:
x=P[x]
cycle.append(C[x])
tot+=C[x]
if x==i:
break
L=len(cycle)
t=0
for i in range(L):
t+=cycle[i]
if i+1>K:
break
now=t
if tot>0:
e=(K-i-1)//L
now+=tot*e
ans=max(ans,now)
print(ans) | 0 | null | 53,391,271,471,648 | 247 | 93 |
x = int(input())
print(int(x/2)+ 1 if x % 2 != 0 else int(x/2)) | import math
N = int(input())
ans = math.ceil(N / 2.0)
print(ans)
| 1 | 58,707,060,313,320 | null | 206 | 206 |
n = int(input())
a = list(map(int, input().split()))
m = 1
if 0 in a:
print(0)
else:
for i in range(n):
m = m * a[i]
if m > 10 ** 18:
print(-1)
break
elif i == n - 1:
print(m) | A,B = map(int,input().split())
C = A*B
print(str(C)) | 0 | null | 15,876,110,709,880 | 134 | 133 |
n = int(input())
a = list(map(int,input().split()))
d = {}
for i in range(1,n+1):
if i not in d:
d[i] = 0
for i in range(len(a)):
d[a[i]] += 1
for i in range(1,n+1):
print(d[i]) | N = int(input())
A = [int(i) for i in input().split()]
P = [0]*N
for i in range(N-1):
P[A[i]-1] += 1
for i in range(N):
print(P[i]) | 1 | 32,542,814,114,720 | null | 169 | 169 |
from math import gcd
k=int(input())
cnt=0
for i in range(1,k+1):
for j in range(1,k+1):
a=gcd(i,j)
for k in range(1,k+1):
cnt+=gcd(a,k)
print(cnt)
| import math
K = int(input())
sum = 0
for i in range(1,K+1):
for j in range(1,K+1):
temp = math.gcd(i,j)
for k in range(1,K+1):
sum+=math.gcd(temp,k)
print (sum) | 1 | 35,387,783,232,612 | null | 174 | 174 |
n,k = map(int,input().split());
kk = n-k+2
a = [0]*kk
for i in range(kk):
ii = i + k
p = ii*(ii-1);
q = ii*(2*n+1-ii);
a[i] = (q//2)-(p//2)+1;
con = 0;
for v in range(kk):
con = (con+a[v]) % 1000000007;
print(con); | N = input().strip()
INFTY = 10**8
dp = [[INFTY for _ in range(2)] for _ in range(len(N)+1)]
a = int(N[-1])
for i in range(10):
if i<a:
dp[1][1] = min(dp[1][1],i+10-a)
else:
dp[1][0] = min(dp[1][0],i+i-a)
for k in range(2,len(N)+1):
a = int(N[-k])
for i in range(10):
if i>=a:
dp[k][0] = min(dp[k][0],dp[k-1][0]+i+i-a)
if i-1>=a:
dp[k][0] = min(dp[k][0],dp[k-1][1]+i+i-1-a)
if i<a:
dp[k][1] = min(dp[k][1],dp[k-1][0]+i+10-a)
if i==0:
dp[k][1] = min(dp[k][1],dp[k-1][1]+9-a)
if 0<=i-1<a:
dp[k][1] = min(dp[k][1],dp[k-1][1]+i+10-a+i-1)
print(min(dp[len(N)][0],dp[len(N)][1]+1)) | 0 | null | 51,958,361,497,472 | 170 | 219 |
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
n, m = map(int, input().split())
if n % 2 == 0:
n -= 1
ans = []
left_range = n//2
right_range = n//2 - 1
left1 = 1
right1 = 1 + left_range
left2 = right1 + 1
right2 = left2 + right_range
while True:
if left1 >= right1:
break
ans.append([left1, right1])
left1 += 1
right1 -= 1
while True:
if left2 >= right2:
break
ans.append([left2, right2])
left2 += 1
right2 -= 1
for i in range(m):
print(*ans[i])
| rate = int(input())
if 400 <= rate < 600:
print("8")
elif 600 <= rate <800:
print("7")
elif 800 <= rate <1000:
print("6")
elif 1000 <= rate <1200:
print("5")
elif 1200 <= rate <1400:
print("4")
elif 1400 <= rate <1600:
print("3")
elif 1600 <= rate <1800:
print("2")
elif 1800 <= rate <2000:
print("1")
| 0 | null | 17,702,912,785,052 | 162 | 100 |
n = int(input())
a = list(map(int, input().split()))
num = [0]*(10**6+1)
for x in a:
num[x] += 1
pairwise = True
for i in range(2, 10**6+1):
cnt = sum(num[i::i])
if cnt == n:
print('not coprime')
exit()
if cnt > 1:
pairwise = False
if pairwise:
print('pairwise coprime')
else:
print('setwise coprime')
| n=int(input())
l=sorted(list(map(int,input().split())),reverse=True)
count=0
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
if l[i]<l[j]+l[k] and l[i]!=l[j]!=l[k]:
count+=1
print(count) | 0 | null | 4,637,318,639,100 | 85 | 91 |
from itertools import permutations
N = int(input())
P = ''.join(input().split())
Q = ''.join(input().split())
l = sorted(permutations(range(1, N + 1), N))
d = {''.join(map(str, k)): v+1 for v, k in enumerate(l)}
print(abs(d[P]-d[Q]))
| # coding=utf-8
def print_list(X):
first_flag = True
for val in X:
if first_flag:
print_line = str(val)
first_flag = False
else:
print_line = print_line + ' ' + str(val)
print(print_line)
def combine_list(A_suit, A_rank, N):
A_after = []
for i in range(N):
A_after.append(A_suit[i] + str(A_rank[i]))
return A_after
def bubble_sort(A, index_list, N):
#print_list(A)
#flag: ???????????????????????????True???????´?
flag = True
i = 0
while flag:
flag = False
for j in range(N-1, i, -1):
if A[j] < A[j-1]:
A[j-1], A[j] = A[j], A[j-1]
index_list[j-1], index_list[j] = index_list[j], index_list[j-1]
flag = True
i += 1
return A, index_list
def selection_sort(A, index_list, N):
for i in range(N):
min_j = i
for j in range(i, N):
if A[j] < A[min_j]:
min_j = j
if i != min_j:
A[i], A[min_j] = A[min_j], A[i]
index_list[i], index_list[min_j] = index_list[min_j], index_list[i]
return A, index_list
def main():
N = int(input())
A = list(input().split())
A_suit = []
A_rank = []
index_list = [x for x in range(N)]
A_after_bubble = []
A_after_selection = []
for element in A:
val = list(element)
val_suit = val[0]
val_rank = int(val[1])
A_suit.append(val_suit)
A_rank.append(val_rank)
A_suit_after_bubble = [0 for x in range(N)]
A_suit_after_selection = [0 for x in range(N)]
A_rank_after_bubble, index_list_after_bubble = bubble_sort(A_rank.copy(), index_list.copy(), N)
A_rank_after_selection, index_list_after_selection = selection_sort(A_rank.copy(), index_list.copy(), N)
for index_before, index_after in enumerate(index_list_after_bubble):
A_suit_after_bubble[index_before] = A_suit[index_after]
for index_before, index_after in enumerate(index_list_after_selection):
A_suit_after_selection[index_before] = A_suit[index_after]
A_after_bubble = combine_list(A_suit_after_bubble, A_rank_after_bubble, N)
A_after_selection = combine_list(A_suit_after_selection, A_rank_after_selection, N)
print_list(A_after_bubble)
print("Stable")
print_list(A_after_selection)
if A_after_selection == A_after_bubble:
print("Stable")
else:
print("Not stable")
if __name__ == '__main__':
main() | 0 | null | 50,223,965,460,670 | 246 | 16 |
#silver fox
n,d,a=map(int,input().split())
from collections import deque
import math
data=[]
for i in range(n):
x,h=map(int,input().split())
data.append((x,h))
data=sorted(data,key=lambda x:x[0])
#data を位置の順番にソートしておく
add=0
damage_sum=0
damage_map=deque([])
for i in range(n):
if damage_map:
while damage_map and damage_map[0][0]<data[i][0]:
k=damage_map.popleft()
damage_sum-=k[1]
if damage_sum<data[i][1]:
p=math.ceil((data[i][1]-damage_sum)/a)
damage_sum+=p*a
add+=p
#少なくともp回の攻撃を加えなくてはならない
damage_map.append((data[i][0]+2*d,p*a))
#data[i][0]+2*dのところまではp*aのダメージがプラスとして加算される
print(add) | from bisect import bisect_left
def main():
n, dis, dam = map(int, input().split())
mon = [list(map(int, input().split())) for _ in range(n)]
mon.sort(key=lambda x: x[0])
p = [v[0] for v in mon]
imos = [0]*(n+1)
dis = 2*dis + 1
ans = 0
for i in range(n):
if 0 < i:
imos[i] += imos[i-1]
if imos[i] < mon[i][1]:
tmp = (mon[i][1] - imos[i] + dam - 1) // dam
ans += tmp
tmp *= dam
imos[i] += tmp
idx = bisect_left(p, p[i]+dis)
imos[idx] -= tmp
print(ans)
if __name__ == "__main__":
main() | 1 | 82,492,022,033,190 | null | 230 | 230 |
q=int(input())
dic={}
for i in range(q):
s=input()
if not s in dic:
dic[s]=1
else:
dic[s]+=1
max_val=max(dic.values())
a=sorted([i for i, k in dic.items() if k == max_val])
for i in a:
print(i)
| x,n = map(int,input().split())
if n == 0:
print(x)
exit()
p = list(map(int,input().split()))
ans = []
num = 0
while ans == []:
if x + num in p and x - num in p:
num+=1
else:
if x + num not in p and x - num not in p:
ans = x - num
elif x + num not in p:
ans = x + num
else:
ans = x - num
print(ans) | 0 | null | 41,986,227,493,572 | 218 | 128 |
from collections import deque
N, D, A = list(map(int, input().split()))
pair_xh = [[-1, -1] for _ in range(N)] # 1回ずつしか使わないけどソートするから必要
for i in range(N):
pair_xh[i][0], pair_xh[i][1] = list(map(int, input().split()))
pair_xh.sort(key = lambda x: x[0]) #座標でソート
q_lim_d = deque() # 累積和に含まれる攻撃範囲とダメージを保存する場所
total = 0 # 喰らいダメージの累積和
count = 0 # 攻撃回数
for i in range(N):
x = pair_xh[i][0]
h = pair_xh[i][1]
while len(q_lim_d) and q_lim_d[-1][0] < x: # 範囲外になったら喰らわないから累積和から外す
total -= q_lim_d[-1][1]
q_lim_d.pop()
h -= total
if h > 0: # 見てる敵の体力が0になる攻撃回数を求めその分を累積和に足す
times = (h + A - 1) // A # 0にするのに必要な回数(切り上げ)
count += times
damage = A * times
total += damage
q_lim_d.appendleft([x + 2 * D, damage])
print(count) | from collections import deque
from math import ceil
n,d,a = map(int,input().split())
M = [list(map(int,input().split())) for i in range(n)]
M = sorted([(x,ceil(h/a)) for x,h in M])
que = deque()
ans = 0
atack = 0
for x,h in M:
while len(que) > 0 and que[0][0] < x:
tx,ta = que.popleft()
atack -= ta
bomb_num = max(0, h-atack)
atack += bomb_num
ans += bomb_num
if bomb_num > 0:
que.append([x+d*2,bomb_num])
print(ans) | 1 | 82,181,146,005,570 | null | 230 | 230 |
x, y = [int(x) for x in input().split()]
def gcd(a, b):
m = a%b
return gcd(b, m) if m else b
print(gcd(x, y))
| import sys
input = sys.stdin.readline
r, c, k = map(int, input().split())
v = [[0 for _ in range(c)] for _ in range(r)]
for i in range(k):
rr, cc, vv = map(int, input().split())
rr, cc = rr - 1, cc - 1
v[rr][cc] = vv
dp = [[0 for _ in range(c + 1)] for _ in range(4)]
for y in range(r):
tmp = [[0 for _ in range(c + 1)] for _ in range(4)]
for x in range(c):
for i in range(2, -1, -1):
dp[i + 1][x] = max(dp[i + 1][x], dp[i][x] + v[y][x])
for i in range(4):
tmp[0][x] = max(tmp[0][x], dp[i][x])
dp[i][x + 1] = max(dp[i][x + 1], dp[i][x])
dp = tmp
print(dp[0][c - 1])
| 0 | null | 2,779,141,135,430 | 11 | 94 |
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)) | import math
from numpy.compat.py3k import asstr
a, b = map(int, input().split())
ans = int(a * b / math.gcd(a, b))
print(str(ans))
| 0 | null | 56,390,107,073,820 | 7 | 256 |
s,t = (i for i in input().split())
print(t+s) | s,t=map(str,input().split());print(t+s) | 1 | 103,290,433,219,120 | null | 248 | 248 |
import sys
d=[0 for i in range(26)]
for line in sys.stdin:
for c in line:
x = ord(c)
if ord('A')<=x and x<=ord('Z'):
x -= (ord('A')-ord('a'))
if ord('a')<=x and x<=ord('z'):
d[x-ord('a')] += 1
for i in range(26):
print("%s : %d" % (chr(ord('a')+i),d[i])) | import sys
cnts = {}
for line in sys.stdin:
for c in list(line.lower()): cnts[c] = cnts.get(c,0) + 1
for c in range(ord('a'),ord('z')+1): print(chr(c),':',cnts.get(chr(c),0))
| 1 | 1,660,394,348,368 | null | 63 | 63 |
N,K = map(int,input().split())
A = list(map(int,input().split()))
wa = [0] * (N+1)
for i in range(N):
wa[i+1] = wa[i] + (A[i]+1)/2
Max = 0
for i in range(N-K+1):
Max = max(Max,wa[K+i]-wa[i])
print(Max)
| n = int(input())
a = sorted(list(map(int, input().split())))
ans = a.pop()
if n % 2:
for i in range((n - 2) // 2):
ans += a.pop() * 2
ans += a.pop()
print(ans)
else:
for i in range((n - 2) // 2):
ans += a.pop() * 2
print(ans) | 0 | null | 42,055,417,097,030 | 223 | 111 |
n = int(input())
x = n%10
a = [0,1,6,8]
if x == 3:
print('bon')
elif x in a:
print('pon')
else:
print('hon') | 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') | 0 | null | 10,302,799,325,442 | 142 | 57 |
N=int(input())
ans=N*2-2
for n in range(1,int(N**.5)+1):
if N%n==0:
ans=min(ans,N//n+n-2)
print(ans) | import numpy
n = int(input())
l = []
ans = n
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
if is_prime(n) :
print(n-1)
if is_prime(n) == False:
for i in range(2,int(numpy.sqrt(n))+1):
if n%i == 0:
a = i
b = n//i
ans = min(n,a+b-2)
print(ans) | 1 | 160,773,300,945,888 | null | 288 | 288 |
n, m, ll = map(int, input().split())
a = []
b = []
for i in range(n):
a.append(list(map(int, input().split())))
for i in range(m):
b.append(list(map(int, input().split())))
for i in range(n):
prt = []
for j in range(ll):
s = 0
for k in range(m):
s += a[i][k] * b[k][j]
prt.append(s)
print(*prt)
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
import numpy as np
def main():
n, m, x = map(int, input().split())
data = np.array(read().split(), np.int64)
data = data.reshape(n, -1) # dataをn行に整形
cost_per_cost = data[:, 0] # data全行の0列
effect_per_book = data[:, 1:]
costs = np.zeros(2**n, np.int64)
# ability 行数：2**n(本の組み合わせパターン), 列数：アルゴリズムの数
ability = np.zeros((2**n, m), np.int64)
for i in range(n):
costs[1<<i:1<<(i+1)] = costs[:1<<i] + cost_per_cost[i]
ability[1<<i:1<<(i+1)] = ability[:1<<i] + effect_per_book[i]
ok = np.all(ability >= x, axis=1)
res = costs[ok]
if len(res) == 0:
print(-1)
else:
print(res.min())
if __name__ == '__main__':
main()
| 0 | null | 11,820,541,431,840 | 60 | 149 |
N = int(input())
A = [int(x) for x in input().split()]
cnt = [0 for x in range(N)]
for i in range(len(A)) :
cnt[A[i]-1] += 1
for i in range(N) :
print(cnt[i]) | N=int(input())
A=list(map(int,input().split()))
n=[0 for x in range(N)]
for i in range(N-1):
n[A[i]-1]+=1
for j in range(N):
print(n[j]) | 1 | 32,494,341,525,690 | null | 169 | 169 |
from itertools import product
N, M, X = map(int, input().split())
C = []
A = []
for _ in range(N):
c, *a = map(int, input().split())
C.append(c)
A.append(a)
ans = float("inf")
for buys in product((0, 1), repeat=N):
cost = 0
achivements = [0] * M
for i, buy in enumerate(buys):
if not buy:
continue
cost += C[i]
for j in range(M):
achivements[j] += A[i][j]
if all(a >= X for a in achivements):
ans = min(ans, cost)
print(ans) if ans != float("inf") else print(-1)
| N,M,X=map(int,input().split())
C=[list(map(int,input().split())) for _ in range(N)]
ans=inf=float('inf')
def dfs(idx,tt,l):
global ans
for i in range(idx,N):
ntt=tt+C[i][0]
nl=[l[j]+C[i][j+1] for j in range(M)]
ok=True
for x in nl:
if x<X:
ok=False
break
if ok:
ans=min(ans,ntt)
else:
dfs(i+1,ntt,nl)
dfs(0,0,[0]*M)
print(ans if ans<inf else -1)
| 1 | 22,297,431,504,612 | null | 149 | 149 |
A, B, K = map(int, input().split())
if A <= K:
B -= K - A
if B < 0:
B = 0
A = 0
else:
A -= K
print(A, B)
| A,B,K=map(int,input().split())
if A>=K:
print(A-K,B)
else:
print(0,max(B-(K-A),0))
| 1 | 104,539,518,901,328 | null | 249 | 249 |
N,D = (int(x) for x in input().split())
count = 0
for i in range(N):
x,y = (int(z) for z in input().split())
dist = x**2 + y**2
if dist <= D**2:
count += 1
print(count) | import math
n, d = [int(n) for n in input().split(' ')]
cnt = 0
for i in range(n):
x, y = [int(n) for n in input().split(' ')]
if math.sqrt(x*x + y*y) <= d:
cnt += 1
print(cnt)
| 1 | 5,917,392,174,880 | null | 96 | 96 |
print("pphbhhphph"[int(input())%10]+"on") | n=input()
a=n[-1]
if a in "24579":
print('hon')
elif a in "0168":
print('pon')
else:
print('bon') | 1 | 19,312,240,224,518 | null | 142 | 142 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.