code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
N = int(input())
print('{:.8f}'.format((N + 1) // 2 / N)) | N = int(input())
g = 0
for n in range(1, N + 1):
if n % 2 == 0:
g += 1
ANS = (N - g) / N
print(ANS) | 1 | 176,902,778,478,250 | null | 297 | 297 |
N, k = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]
s = 0
for i in h:
if i >= k:
s += 1
print(s) | # -*- coding: utf-8 -*-
n, k = map(int, input().split())
cnt = 0
h = list(map(int, input().split()))
for high in h:
if high >= k:
cnt += 1
print(cnt)
| 1 | 178,918,330,156,512 | null | 298 | 298 |
n = int(input())
L = []
for _ in range(n):
x, l = map(int, input().split())
left = x - l
right = x + l
L.append((left, right))
L = sorted(L, key=lambda x: x[1])
ans = 0
prev = -float('inf')
for r in L:
if r[0] >= prev:
ans += 1
prev = r[1]
print(ans)
| n=int(input())
l=sorted([list(map(int,input().split())) for i in range(n)],key=lambda x:x[0]-x[1],reverse=1)
now=float("INF")
ans=0
for i in l:
if sum(i)<=now:
now=i[0]-i[1]
ans+=1
print(ans) | 1 | 89,636,643,195,100 | null | 237 | 237 |
n = input()
s = input().split()
l = [int(i) for i in s]
print(min(l),max(l),sum(l)) | n = input()
a = map(int,raw_input().split())
sum = a[0]
max = a[0]
min = a[0]
for i in range(1,n):
sum += a[i]
if min > a[i]:
tmp = min
min = a[i]
a[i] = tmp
if a[i] > max:
tmp = max
max = a[i]
a[i] = tmp
print str(min),str(max),str(sum) | 1 | 712,662,459,212 | null | 48 | 48 |
class Combination:
"""階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
def __init__(self, n, mod):
self.fact = [1]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * i % mod)
self.inv_fact = [0] * (n + 1)
self.inv_fact[n] = pow(self.fact[n], mod - 2, mod)
for i in reversed(range(n)):
self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
self.mod = mod
def factorial(self, k):
"""k!を求める O(1)"""
return self.fact[k]
def inverse_factorial(self, k):
"""k!の逆元を求める O(1)"""
return self.inv_fact[k]
def permutation(self, k, r):
"""kPrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r]) % self.mod
def combination(self, k, r):
"""kCrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.mod
def combination_large(self, k, r):
"""kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
if k < r:
return 0
res = 1
for l in range(r):
res *= (k - l)
res %= self.mod
return (res * self.inv_fact[r]) % self.mod
x, y = map(int, input().split())
mod = 10**9 + 7
comb = Combination(10**6,mod)
if (x+y)%3 != 0:
print(0)
exit(0)
i = (2*x-y)//3
j = (2*y-x)//3
n = i+j
r = i
if not 0 <= r <= n:
print(0)
exit(0)
print(comb.combination(n, r))
| # -*- coding: utf-8 -*-
"""
D - Knight
https://atcoder.jp/contests/abc145/tasks/abc145_d
"""
import sys
def modinv(a, m):
b, u, v = m, 1, 0
while b:
t = a // b
a -= t * b
a, b = b, a
u -= t * v
u, v = v, u
u %= m
return u if u >= 0 else u + m
def solve(X, Y):
MOD = 10**9 + 7
if (X + Y) % 3:
return 0
n = (X - 2 * Y) / -3.0
m = (Y - 2 * X) / -3.0
if not n.is_integer() or not m.is_integer() or n < 0 or m < 0:
return 0
n, m = int(n), int(m)
x1 = 1
for i in range(2, n + m + 1):
x1 = (x1 * i) % MOD
x2 = 1
for i in range(2, n+1):
x2 = (x2 * i) % MOD
for i in range(2, m+1):
x2 = (x2 * i) % MOD
ans = (x1 * modinv(x2, MOD)) % MOD
return ans
def main(args):
X, Y = map(int, input().split())
ans = solve(X, Y)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| 1 | 149,913,232,451,790 | null | 281 | 281 |
n=int(input())
s = input()
Ra = s.count('R')
t = s[:Ra]
Rb = t.count('R')
print(Ra-Rb) | n = int(input())
s = input().rstrip()
i=0
j=n-1
c= 0
while i!=j:
while s[j]!='R' and j>i:
j-=1
while s[i]=='R' and j>i:
i+=1
if i!=j:
c+= 1
i+= 1
j-=1
if i>=j:
break
print(c) | 1 | 6,351,138,480,108 | null | 98 | 98 |
def gcd(u, v):
if (v == 0): return u
return gcd(v, u % v)
def lcm(u, v):
return (u * v) // gcd(u, v)
while 1:
try:
inp = input()
except EOFError:
break
else:
u, v = inp.split(' ')
u = int(u)
v = int(v)
print(gcd(u, v), lcm(u, v)) | # coding=utf-8
def solve_gcd(number1: int, number2: int) -> int:
two_list = [number1, number2]
two_list.sort()
if two_list[1] % two_list[0] == 0:
return two_list[0]
r = two_list[1] % two_list[0]
return solve_gcd(two_list[0], r)
def solve_lcm(number1: int, number2: int, number3: int) -> int:
return number1*number2//number3
if __name__ == '__main__':
while True:
try:
a, b = map(int, input().split())
except EOFError:
break
gcd = solve_gcd(a, b)
lcm = solve_lcm(a, b, gcd)
print(gcd, lcm) | 1 | 600,608,130 | null | 5 | 5 |
#!/usr/bin/python3
# -*- coding:utf-8 -*-
from functools import reduce
def main():
n = int(input())
la = list(map(int, input().strip().split()))
x = reduce(lambda x, y: x ^ y, la)
print(' '.join([str(x ^ a) for a in la]))
if __name__=='__main__':
main()
| n = raw_input()
m =n.split(" ")
a = int(m[0])
b = int(m[1])
c = int(m[2])
if a < b < c :print "Yes"
else :print "No" | 0 | null | 6,429,705,649,250 | 123 | 39 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
T1, T2 = MAP()
A1, A2 = MAP()
B1, B2 = MAP()
if T1*A1+T2*A2 == T1*B1+T2*B2:
print("infinity")
exit()
if (A1 < B1 and A2 < B2) or (B1 < A1 and B2 < A2):
print(0)
exit()
if A1 > B1:
A1, B1 = B1, A1
A2, B2 = B2, A2
if A1*T1+A2*T2 < B1*T1+B2*T2:
print(0)
exit()
F = A1*T1-B1*T1
L = A2*T2-B2*T2
S, T = divmod(-F, F+L)
if T == 0:
print(2*S)
else:
print(2*S+1)
| t1,t2 = map(int,input().split())
a1,a2 = map(int,input().split())
b1,b2 = map(int,input().split())
import math
f = (a1-b1)*t1
s = (a2-b2)*t2
if f == -s:
print("infinity")
elif (f>0 and f+s>0) or (f<0 and f+s<0):
print(0)
elif f//(-(f+s)) == math.ceil(f/(-(f+s))):
print(f//(-(f+s))*2)
else:
print(f//(-(f+s))*2+1) | 1 | 131,780,624,899,840 | null | 269 | 269 |
s = input()
t = input()
ls = len(s)
lt = len(t)
ret = lt
for i in range(ls+1 - lt):
diff = 0
for j in range(lt):
diff += (t[j] != s[i+j])
if diff == 0:
ret = diff
break
if diff < ret:
ret = diff
print(ret) | list_data = [input() for _ in range(2)]
s = list_data[0]
t = list_data[1]
len_t = len(t)
max_correct = 0
for i in range(len(s)-len(t)+1):
correct = 0
for j in range(len(t)):
if s[i+j] == t[j]:
correct += 1
if max_correct < correct:
max_correct = correct
print(len_t - max_correct) | 1 | 3,680,310,481,760 | null | 82 | 82 |
import math
import decimal
A, B = map(str, input().split())
A = int(A)
B = decimal.Decimal(B)
print(math.floor(A*B)) | #!/usr/bin/env python3
N, K = [int(s) for s in input().split()]
h = [int(s) for s in input().split()]
print(len(list(filter(lambda x: x >= K, h)))) | 0 | null | 97,626,239,694,730 | 135 | 298 |
N, K = map(int, input().split())
H = list(map(int, input().split()))
if K >= N:
print(0)
else:
H = sorted(H)
count = 0
for i in range(N-K):
count += H[i]
print(count) | import math
H, W = map(int, input().split(' '))
if H == 1 or W == 1:
print(1)
exit()
res = math.ceil((H*W)/2)
print(res)
| 0 | null | 64,858,602,711,760 | 227 | 196 |
N, K = map(int, input().split())
H = tuple(map(int, input().split()))
assert len(H) == N
print(len([h for h in H if h >= K])) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
????????????
???????????????????¨???????????????????????????????????????????????¨???°????????°??????????????°??????????¨???°???????¨??????§??????
????????°????????¬?????????????¨??????§?¨???°???????????°??? (1+2)*(5+4) ??????
???????????????????¨??????§??? 1 2 + 5 4 + * ??¨?¨???°???????????????
???????????????????¨??????§?????????????¨??????§????????¨????????¬??§???????????§???????????¨????????????????????????????????????
???????????????????¨??????§?????????????????°???????¨????????????????????????????????????????
"""
# ?????????
INP = list(input().strip().split())
TMP = []
res = 0
for i in INP:
if i == "+":
b = TMP.pop()
a = TMP.pop()
TMP.append(a + b)
# print("{} - {} = {}".format(a,b,a+b))
elif i == "-":
b = TMP.pop()
a = TMP.pop()
TMP.append(a - b)
# print("{} - {} = {}".format(a,b,a-b))
elif i == "*":
b = TMP.pop()
a = TMP.pop()
TMP.append(a * b)
# print("{} * {} = {}".format(a,b,a*b))
else:
TMP.append(int(i))
print(TMP.pop()) | 0 | null | 89,717,478,762,238 | 298 | 18 |
N=int(input())
A=list(map(int,input().split()))
mod = 10**9+7
x,y,z=0,0,0
ans=1
for a in A:
ans*=[x,y,z].count(a)
ans%=mod
if x==a:
x+=1
elif y==a:
y+=1
else:
z+=1
print(ans) | n = int(input())
a = list(map(int, input().split()))
mod = 10**9+7
c = [0 for i in range(n+1)]
c[0] = 3
ans = 1
for i in range(n):
ans *= c[a[i]]
ans %= mod
c[a[i]] -= 1
c[a[i]+1] += 1
print (ans)
| 1 | 130,046,034,890,592 | null | 268 | 268 |
N, K = map(int, input().split())
ans = 0
mod = 10 ** 9 + 7
count = [0] * (K+10)
for i in range(K,0,-1):
t = pow(K//i, N, mod)
j = 2
while j * i <= K:
t -= count[j*i]
j += 1
count[i] = t
# tがiの倍数からなる数列の個数であることが確定しているはず
ans += t * i
ans %= mod
print(ans)
| N = int(input())
d = {}
for i in range(N):
s = input()
if s in d.keys():
d[s] += 1
else:
d[s] = 1
mx = 0
for i in d.values():
mx = max(mx, i)
for i in sorted(d.items()):
if i[1] == mx:
print(i[0]) | 0 | null | 53,496,475,094,080 | 176 | 218 |
s = str(input())
sm = 0
for c in s:
sm += int(c)
if sm % 9 == 0:
print('Yes')
else:
print('No') | 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)) | 0 | null | 90,202,738,287,860 | 87 | 296 |
a, b = list(map(int, input().split()))
d = a // b
r = a % b
f = float(a) / float(b)
print("{0} {1} {2:.5f}".format(d, r, f))
| import math
n = int(input())
dept=100
for i in range(n):
dept=dept*1.05
#print dept
dept=math.ceil(dept)
#print dept
print "%i"%(dept*1000) | 0 | null | 302,351,736,818 | 45 | 6 |
def main():
from bisect import bisect_left as bl
from itertools import accumulate as ac
n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
aa = [0]+list(ac(a))
an = aa[n]
ok = 0
ng = 10**10
while abs(ok-ng) > 1:
mid = (ok+ng)//2
if sum([n-bl(a, mid-a[i]) for i in range(n)]) >= m:
ok = mid
else:
ng = mid
c = -m+sum([n-bl(a, ok-a[i]) for i in range(n)])
ans = -c*ok
for i in range(n):
d = bl(a, ok-a[i])
ans += an-aa[d]+(n-d)*a[i]
print(ans)
main() | def resolve():
N, K = map(int, input().split())
D = []
A = []
for _ in range(K):
d = int(input())
a = list(map(int, input().split()))
D.append(d)
A.append(a)
ans = 0
for i in range(N):
flag = 0
for j in range(K):
if i+1 in A[j]:
flag = 1
if flag == 0:
ans += 1
print(ans)
resolve() | 0 | null | 66,089,367,359,862 | 252 | 154 |
#ABC167
A,B,C,K=map(int,input().split())
#----------以上入力----------
if A > K:
print(K)
elif A+B >= K:
print(A)
else:
print(A-(K-A-B)) | for i in range(int(input())):
a,b,c=map(lambda x:int(x)**2,input().split())
if a+b==c or b+c==a or c+a==b:
print("YES")
else:
print("NO")
| 0 | null | 10,854,257,616,832 | 148 | 4 |
N = int(input())
S = input()
n = N/2
if S == S[int(n):] * 2:
print("Yes")
else:
print("No") | lst = [input() for i in range(2)]
n = int(lst[0])
s = lst[1]
t = ''
for i in range(n//2):
t += s[i]
if n % 2 == 1:
print('No')
elif t + t == s:
print('Yes')
else:
print('No')
| 1 | 146,252,896,508,480 | null | 279 | 279 |
N = int(input())
C1 = list(input().split())
C2 = C1[:]
def get_card_suit(card):
return card[:1]
def get_card_value(card):
return card[1:]
def bubble_sort(card):
r_exists = True
while r_exists == True:
r_exists = False
i = N - 1
while i >= 1:
if get_card_value(card[i]) < get_card_value(card[i - 1]):
card[i], card[i - 1] = card[i - 1], card[i]
r_exists = True
i -= 1
def select_sort(card):
i = 0
while i < N:
min_j = i
j = i
while j < N:
if get_card_value(card[j]) < get_card_value(card[min_j]):
min_j = j
j += 1
card[i], card[min_j] = card[min_j], card[i]
i += 1
def output(card):
s = ''
for x in card:
s = s + str(x) + ' '
print(s.rstrip())
def is_stable():
i = 0
while i < N:
if get_card_suit(C1[i]) != get_card_suit(C2[i]):
return False
i += 1
return True
bubble_sort(C1)
select_sort(C2)
output(C1)
print('Stable')
output(C2)
if is_stable() == True:
print('Stable')
else:
print('Not stable')
| n = int(input())
s = input()
a = s.split()
def value(a, i):
return int(a[i][-1])
def isstable(s, a, n):
for i in range(n - 1):
if value(a, i) == value(a, i + 1):
v1 = s.index(a[i])
v2 = s.index(a[i + 1])
if v1 > v2:
return "Not stable"
return "Stable"
for i in range(n - 1):
for j in range(i + 1, n)[::-1]:
if value(a, j) < value(a, j - 1):
a[j], a[j - 1] = a[j - 1], a[j]
print(" ".join(a))
print(isstable(s.split(), a, n))
a = s.split()
for i in range(n - 1):
minj = i
for j in range(i + 1, n):
if value(a, j) < value(a, minj):
minj = j
a[i], a[minj] = a[minj], a[i]
print(" ".join(a))
print(isstable(s.split(), a, n))
| 1 | 27,665,320,808 | null | 16 | 16 |
X=int(input())
ans=(X//500)*1000
X%=500
ans+=(X//5)*5
print(ans)
| from collections import Counter
N = int(input())
A = list(map(int, input().split()))
max_a = max(A)
A.sort()
count = Counter(A)
divisible = [False] * (max_a + 1)
ans = 0
for a in A:
if divisible[a]:
continue
for i in range(1, max_a // a + 1):
divisible[i * a] = True
if count[a] == 1:
ans += 1
print(ans)
| 0 | null | 28,596,352,373,788 | 185 | 129 |
n = int(input()[-1])
if n == 3:
print("bon")
elif n in [0, 1, 6, 8]:
print("pon")
else:
print("hon") | from bisect import bisect_right
import string
N=int(input())
L=[0]*13
for i in range(1,13):
L[i]=(L[i-1]+1)*26
# print(L)
# やるべきことは26進数
def bisectsearch_right(L,a):
i=bisect_right(L,a)
return(i)
S=string.ascii_lowercase
l=bisectsearch_right(L,N-1)
s=['']*l
tmp=N-1-L[l-1]
# print(l,tmp)
j=l-1
while j>=0:
s[j]=S[tmp%26]
tmp//=26
j-=1
print(''.join(s)) | 0 | null | 15,497,970,499,228 | 142 | 121 |
def resolve():
N, D = map(int, input().split())
cnt = 0
for n in range(N):
x, y = map(int, input().split())
d = (x ** 2 + y ** 2) ** 0.5
if d <= D:
cnt += 1
print(cnt)
resolve() | class ReversingNumbers:
def output(self, a):
s = ""
a.reverse()
for i in range(len(a)-1):
s += "%d " % (a[i])
s += "%d" % (a[len(a)-1])
print s
if __name__ == "__main__":
rn = ReversingNumbers()
raw_input()
a = map(int, raw_input().split())
rn.output(a) | 0 | null | 3,426,323,987,844 | 96 | 53 |
n=int(input())
R=[]
for _ in range(n):
x,l=map(int,input().split())
R.append([x-l,x+l])
R=sorted(R,key=lambda x:x[1])
ans=n
for i in range(1,n):
if R[i][0]<R[i-1][1]:
ans-=1
R[i][1]=R[i-1][1]
print(ans) | n = int(input())
ranges = []
for i in range(n):
x, l = map(int, input().split())
ranges.append([max(x-l, 0), x+l])
ranges.sort(key=lambda x: x[1])
start = 0
ans = 0
for range in ranges:
if range[0] >= start:
start = range[1]
ans += 1
print(ans) | 1 | 89,887,678,904,212 | null | 237 | 237 |
input()
s = input()
print(s.count("ABC")) | X=int(input())
n = 0
big = 0
small=0
#print(10**9)
while True:
if (n**5 - (n-1)**5) > 10**9 :
break
big=n
n += 1
n=0
while True:
if (n**5 - (n-1)**5) > 10**9 :
break
small=n
n -= 1
a = list(range(0, big, 1))+list(range(-1, small-1, -1))
b = list(range(0, big-1, 1))+list(range(-1, small-2, -1))
stopFlag = False
for ia in a:
if stopFlag :
break
for ib in b:
if (ia**5) - (ib**5) == X:
print(ia, ib)
stopFlag = True
break
| 0 | null | 62,279,894,598,200 | 245 | 156 |
def main():
for i in range(1, 10):
for j in range(1, 10):
ans = i * j
s = str(i) + 'x' + str(j) + '=' + str(ans)
print(s)
main() | a = range(1, 10)
[print('{}x{}={}'.format(i, j, i * j)) for i in a for j in a] | 1 | 94,560 | null | 1 | 1 |
H,W=map(int,input().split())
if (H==1)|(W==1):
print(1)
elif (H%2==1)&(W%2==1):
print(int((H*W+1)/2))
else:
print(int(H*W/2)) | [H,W] = list(map(int,input().split(' ')))
K = int((H*W+1)*0.5)
if H==1 or W==1:print(1)
else:print(K) | 1 | 50,586,207,531,392 | null | 196 | 196 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
def main():
mod = 10**9+7
N = int(input())
A = list(map(int, input().split()))
C = [0] * 3
ret = 1
for i in range(N):
ret *= C.count(A[i])
ret %= mod
for j in range(3):
if C[j]==A[i]:
C[j]+=1
break
print(ret)
if __name__ == '__main__':
main() | a, b = map(float, input().split())
print(int(a)*int(b*100+0.5)//100) | 0 | null | 73,194,648,890,308 | 268 | 135 |
# -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
X = int(input())
return X
def main(X: int) -> None:
"""
メイン処理.
Args:\n
X (int): 最高レーティング（400 <= X <= 1999）
"""
# 求解処理
ans = 10 - (X // 200)
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
X = get_input()
# メイン処理
main(X)
| import sys
readline = sys.stdin.readline
X = int(readline())
limit = 600
rank = 8
for i in range(8):
if X < limit:
print(rank)
break
limit += 200
rank -= 1 | 1 | 6,777,041,813,720 | null | 100 | 100 |
import sys
sys.setrecursionlimit(10**9)
def main():
n, x, t = map(int, input().split())
if n % x == 0:
print((n//x)*t)
else:
print((n//x+1)*t)
return
if __name__ == "__main__":
main() | n, x, t = [int(n) for n in input().split(' ')]
a = n // x * t
if n % x != 0:
a += t
print(a)
| 1 | 4,260,772,769,988 | null | 86 | 86 |
n,k = map(int,input().split())
h = list(map(int, input().split()))
if n <= k:
print(0)
exit()
h.sort()
print(sum(h[:n-k])) | N,K = map(int,input().split())
A = sorted(list(map(int,input().split())))
F = sorted(list(map(int,input().split())),reverse=True)
if K>=sum(A):
ans = 0
else:
low = 0
high = 10**12
while high-low>1:
mid = (high+low)//2
B = A[:]
cnt = 0
for i in range(N):
if B[i]*F[i]>mid:
cnt += (B[i]-mid//F[i])
if cnt<=K:
high = mid
else:
low = mid
ans = high
print(ans) | 0 | null | 122,271,484,669,972 | 227 | 290 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K = map(int, readline().split())
point = list(map(int, readline().split()))
T = readline().strip()
T = list(map(int, T.translate(str.maketrans('rsp', '012'))))
hand = [0] * N
ans = 0
for i, h in enumerate(T):
win = (h - 1) % 3
if i >= K and win == hand[i - K]:
hand[i] = -1
else:
hand[i] = win
ans += point[win]
print(ans)
return
if __name__ == '__main__':
main()
| l=map(str,raw_input().split())
chk=[]
op='-+*'
while len(l):
k=l.pop(0)
if k in op:
b=chk.pop()
a=chk.pop()
chk.append(str(eval(a+k+b)))
else:
chk.append(k)
print chk[0] | 0 | null | 53,217,723,140,340 | 251 | 18 |
print(list(map(int,input().split())).index(0) + 1) | n = map(int, input().split(" "))
for index, i in enumerate(n, 1):
if i == 0:
print(index) | 1 | 13,471,532,223,812 | null | 126 | 126 |
# coding: utf-8
N = list(map(int,list(input())))
sN = sum(N)
if sN%9 ==0:
print("Yes")
else:
print("No")
| def main():
import sys
input = sys.stdin.readline
n,p = [int(i) for i in input().split()]
s = input()
ans = 0
import collections
if p == 2 or p == 5:
for i in range(n):
if int(s[i]) % p == 0:
ans += i + 1
print(ans)
exit()
else:
chk = []
m = 0
chk = collections.deque(chk)
for i in range(n)[::-1]:
m = (int(s[i])*pow(10,n-1-i,p)+m)%p
chk.append(m)
chk.append(0)
chk = list(chk)
c = collections.Counter(chk)
for i in range(p):
ans += c[i]*(c[i]-1)/2
print(int(ans))
if __name__ == '__main__':
main() | 0 | null | 31,140,360,223,542 | 87 | 205 |
N=int(input())
check=1
while check**2<=N:
if N%check==0:
keep=N//check
check+=1
print(keep+N//keep-2)
| N=int(input())
l=[]
for i in range(1,int(N**0.5)+1):
if N%i==0:
l.append([i,N/i])
L=len(l)
s=[0]*L
for j in range(L):
s[j]=l[j][0]+l[j][1]
print(int(min(s))-2) | 1 | 161,759,141,671,708 | null | 288 | 288 |
N, X, T = map(int, input().split())
res = 0
while N > 0:
N -= X
res += T
print(res) | n,x,t=map(int,input().split())
if n%x==0:print(n//x*t)
else:print((n//x+1)*t) | 1 | 4,257,607,856,640 | null | 86 | 86 |
import fractions
while True:
try:
(a, b) = map(int, raw_input().split())
c = fractions.gcd(a, b)
print c, ((a*b)/c)
except EOFError:
break | def GCD(a, b):
if b > a:
return GCD(b, a)
elif a % b == 0:
return b
return GCD(b, a % b)
def LCM(a, b):
return a * b // GCD(a, b)
import sys
L = sys.stdin.readlines()
for line in L:
x, y = list(map(int, line.split()))
print(GCD(x, y), LCM(x, y)) | 1 | 551,766,820 | null | 5 | 5 |
class UnionFind:
def __init__(self, num):
self.parent = [-1] * num
def find(self, node):
if self.parent[node] < 0:
return node
self.parent[node] = self.find(self.parent[node])
return self.parent[node]
def union(self, node1, node2):
node1 = self.find(node1)
node2 = self.find(node2)
if node1 == node2:
return
if self.parent[node1] > self.parent[node2]:
node1, node2 = node2, node1
self.parent[node1] += self.parent[node2]
self.parent[node2] = node1
return
def same(self, node1, node2):
return self.find(node1) == self.find(node2)
def size(self, x):
return -self.parent[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.parent) if x < 0]
def group_count(self):
return len(self.roots())
n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
uf.union(a, b)
print(uf.group_count() - 1)
| import sys
if __name__ == "__main__":
a,b = map(int, raw_input().split())
print "%d %d %f" %(a/b, a%b, a*1.0/b) | 0 | null | 1,439,753,781,888 | 70 | 45 |
def resolve():
X = list(map(int, input().split()))
print(X.index(0)+1)
if '__main__' == __name__:
resolve() | n = int(input())
A = list(map(int, input().split()))
cumsum = [[0 for j in range(2)] for i in range(60)]
ans = [0] * 60
#print(cumsum)
for i in range(len(A) - 1, -1, -1):
plus_num = A[i]
bit_num = format(plus_num, "060b")
#print(bit_num)
for i, bit in enumerate(bit_num):
bit = int(bit)
if bit == 0:
ans[i] += cumsum[i][1]
else:
ans[i] += cumsum[i][0]
cumsum[i][bit] += 1
#print(ans)
#print(cumsum)
ans_num = 0
mod = 10**9 + 7
for i, cnt in enumerate(ans):
ans_num += 2**(59-i) * cnt
ans_num %= mod
print(ans_num)
| 0 | null | 68,407,766,171,360 | 126 | 263 |
r = input ().split ()
print ("Yes" if r[0] == r[1] else "No") | # -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import itertools
import random
from decimal import *
input = sys.stdin.readline
def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
D = inputInt()
C = inputList()
S = []
for i in range(D):
s = inputList()
S.append(s)
ans = []
for i in range(D):
bestSco = 0
bestI = 1
for j,val in enumerate(S[i]):
tmpAns = ans + [j+1]
tmpSco = findScore(tmpAns, S, C)
if bestSco < tmpSco:
bestSco = tmpSco
bestI = j+1
ans.append(bestI)
for i in ans:
print(i)
def findScore(ans, S, C):
scezhu = [inf for i in range(26)]
sco = 0
for i,val in enumerate(ans):
tmp = S[i][val-1]
scezhu[val-1] = i
mins = 0
for j,vol in enumerate(C):
if scezhu[j] == inf:
mins = mins + (vol * (i+1))
else:
mins = mins + (vol * ((i+1)-(scezhu[j]+1)))
tmp -= mins
sco += tmp
return sco
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
| 0 | null | 46,713,321,795,840 | 231 | 113 |
x, y = map(int, input().split())
if y % 2 == 0 and x*2 <= y <= x*4:
print('Yes')
else:
print('No') | xy = [int(s) for s in input().split()]
x = xy[0]
y = xy[1]
if y % 2 == 0 and y<=4*x and y>=2*x:
print('Yes')
else:
print('No') | 1 | 13,774,482,635,508 | null | 127 | 127 |
n = int(input())
x = input()
popcount = x.count('1')
p = int(x, 2) % (popcount + 1)
q = int(x, 2) % (popcount - 1) if popcount != 1 else 0
for i in range(n):
if x[i] == '0':
y = (p + pow(2, n-i-1, popcount+1)) % (popcount + 1)
else:
if popcount != 1:
y = (q - pow(2, n-i-1, popcount-1)) % (popcount - 1)
else:
print(0)
continue
cnt = 1
while y != 0:
y %= bin(y).count('1')
cnt += 1
print(cnt)
| T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
# 必ずB1の方を大きくする必要がある
if A1 > B1:
B1, A1 = A1, B1
B2, A2 = A2, B2
P = T1*(A1-B1) # Pは負の値
Q = T2*(A2-B2)
if P + Q == 0:
print("infinity")
exit()
elif P + Q < 0: # 出会う位置まで戻ってこれなかった
print(0)
exit()
elif P + Q > 0: # 限られた数だけあえる
if (-P % (P + Q)) == 0:
print(2*(-P // (P+Q)))
else:
print(2*(-P // (P+Q))+1)
| 0 | null | 69,633,578,229,562 | 107 | 269 |
n, k = map(int, input().split())
a = [int(x) for x in input().split()]
for i in range(n-k):
if a[i+k] > a[i]:
print("Yes")
else:
print("No") | n, k = map(int, input().split())
l = list(map(int, input().split()))
start = k
c = 0
for i in range(n-k):
if l[start]>l[c]:
print("Yes")
else:
print("No")
start+=1
c+=1 | 1 | 7,073,107,689,480 | null | 102 | 102 |
n, q = map(int, input().split())
p = [input().split() for _ in range(n)]
t = i = 0
while n:
i = i % n
if int(p[i][1]) <= q:
t += int(p[i][1])
print(p[i][0], t)
del p[i]
n -= 1
else:
p[i][1] = int(p[i][1]) - q
t += q
i += 1 | n = int(input())
s = 0
b = False
for _ in range(n):
w = input().split()
if w[0] == w[1]:
s += 1
if s == 3:
b = True
break
else:
s = 0
print('Yes' if b else 'No')
| 0 | null | 1,285,710,199,212 | 19 | 72 |
import sys
input = sys.stdin.buffer.readline
n = int(input())
A = list(map(int, input().split()))
L = [(a, i+1) for i, a in enumerate(A)]
L.sort(reverse=True)
dp = [[-1]*(n+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n+1):
for j in range(n+1-i):
a, idx = L[i+j-1]
if i:
dp[i][j] = max(dp[i][j], dp[i-1][j]+a*(idx-i))
if j:
dp[i][j] = max(dp[i][j], dp[i][j-1]+a*(n+1-j-idx))
ans = 0
for i in range(n+1):
ans = max(ans, dp[i][n-i])
print(ans) | s = input()
if s[0] == "R":
if s[1] == "R":
if s[2] == "R":
ans = 3
else:
ans = 2
else:
ans = 1
else:
if s[1] == "R":
if s[2] == "R":
ans = 2
else:
ans = 1
elif s[2] == "R":
ans = 1
else:
ans = 0
print(ans) | 0 | null | 19,252,244,252,490 | 171 | 90 |
X=int(input())
x=X//200
print(10-x) | n=int(input())
a=[0]+list(map(int,input().split()))
b=[0 for i in range(n+1)]
for i in range(n):
b[a[i]]+=1
[print(i) for i in b[1:]]
| 0 | null | 19,651,093,961,730 | 100 | 169 |
n = int(input())
*A, = map(int, input().split())
inf = 10**18
# DP[i][0]=i番目まででi//2個選んだ最大値
# DP[i][1]=i番目まででi//2+1個選んだ最大値
DP = [[-inf]*2 for i in range(n)]
DP[0][0] = 0
DP[0][1] = A[0]
DP[1][0] = 0
DP[1][1] = max(A[0], A[1])
for i in range(2, n):
if i % 2 == 0:
DP[i][0] = max(DP[i-2][0]+A[i], DP[i-1][1])
DP[i][1] = DP[i-2][1]+A[i]
else:
DP[i][0] = max(DP[i-2][0]+A[i], DP[i-1][0])
DP[i][1] = max(DP[i-2][1]+A[i], DP[i-1][1])
if n % 2 == 0:
print(DP[n-1][1])
else:
print(DP[n-1][0])
| # 写経AC
from collections import defaultdict
N = int(input())
A = [int(i) for i in input().split()]
# dp[(i, x, flag)]:= i番目まででx個選んでいる時の最大値
# flag: i番目をとるフラグ
dp = defaultdict(lambda: -float("inf"))
# 初期条件
dp[(0, 0, 0)] = 0
# 貰うDP
for i, a in enumerate(A, 1):
# i番目までで選ぶ個数
for x in range((i // 2) - 1, (i + 1) // 2 + 1):
dp[(i, x, 0)] = max(dp[(i - 1, x, 0)], dp[(i - 1, x, 1)])
dp[(i, x, 1)] = dp[(i - 1, x - 1, 0)] + a
print(max(dp[(N, N // 2, 0)], dp[(N, N // 2, 1)])) | 1 | 37,371,450,452,560 | null | 177 | 177 |
moutain = [0 for i in range(10)]
for i in range(10):
moutain[i] = int(raw_input())
moutain.sort(reverse=True)
for i in range(3):
print moutain[i]
| N = int(input())
a = 0
for i in range(1,int(N**0.5)+1):
if N%i == 0:
a = max(a,i)
b = N//a
print((a-1)+(b-1)) | 0 | null | 80,532,041,820,608 | 2 | 288 |
import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
import bisect
MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 8)
n, m = map(int, input().split())
c = list(map(int, input().split()))
dp = [[INF] * (n + 10) for _ in range(m + 10)]
for i in range(m+10):
dp[i][0] = 0
for i in range(1, n + 1):
if i % c[0] == 0:
dp[1][i] = i // c[0]
for i in range(2, m + 1):
for j in range(1, n + 1):
if j - c[i - 1] >= 0:
dp[i][j] = min(dp[i-1][j], dp[i][j - c[i - 1]] + 1)
else:
dp[i][j] = dp[i-1][j]
print(dp[m][n])
| N,K=map(int,input().split())
s = set(range(1, N+1))
for i in range(K):
d = int(input())
A = list(map(int,input().split()))
for x in A:
try:
s.remove(x)
except:
pass
print(len(s)) | 0 | null | 12,355,334,574,050 | 28 | 154 |
import math
N = int(input())
min = math.floor(N / 1.08)
max = math.ceil(N/ 1.08)
flag = False
for i in range(min,max+1):
ans = math.floor(i*1.08)
if N == ans:
X = i
flag = True
break
if(flag):
print(X)
else:
print(':(') | import math
N=int(input())
a=math.ceil(N/(1.08))
if math.floor(a*1.08)==N:
print(a)
else:
print(':(') | 1 | 125,853,230,815,900 | null | 265 | 265 |
N,M=map(int,input().split())
sets=[]
if N%2==1:
for i in range(M):
sets.append((i+1,i+1+(N-3-2*i)+1))
elif N%2==0:
count=0
kukan=[]
for i in range(N//2-1):
kukan.append(count)
count+=2
if count==N//2 or count==N//2-1:
count+=1
kukan.reverse()
for i in range(M):
sets.append((i+1,i+1+kukan[i]+1))
for set1 in sets:
print(set1[0],set1[1]) | from collections import deque
import sys
sys.setrecursionlimit(20000000)
N = int(input())
ab = [list(map(int, input().split())) for _ in range(N-1)]
routes = [[] for _ in range(N)]
for i in range(len(ab)):
routes[ab[i][0]-1].append([ab[i][1]-1, i])
routes[ab[i][1]-1].append([ab[i][0]-1, i])
route_color = [-10e+10 for _ in range(len(ab))]
route_num = [0]*N
max_route = 0
for i in range(N):
num = len(routes[i])
route_num[i] = num
if max_route < num:
max_route = num
seen = [False for _ in range(N)]
def function(num,pre_color):
color_num = -1
for route in routes[num]:
color_num += 1
if color_num == pre_color:
color_num+=1
if route_color[route[1]] != -10e+10:
color_num-=1
pass
else:
route_color[route[1]] = color_num
if seen[route[0]] == False:
seen[route[0]] = True
function(route[0],route_color[route[1]])
return
function(0,-1)
print(max_route)
for color in route_color:
print(color+1) | 0 | null | 82,542,809,646,040 | 162 | 272 |
n, k = map(int, input().split())
s = [0]
for i in range(1,n+1):
s.append(s[i-1] + i)
ans = 0
for i in range(k,n+1):
ans += ((s[n]-s[n-i]) - s[i-1])+ 1
print((ans+1) % (10**9 + 7))
| N,K=map(int, input().split())
sum_ = 0
for k in range(K, N+2):
sum_ += k*(N-k+1)+1
sum_ = sum_ % (10**9+7)
print(sum_) | 1 | 32,975,831,716,128 | null | 170 | 170 |
A,B=map(int,input().split())
if A>9 or B>9:
print(-1)
else:
print(A*B) | a,b=map(int,input().split())
print("-1" if a>9 or b>9 else a*b) | 1 | 157,730,638,972,832 | null | 286 | 286 |
# -*- coding:utf-8 -*-
import sys
array = []
for i in sys.stdin:
array.append(i)
for i in range(len(array)):
data = array[i].split()
a = int(data[0])
op = str(data[1])
b = int(data[2])
if op == '?':
break
if op == '+':
print(a+b)
if op == '-':
print(a-b)
if op == '/':
print(int(a/b))
if op == '*':
print(a*b) | import sys
for e in sys.stdin.readlines():
print(len(str(eval('+'.join(e.split())))))
| 0 | null | 343,185,642,812 | 47 | 3 |
n = int(input())
a = int(n//1.08)
for x in range(a, a+2):
if x < (n + 1)/1.08 and x >= n/1.08:
print(x)
exit()
print(':(') | import math
def main():
n = int(input())
tax = 1.08
ans = math.ceil(n / tax)
ans_check = ans * tax
if math.floor(ans * tax) == n:
print(ans)
else:
print(":(")
if __name__ == "__main__":
main() | 1 | 125,785,819,088,832 | null | 265 | 265 |
N,M=list(map(int, input().split()))
P=[0]*M
S=[0]*M
for i in range(M):
P[i],S[i]=list(input().split())
P[i]=int(P[i])
flagac=[False]*N
pnlt=[0]*N
for i in range(M):
p=P[i]-1
s=S[i]
if s=='AC':
flagac[p]=True
else:
pnlt[p]+=(flagac[p]+1)%2
# print(flagac)
# print(pnlt)
ctac=0
ctwa=0
for i in range(N):
if flagac[i]:
ctac+=1
ctwa+=pnlt[i]
print(ctac, ctwa) | import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
# N =I()
N,M= LI()
if M==0:
print(0,0)
exit()
pS = [LS() for _ in range(M)]
# print(pS)
_p,S = zip(*pS)
p = list(map(int,_p))
WA = np.zeros(N+1)
AC = np.full(N+1,False, dtype=bool)
penalty = 0
for i in range(M):
if AC[p[i]]:
continue
if S[i]=='WA':
WA[p[i]] += + 1
else:
AC[p[i]]=True
penalty += WA[p[i]]
AC_count = np.count_nonzero(AC)
# space output
print(AC_count,int(penalty))
#Ap = np.array(A)
# if ans:
# print('Yes')
# else:
# print('No') | 1 | 93,502,817,320,862 | null | 240 | 240 |
a,k,d = map(int, input().split())
if a < 0:
x = -a
else:
x = a
y = x % d
l = x // d
m = k - l
if m < 0:
ans = x - (k * d)
elif m % 2 ==0:
ans = y
else :
ans = y - d
print(abs(ans)) |
startX, countK, distanceD = map(int, input().split())
n = int(abs(startX) / distanceD)
ans = abs(startX) % distanceD
if n > countK:
ans += distanceD * (n - countK)
else:
if (countK - n) % 2 == 1:
ans= abs(ans - distanceD)
print(ans)
| 1 | 5,233,928,764,962 | null | 92 | 92 |
five_numbers = list(map(int, input().split()))
for order, number in enumerate(five_numbers):
if number == 0:
if order == 0:
print(five_numbers[order+1]-1)
break
print(five_numbers[order-1]+1) | x=list(map(int,input().split()))
for k in range(5):
if x[k]==0:
print(k+1)
else:
continue | 1 | 13,591,681,075,372 | null | 126 | 126 |
N = int(input())
if N == 1:
print(0)
exit()
if N == 2:
print(2)
exit()
# N >= 3
# 全事象
all_pattern = 10 ** N
# 0も9もない
pattern_a = 8 ** N
# 0あるが9ない
pattern_b = 9 ** N - 8 ** N
ans = all_pattern - pattern_a - pattern_b * 2
ans = ans % (10**9 + 7)
print(ans) | n=int(input())
mod=1000000007
print((pow(10,n,mod)-2*pow(9,n,mod)+pow(8,n,mod))%mod) | 1 | 3,177,854,570,492 | null | 78 | 78 |
n = int(input())
a = list(map(int, input().split()))
count = 0
flag = True
while flag:
flag = False
for j in range(n - 1, 0, -1):
if a[j] < a[j - 1]:
a[j], a[j - 1] = a[j - 1], a[j]
count += 1
flag = True
print(' '.join(list(map(str, a))))
print(count) | n = int(input())
a = [int(x) for x in input().split()]
c = 0
for i in range(n):
for j in range(1, n):
if a[j - 1] > a[j]:
tmp = a[j - 1]
a[j - 1] = a[j]
a[j] = tmp
c += 1
print(" ".join([str(x) for x in a]))
print(c) | 1 | 15,902,666,312 | null | 14 | 14 |
H,N = map(int,input().split())
AB = [list(map(int,input().split())) for _ in range(N)]
dp = [[10000000000000]*(H+1) for _ in range(N+1)]
for y in range(N):
a,b = AB[y]
for x in range(H+1):
if x <= a:
dp[y+1][x] = min(dp[y][x], b)
else:
dp[y+1][x] = min(dp[y][x], dp[y+1][x-a]+b)
print(dp[-1][-1]) | class Dice(object):
def __init__(self, line):
self.top = 1
self.bottom = 6
self.south = 2
self.east = 3
self.west = 4
self.north = 5
self.convert = [int(s) for s in line.split()]
def move(self, direction):
if 'N' == direction:
self.top, self.north, self.bottom, self.south = self.south, self.top, self.north, self.bottom
elif 'S' == direction:
self.top, self.north, self.bottom, self.south = self.north, self.bottom, self.south, self.top
elif 'W' == direction:
self.top, self.east, self.bottom, self.west = self.east, self.bottom, self.west, self.top
elif 'E' == direction:
self.top, self.east, self.bottom, self.west = self.west, self.top, self.east, self.bottom
def search(self, line):
top, south = [int(s) for s in line.split()]
for direction in 'NNNNWNNNN':
self.move(direction)
if self.convert[self.south - 1] == south:
break
for direction in 'WWWW':
self.move(direction)
if self.convert[self.top - 1] == top:
break
return self.result()
def result(self):
return self.convert[self.east - 1]
dice = Dice(input())
for i in range(int(input())):
print(dice.search(input())) | 0 | null | 40,613,880,240,220 | 229 | 34 |
n = int(input())
p = list(map(int, input().split()))
ans = 0
min_p = n
for i in p:
if i <= min_p:
min_p = i
ans += 1
print(ans)
| import math
a, b, c = list(map(int, input().split()))
sa, sb, sc = math.sqrt(a), math.sqrt(b), math.sqrt(c)
d = c-a-b
if (c-a-b > 0) and ((c-a-b)**2 > 4*a*b):
print("Yes")
else:
print("No")
| 0 | null | 68,245,314,065,798 | 233 | 197 |
N = int(input())
A = [int(x) for x in input().split()]
num_c = 0
for i in range(0, N):
minj = i
for j in range(i, N):
if A[j] < A[minj]:
minj = j
if(i != minj):
A[i], A[minj] = A[minj], A[i]
num_c += 1
print((" ").join(str(x) for x in A))
print(num_c) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
def print_array(a):
print(" ".join(map(str, a)))
def selectionsort(arr, n):
a = arr[:]
s = 0
for i in range(n):
minj = i
for j in range(i, n):
if a[j] < a[minj]:
minj = j
if i != minj:
(a[i], a[minj]) = (a[minj], a[i])
s += 1
return (a, s)
def main():
n = int(input())
arr = list(map(int, input().split()))
(a, s) = selectionsort(arr, n)
print_array(a)
print(s)
if __name__ == "__main__":
main() | 1 | 19,767,063,520 | null | 15 | 15 |
import sys
readline = sys.stdin.readline
N = int(readline())
S = [readline().rstrip() for _ in range(N)]
def count_cb_ob(s):
st = []
for i, si in enumerate(s):
if si == '(' or len(st) == 0 or st[-1] != '(':
st.append(si)
else:
st.pop()
return st.count(')'), st.count('(')
cb_obs = map(count_cb_ob, S)
f, b, s = [], [], []
for down, up in cb_obs:
(f if down < up else (s if down == up else b)).append((down, up))
f = sorted(f)
b = sorted(b, key=lambda x:x[1], reverse=True)
count = 0
ans = 'Yes'
for down, up in (*f, *s, *b):
count -= down
if count < 0:
ans = 'No'
count += up
if count != 0:
ans = 'No'
print(ans) |
N = int(input())
A = []
B = []
for _ in range(N):
a, b = map(int, input().split())
A.append(a)
B.append(b)
A.sort()
B.sort()
if N % 2 == 0:
l = A[N // 2 - 1] + A[N // 2]
u = B[N // 2 - 1] + B[N // 2]
print(u - l + 1)
else:
l = A[N // 2]
u = B[N // 2]
print(u - l + 1)
| 0 | null | 20,608,785,128,332 | 152 | 137 |
# ABC154A
def f(s, t, a, b, u):
if u == s:
print(a - 1, b)
else:
print(a, b - 1)
s, t = input().split()
a, b = map(int, input().split())
u = input()
f(s, t, a, b, u)
| x = int(input())
xSum = 0
cnt = 1
while True:
xSum += x
if xSum%360 == 0:
break
cnt += 1
print(cnt) | 0 | null | 42,746,995,356,098 | 220 | 125 |
n = int(input())
S, T = input().split()
ans = ""
for i in range(n):
ans += S[i]+T[i]
print(ans) |
s=[0,0]
for i in range(int(input())):
r=input().split()
if r[0]<r[1]:
s[1]+=3
elif r[1]<r[0]:
s[0]+=3
else:
s[0]+=1
s[1]+=1
print(str(s[0])+' '+str(s[1]))
| 0 | null | 56,962,258,353,888 | 255 | 67 |
n=int(input())
list={}
list1=[]
for i in range(n):
a,b=map(str,input().split())
if a=="insert":
list.setdefault(b,i)
if a=="find":
if b in list:
list1.append("yes")
else:
list1.append("no")
for i in list1:
print(i)
| a = sorted([int(input()) for i in range(10)])
a.reverse()
for i in range(3):
print(a[i]) | 0 | null | 36,274,494,868 | 23 | 2 |
N = int(input())
A = list(map(int, input().split()))
A = sorted(A, reverse = True)
L = len(A) // 2
if len(A) % 2 == 0:
#偶数の時
ans = sum(A[:L]) + sum(A[1:L])
else:
#奇数の時
ans = sum(A[:L]) + sum(A[1:L+1])
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")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
N = int(input())
A = list(map(int, input().split()))
A = sorted(A, reverse=True)
ans = A[0]
for i in range(N-2):
ans += A[i//2+1]
print(ans)
| 1 | 9,209,917,181,348 | null | 111 | 111 |
n=input()
fn_first=1
fn_second=1
if n >= 2:
for x in xrange(n-1):
tmp = fn_first
fn_first = fn_first + fn_second
fn_second = tmp
print fn_first | n = int(input())
dp = [1] * (n+1)
for j in range(n-1):
dp[j+2] = dp[j+1] + dp[j]
print(dp[n])
| 1 | 1,870,727,770 | null | 7 | 7 |
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 same(self, x, y):
return self.find(x) == self.find(y)
N, M = map(int, input().split())
u = UnionFind(N)
for i in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
u.union(a, b)
h = {}
for i in range(N):
h[u.find(i)] = True
print(len(h)-1)
| import sys
input = sys.stdin.readline
N, M, L = (int(i) for i in input().split())
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
from scipy.sparse import csr_matrix
graph = [[0]*N for i in range(N)]
for i in range(M):
a, b, c = (int(i) for i in input().split())
graph[a-1][b-1] = c
graph[b-1][a-1] = c
graph = csr_matrix(graph)
d = floyd_warshall(csgraph=graph, directed=False)
new_graph = [[0]*N for i in range(N)]
for i in range(N):
for j in range(N):
if d[i][j] <= L:
new_graph[i][j] = 1
new_graph[j][i] = 1
graph = csr_matrix(new_graph)
d = floyd_warshall(csgraph=graph, directed=False)
Q = int(input())
for i in range(Q):
s, t = (int(i) for i in input().split())
if d[s-1][t-1] == float("inf"):
print("-1")
else:
print(int(d[s-1][t-1]-1)) | 0 | null | 87,526,015,556,518 | 70 | 295 |
n = int(input())
a = list(map(int,input().split()))
ans = [0 for i in range(n)]
for i in a:
ans[i-1] += 1
for i in ans:
print(i) | from collections import Counter
n=int(input())
a=list(map(int,input().split()))
c=Counter(a)
for i in range(1,n+1):
print(c[i])
| 1 | 32,494,444,254,030 | null | 169 | 169 |
def solve(n):
if n <= 1:
print(1)
return
a, b = 1, 1
for _ in range(2, n + 1):
c = a + b
b = a
a = c
print(c)
if __name__ == "__main__":
n = int(input())
solve(n)
| def fib(n):
x=[1,1]
for i in range(n+1):
y=x[i]+x[i+1]
x.append(y)
print(x[n])
a=int(input())
fib(a)
| 1 | 1,764,053,412 | null | 7 | 7 |
def main():
from collections import deque
N, M = (int(i) for i in input().split())
if N % 2 == 0:
A = deque([i+1 for i in range(N)])
for i in range(1, M+1):
if (N-i)-i > N//2:
print(A[i], A[N-i])
else:
print(A[i], A[N-i-1])
else:
A = deque([i for i in range(N)])
for i in range(1, M+1):
print(A[i], A[N-i])
if __name__ == '__main__':
main()
| N=int(input())
S=input()
if N%2==0 and S[:int(N/2)]==S[int(N/2):]:
print("Yes")
else:
print("No") | 0 | null | 88,017,298,834,880 | 162 | 279 |
N = int(input())
if N%1000 == 0:
print(0)
else:
print(1000-(N%1000)) | cnt = 0
n = int(raw_input())
A = [int(raw_input()) for _ in range(n)]
G = [1] if n < 5 else [1, 4]
while G[-1]*3+1 <= n/3: G.append(G[-1]*3+1)
if n > 256: G.append(n/10*9+G[-1]%2+(n/10*9-1)%2)
G.reverse()
def insersionSort(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():
for g in G:
insersionSort(g)
shellSort()
print len(G)
print " ".join(map(str, G))
print cnt
print "\n".join(map(str, A)) | 0 | null | 4,248,790,790,020 | 108 | 17 |
N = int(input())
S = str(N)
m = len(S)
K = int(input())
#dp[i][j][k]: 上からi桁目までに0以外がj個あって、Nと一致しているならばk=0
dp = [[[0] * 2 for _ in range(4)] for _ in range(m+1)]
dp[0][0][0] = 1
for i in range(m): #i=0は架空の桁に相当。
for j in range(4):
for k in range(2):
#dp[i][j][k]という状態が次の桁でどこに遷移するかを考える。遷移先のni,nj,nkを決定する。
nd = int(S[i]) #Nのi桁目。1桁目はS[0]。
for d in range(10): #dというのが今の桁(i+1)の値
ni = i+1 #今の桁
nj = j
nk = k
if d != 0: #もし今の桁が0でなければjは一つ増える。
nj += 1
if nj > K: #もしnjが許容値のKを超えたら無視。
continue
if k == 0: #ここまで完全一致の時
if d > nd: #今の桁がNのi桁目より大きいつまりNを超えているので無視。
continue
elif d < nd: #今の桁がNのi桁目より小さいなら完全一致ではないのでnk=1と変更。
nk = 1
dp[ni][nj][nk] += dp[i][j][k]
ans = dp[m][K][0] + dp[m][K][1]
print(ans) | #coding:utf-8
import sys,os
from collections import defaultdict, deque
from fractions import gcd
from math import ceil, floor
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
XLMIIS = lambda x: [LMIIS() for _ in range(x)]
YN = lambda c : print('Yes') if c else print('No')
MOD = 10**9+7
list_N = list(map(int,list(input())))
len_N = len(list_N)
list_N = [0] + list_N
K = II()
dp0 = []
dp1 = []
for i in range(len_N+1):
dp0.append([0]*(K+1))
dp1.append([0]*(K+1))
for i in range(1,len_N+1):
dp0[i][0] = 1
dp0[1][1] = max(list_N[1]-1,0)
dp1[1][1] = 1
for i in range(2,len_N+1):
dp1[i][0] = dp1[i-1][0]
for j in range(1,K+1):
num = list_N[i]
if num > 0:
dp0[i][j] = dp0[i-1][j-1] * 9 + dp0[i-1][j] + dp1[i-1][j-1] * (num-1) + dp1[i-1][j]
dp1[i][j] = dp1[i-1][j-1]
else:
dp0[i][j] = dp0[i-1][j-1] * 9 + dp0[i-1][j]
dp1[i][j] = dp1[i-1][j]
print(dp0[len_N][K]+dp1[len_N][K])
dbg(dp0[len_N][K],dp1[len_N][K])
if __name__ == '__main__':
main() | 1 | 76,365,073,769,670 | null | 224 | 224 |
S = input()
S_len = len(S)
print("x" * S_len) | n = input()
print(n.replace(n,'x'*len(n))) | 1 | 72,977,389,504,800 | null | 221 | 221 |
a,b = input().split()
A = (a*int(b))
B = (b*int(a))
if A < B:
print(A)
else:
print(B) | li = input().split()
li.sort()
print(li[0]*int(li[1])) | 1 | 84,019,819,769,732 | null | 232 | 232 |
import numpy as np
H,W,M = map(int,input().split())
#h = np.empty(M,dtype=np.int)
#w = np.empty(M,dtype=np.int)
bomb = set()
hh = np.zeros(H+1,dtype=np.int)
ww = np.zeros(W+1,dtype=np.int)
for i in range(M):
h,w = map(int,input().split())
bomb.add((h,w))
hh[h] += 1
ww[w] += 1
#print(bomb)
h_max = np.max(hh)
w_max = np.max(ww)
h_max_ids = list()
w_max_ids = list()
for i in range(1,H+1):
if hh[i] == h_max:
h_max_ids.append(i)
for j in range(1,W+1):
if ww[j] == w_max:
w_max_ids.append(j)
for i in h_max_ids:
for j in w_max_ids:
if not (i,j) in bomb:
print(h_max + w_max)
exit()
#print("hmax:{} wmax:{}".format(h_max_id, w_max_id))
#print("hmax:{} wmax:{}".format(hh[h_max_id], ww[w_max_id]))
print(h_max + w_max - 1)
| def solve():
H,W,M = map(int,input().split())
h_counter = [0] * H
w_counter = [0] * W
opponents = []
for _ in range(M):
h, w = map(lambda x:int(x)-1, input().split())
h_counter[h] += 1
w_counter[w] += 1
opponents.append((h,w))
h_max = max(h_counter)
w_max = max(w_counter)
h_max_area_cnt = 0
h_max_area_nums = set()
for h in range(H):
if h_counter[h] == h_max:
h_max_area_nums.add(h)
h_max_area_cnt += 1
w_max_area_cnt = 0
w_max_area_nums = set()
for w in range(W):
if w_counter[w] == w_max:
w_max_area_nums.add(w)
w_max_area_cnt += 1
max_area_cnt = h_max_area_cnt * w_max_area_cnt
opponent_in_max_area = 0
for h,w in opponents:
if h in h_max_area_nums and w in w_max_area_nums:
opponent_in_max_area += 1
if max_area_cnt > opponent_in_max_area:
print(h_max + w_max)
else:
print(h_max + w_max - 1)
if __name__ == '__main__':
solve()
| 1 | 4,664,531,580,660 | null | 89 | 89 |
import sys
from collections import defaultdict
def input():
return sys.stdin.readline().rstrip()
def main():
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
len1 = T1 * A1 + T2 * A2
len2 = T1 * B1 + T2 * B2
first1 = T1 * A1
first2 = T1 * B1
second1 = T2 * A2
second2 = T2 * B2
if len1 == len2:
print("infinity")
exit()
if len1 > len2:
if first1 < first2:
a, b = divmod(first2 - first1, len1 - len2)
if b == 0:
print(a * 2)
exit()
else:
print(a * 2+1)
exit()
else:
print(0)
exit()
if len2 > len1:
if first2 < first1:
a, b = divmod(first1 - first2, len2 - len1)
if b == 0:
print(a * 2 )
exit()
else:
print(a * 2+1)
exit()
else:
print(0)
exit()
if __name__ == "__main__":
main()
| def solve(A, i, m, n):
"""Return if it is possible to make value m with some elements in A.
n is length of A.
i is index.
R is the record of answer i, m.
Using Divide-and-Conquer method.
"""
if R[i][m] != None:
return R[i][m]
if m == 0:
R[i][m] = True
return True
elif i >= n:
R[i][m] = False
return False
else:
ans = solve(A, i + 1, m, n) or solve(A, i + 1, m - A[i], n)
R[i][m] = ans
return ans
import sys
n = int(sys.stdin.readline())
A = tuple(map(int, sys.stdin.readline().split()))
q = int(sys.stdin.readline())
M = tuple(map(int, sys.stdin.readline().split()))
s_A = sum(A)
R = [[None] * 2000 for i in range(n + 1)]
ans = ''
for m in M:
if s_A < m:
ans += 'no\n'
elif solve(A, 0, m, n):
ans += 'yes\n'
else:
ans += 'no\n'
print(ans, end = '') | 0 | null | 66,033,995,182,038 | 269 | 25 |
# pythonの場合、ライブラリ関数でgcdがある？ただし、配列まとめてというわけではない模様
from math import gcd
def main():
N = int(input())
A = list(map(int,input().split()))
pc = True
maxA = max(A)
cnts = [ 0 for _ in range(maxA+1) ]
for a in A:
cnts[a] += 1
for i in range(2,maxA):
if pc:
# 素因数ごとに、A内での登場回数を数える
# 2つあったらその2つのcommon dividerとして、1以外にそれがあることが確定する
cnt = 0
for j in range(i,maxA+1,i):
cnt += cnts[j]
if 1 < cnt:
# Aの素因数で重複があれば、pcでない
pc = False
break
sc = False
if pc == False:
gcdResult = 0
for a in A:
# 配列全要素に対してgcdを呼んでるが、結果的に、それが1になればsc、ならなければnot sc
gcdResult=gcd(gcdResult,a)
if gcdResult == 1:
sc = True
if pc:
print("pairwise coprime")
elif sc:
print("setwise coprime")
else:
print("not coprime")
if __name__ == "__main__":
main()
| from functools import reduce
from math import gcd
N=int(input())
A=list(map(int, input().split()))
c=max(A)+1
C=[0]*c
f=1
for i in A:
C[i]+=1
for i in range(2,c):
cnt=0
for j in range(i,c,i):
cnt+=C[j]
if cnt>1:
f=0
if f==1:
print('pairwise coprime')
elif reduce(gcd, A) == 1:
print('setwise coprime')
else:
print('not coprime') | 1 | 4,128,960,520,132 | null | 85 | 85 |
def main():
N = int(input())
A = [int(a) for a in input().split()]
xor_all = A[0]
for i in range(1, N):
xor_all ^= A[i]
for i in range(N):
if i != N - 1:
print(A[i]^xor_all, end=" ")
else:
print(A[i]^xor_all)
if __name__ == "__main__":
main() | n = int(input())
a = list(map(int, input().split()))
s = a[0]
for i in range(1,n):
s ^= a[i]
ans = [0]*n
for j in range(n):
ans[j] = s ^ a[j]
print(*ans) | 1 | 12,498,169,902,110 | null | 123 | 123 |
n,k = map(int,input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
A.sort()
F.sort()
F.reverse()
t = sum(A)
ok = 10**12
ng = -1
if t <= k:
print(0)
else:
while abs(ok-ng) > 1:
cur = 0
mid = (ok+ng)//2
for i in range(n):
temp = mid/F[i]
if int(temp) == temp:
cur += max(0, int(A[i]-temp))
else:
if A[i]-temp > 0:
cur += int(A[i]-temp)+1
if cur > k:
ng = mid
else:
ok = mid
print(ok)
| import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
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()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M = map(int, readline().split())
uf = UnionFind(N)
for _ in range(M):
a, b = map(int, readline().split())
uf.union(a - 1, b - 1)
print(uf.group_count() - 1)
if __name__ == '__main__':
main() | 0 | null | 83,884,937,253,580 | 290 | 70 |
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
ans = "NO"
if abs(a-b) <= t * (v - w):
ans = "YES"
print(ans) |
A, B, C = map(int, input().split())
x = A * B * 4
y = (C - A - B) ** 2
if x < y and C - A - B > 0:
print("Yes")
else:
print("No")
| 0 | null | 33,260,982,585,100 | 131 | 197 |
from collections import Counter
n,p = map(int,input().split())
S = input()
dp = [0]
mod = p
if p==2:
ans =0
for i in reversed(range(n)):
if int(S[i])%2==0:
ans += i+1
print(ans);exit()
elif p==5:
ans =0
for i in reversed(range(n)):
if int(S[i])%5==0:
ans += i+1
print(ans);exit()
for i in reversed(range(n)):
dp.append(dp[-1]%mod + pow(10,n-1-i,mod)*int(S[i]))
dp[-1]%=mod
count = Counter(dp)
ans = 0
for key,val in count.items():
if val>=2:
ans += val*(val-1)//2
print(ans) | from sys import stdin
from collections import defaultdict, Counter
N, P = map(int, stdin.readline().split())
S, = stdin.readline().split()
ans = 0
# 2 cases
if P == 2 or P == 5:
digitdiv = []
for i in range(N):
if int(S[i]) % P == 0:
ans += i + 1
else:
#
count = Counter()
prefix = []
ten = 1
mod = 0
for i in range(N):
x = (int(S[N - i - 1])*ten + mod) % P
prefix.append(x)
count[x] += 1
ten = (ten * 10) % P
mod = x
prefix.append(0)
count[0] += 1
for val in count.values():
ans += val*(val - 1)//2
print (ans)
| 1 | 58,308,458,434,070 | null | 205 | 205 |
import math
a,b,C = tuple(float(n) for n in input().split())
C = math.radians(C)
S = a*b*math.sin(C) / 2
L = a + b + math.sqrt(a**2+b**2-2*a*b*math.cos(C))
h = b*math.sin(C)
print("{:.8f}\n{:.8f}\n{:.8f}".format(S,L,h))
| import math
pi=math.pi
a,b,si=map(float,input().split())
S=(1/2)*a*b*math.sin(math.radians(si))
c2=a*a+b*b-2*a*b*math.cos(math.radians(si))
L=a+b+math.sqrt(c2)
h=(2*S)/a
print(S)
print(L)
print(h)
| 1 | 168,230,444,082 | null | 30 | 30 |
x = input().split()
a = int(x[0])
b = int(x[1])
c = int(x[2])
if a <= b <= c:
print(a,b,c)
elif a <= c <= b:
print(a,c,b)
elif b <= a <= c:
print(b,a,c)
elif b <= c <= a:
print(b,c,a)
elif c <= a <= b:
print( c,a,b)
else:
print(c,b,a) | a = raw_input().split(" ")
a.sort()
print "%s %s %s" % (a[0],a[1],a[2]) | 1 | 427,591,079,168 | null | 40 | 40 |
n = input()
d = [0 for i in range(n)]
f = [0 for i in range(n)]
G = [0 for i in range(n)]
M = [[0 for i in range(n)] for j in range(n)]
color = [0 for i in range(n)]
tt = [0]
WHITE = 0
GRAY = 1
BLACK = 2
def dfs_visit(u):
color[u] = GRAY
tt[0] = tt[0] + 1
d[u] = tt[0]
for v in range(n):
if M[u][v] == 0:
continue
if color[v] == WHITE:
dfs_visit(v)
color[u] == BLACK
tt[0] = tt[0] + 1
f[u] = tt[0]
def dfs():
for u in range(n):
if color[u] == WHITE:
dfs_visit(u)
for u in range(n):
print "%d %d %d" %(u + 1, d[u], f[u])
### MAIN
for i in range(n):
G = map(int, raw_input().split())
for j in range(G[1]):
M[G[0]-1][G[2+j]-1] = 1
dfs() | #ライブラリの読み込み
import math
#入力値の格納
k,x = map(int,input().split())
#判定
if k * 500 >= x:
text = "Yes"
else:
text = "No"
#表示
print(text)
| 0 | null | 49,097,830,577,192 | 8 | 244 |
def cmb(n, r, mod):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return (fact[n] * factinv[r] * factinv[n-r]) % mod
def prm(n,r,mod):
if (r < 0) or (n < r):
return 0
return (fact[n] * factinv[n-r])%mod
mod = 10**9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0,1]
s = int(input())
na = s//3
ans = 0
for i in range(2,s):
fact.append((fact[-1] * i) % mod)
inv.append((inv[mod % i] * (mod - (mod // i))) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
for i in range(1,na+1):
ans += cmb(s - 3*i + i - 1, i-1 , mod)
ans %= mod
print(ans%mod) | s = int(input())
a = []
a.append(1)
a.append(0)
a.append(0)
for i in range(3,s+1):
a.append(sum(a)-a[i-1]-a[i-2])
ans = a[-1] % (10**9 + 7)
print(ans) | 1 | 3,309,540,281,960 | null | 79 | 79 |
from collections import deque
n,k = map(int,input().split())
r,s,p = map(int,input().split())
t = input()
q = deque([])
points = 0
for i in range(n):
if i <= k-1:
if t[i] == 'r':
points += p
q.append('p')
elif t[i] == 's':
points += r
q.append('r')
elif t[i] == 'p':
points += s
q.append('s')
else:
ban = q.popleft()
if t[i] == 'r':
if ban != 'p':
points += p
q.append('p')
else:
q.append('x')
elif t[i] == 's':
if ban != 'r':
points += r
q.append('r')
else:
q.append('x')
elif t[i] == 'p':
if ban != 's':
points += s
q.append('s')
else:
q.append('x')
print(points) | N,K=map(int,input().split())
R,S,P=map(int,input().split())
T=list(input())
d={"r":P,"s":R,"p":S}
ans=0
for i in range(N):
if i>=K and T[i-K]==T[i]:
T[i]="o"
else:
ans+=d[T[i]]
print(ans) | 1 | 107,041,664,167,708 | null | 251 | 251 |
import sys
import fractions
input = sys.stdin.readline
mod = 10 ** 9 + 7
N = int(input().strip())
A = list(map(int, input().strip().split(" ")))
lcm = 1
for a in A:
lcm = a // fractions.gcd(a, lcm) * lcm
ans = 0
for a in A:
ans += lcm // a
print(ans % mod) | from fractions import gcd
import sys
input = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
def modinv(a, mod):
return pow(a, mod - 2, mod)
n = int(input())
if n == 1:
print(1)
exit()
A = list(map(int, input().split()))
lcm = A[0]
for i in range(n):
g = gcd(lcm, A[i])
lcm *= A[i] // g
ans = 0
for i in range(n):
gyaku = modinv(A[i], mod)
ans += lcm * gyaku
ans %= mod
print(ans)
| 1 | 87,712,619,175,780 | null | 235 | 235 |
def solve(string):
k = int(string)
if k % 2 == 0 or k % 5 == 0:
return "-1"
n = 7
ans = 1
while n % k:
n = (10 * n + 7) % k
ans += 1
return str(ans)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
| import sys
import numpy as np # noqa
import numba # noqa
from numba import njit, b1, i4, i8, f8 # noqa
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
@njit((i8, ), cache=True)
def main(K):
for i in range(K):
if i == 0:
a = 7 % K
else:
a = (a * 10 + 7) % K
if a == 0:
return i + 1
return -1
K = int(readline())
print(main(K))
| 1 | 6,074,064,229,706 | null | 97 | 97 |
N, M = map(int, input().split())
A = list(map(int, input().split()))
print(max(-1, N-sum(A)))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from operator import or_
class SegmentTree:
def __init__(self, orig, func, unit):
_len = len(orig)
self.func = func
self.size = 1 << (_len - 1).bit_length()
self.tree = [unit] * self.size + orig + [unit] * (self.size - _len)
self.unit = unit
for i in range(self.size - 1, 0, -1):
self.tree[i] = func(self.tree[i * 2], self.tree[i * 2 + 1])
def update(self, i, v):
i += self.size
self.tree[i] = v
while i:
i //= 2
self.tree[i] = self.func(self.tree[i * 2], self.tree[i * 2 + 1])
def find(self, l, r):
l += self.size
r += self.size
ret = self.unit
while l < r:
if l & 1:
ret = self.func(ret, self.tree[l])
l += 1
if r & 1:
r -= 1
ret = self.func(ret, self.tree[r])
l //= 2
r //= 2
return ret
n = readline()
s = readline()
q = int(readline())
li = [1 << ord(x) - 97 for x in s[:-1]]
seg = SegmentTree(li, or_, 0)
ans = []
for _ in range(q):
f, x, y = readline().split()
x = int(x)
if f == '1':
seg.update(x - 1, 1 << ord(y) - 97)
else:
y = int(y)
z = seg.find(x - 1, y)
cnt = bin(z).count('1')
ans.append(cnt)
print(*ans)
| 0 | null | 47,264,907,661,230 | 168 | 210 |
N=int(input())
dp=[0]*(N+1)
dp[0]=1
dp[1]=1
for i in range(2,N+1):
dp[i]=dp[i-1]+dp[i-2]
ans=dp[N]
print(ans)
| N = int(input())
def memorize(f) :
cache = {}
def helper(*args) :
if args not in cache :
cache[args] = f(*args)
return cache[args]
return helper
@memorize
def fibonacci(n):
if n == 0 or n == 1:
return 1
res = fibonacci(n - 2) + fibonacci(n - 1)
return res
print(fibonacci(N))
| 1 | 1,823,035,200 | null | 7 | 7 |
N=int(input())
XY=[[] for _ in range(N)]
for i in range(N):
A=int(input())
for _ in range(A):
x,y = map(int, input().split())
x-=1
XY[i].append([x,y])
ans=0
for bit_state in range(2**N):
flag=True
for i in range(N):
if (bit_state>>i)&1:
for x, y in XY[i]:
if (bit_state >>x)&1 != y:
flag=False
if flag:
ans=max(ans, bin(bit_state).count("1"))
print(ans) | n = int(input())
a = []
xy = [[] for i in range(n)]
for i in range(n):
a.append(int(input()))
for j in range(a[i]):
xy[i].append(list(map(int, input().split())))
ans = 0
for i in range(2**n):
tf = [False for j in range(n)]
for j in range(n):
if (i>>j)&1:
tf[j] = True
flag = False
for j in range(n):
for k in range(a[j]):
if tf[j]:
if xy[j][k][1] != tf[xy[j][k][0]-1]:
flag = True
break
if flag:
break
else:
ans = max(ans, tf.count(True))
print(ans) | 1 | 121,272,102,336,396 | null | 262 | 262 |
def mips():
return map(int,input().split())
N,K = mips()
ans = 0
for i in range(K,N+1):
Max_K = (i * (2*N - (i-1)))//2
Min_K = (i * (2*0 + (i-1)))//2
ans += (Max_K-Min_K) + 1
ans %= (10**9 + 7)
print(ans+1) | n, k = map(int, input().split())
count = 0
for i in range(k, n + 2):
if i == k:
tot_min = 0
tot_max = 0
for j in range(i):
tot_min += j
tot_max += n - j
else:
tot_min += i - 1
tot_max += n - i + 1
count += tot_max - tot_min + 1
count %= 10 ** 9 + 7
print(count) | 1 | 33,104,274,354,930 | null | 170 | 170 |
l = int(input())
print((l/3)**3) | import sys
n = int(sys.stdin.readline().strip())
S = map(int, sys.stdin.readline().strip().split(" "))
n = int(sys.stdin.readline().strip())
T = map(int, sys.stdin.readline().strip().split(" "))
res = []
for t in T:
res.append(int(S.count(t) != 0))
print sum(res) | 0 | null | 23,614,019,157,920 | 191 | 22 |
a,b,k=map(int,input().split())
if a>=k: print(a-k,b)
elif a+b>=k: print(0,a+b-k)
else: print(0,0)
| #65
import math
while True:
n=int(input())
if n==0:
break
s=list(map(int,input().split()))
m=sum(s)/n
a=0
for i in range(n):
a+=(s[i]-m)**2
b=math.sqrt(a/n)
print(b)
| 0 | null | 52,289,870,981,502 | 249 | 31 |
N = int(input())
P = list(map(int,input().split()))
P = sorted([(P[i],i) for i in range(N)],key=lambda x:x[0])
cnt = 1
imin = P[0][1]
for i in range(1,N):
ind = P[i][1]
if ind<imin:
cnt += 1
imin = ind
print(cnt) | n = int(input())
p = list(map(int,input().split()))
min_num = 10**6
cnt = 0
for i in range(n):
if p[i] < min_num:
min_num = p[i]
cnt += 1
print(cnt) | 1 | 85,768,376,855,070 | null | 233 | 233 |
R, C, K = map(int, input().split())
V = [[0]*(C+1) for _ in range(R+1)]
for _ in range(K):
r, c, v = map(int, input().split())
V[r][c] = v
dp0 = [[0]*(C+1) for _ in range(R+1)]
dp1 = [[0]*(C+1) for _ in range(R+1)]
dp2 = [[0]*(C+1) for _ in range(R+1)]
dp3 = [[0]*(C+1) for _ in range(R+1)]
for i in range(R+1):
for j in range(C+1):
v = V[i][j]
la = lb = lc = ld = 0
if j > 0:
la = dp0[i][j-1]
lb = dp1[i][j-1]
lc = dp2[i][j-1]
ld = dp3[i][j-1]
dp2[i][j] = max(dp2[i][j], lc, lb + v)
dp3[i][j] = max(dp3[i][j], ld, lc + v)
if i > 0:
max_p = max(dp0[i-1][j], dp1[i-1][j], dp2[i-1][j], dp3[i-1][j])
dp0[i][j] = max(dp0[i][j], max_p, la)
dp1[i][j] = max(dp1[i][j], max_p + v, lb, la + v)
print(max(dp0[R][C], dp1[R][C], dp2[R][C], dp3[R][C]))
| import os
import sys
import numpy as np
def solve(inp):
r, c, k = inp[:3]
items = np.zeros((r + 1, c + 1), dtype=np.int64)
rrr = inp[3::3]
ccc = inp[4::3]
vvv = inp[5::3]
for r_, c_, v in zip(rrr, ccc, vvv):
items[r_, c_] = v
dp = np.zeros((r + 1, c + 1, 4), dtype=np.int64)
for i in range(1, r + 1):
for j in range(1, c + 1):
v = items[i, j]
dp[i, j] = np.maximum(dp[i, j - 1], dp[i - 1, j, 3])
if v > 0:
dp[i, j, 1:] = np.maximum(dp[i, j, 1:], dp[i, j, :-1] + v)
return dp[-1, -1, -1]
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', '(i8[:],)')(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit('(i8[:],)', cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print(ans)
| 1 | 5,613,602,318,880 | null | 94 | 94 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.