code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
from math import ceil
A, B, C, D = map(int, input().split())
time_A, time_C = ceil(A/D), ceil(C/B)
print('Yes') if time_A >= time_C else print('No') | import math
a, b, c, d = map(int, input().split())
takahashi_attacks = math.ceil(c / b)
aoki_attacks = math.ceil(a / d)
if takahashi_attacks <= aoki_attacks:
print('Yes')
else:
print('No') | 1 | 29,775,776,164,802 | null | 164 | 164 |
from functools import reduce
import sys
N, M = map(int, input().split())
A = list(map(int, input().split()))
def lcm(a,b):
return int(a * b / gcd(a, b))
def gcd(a, b):
import fractions
return fractions.gcd(a, b)
def temp(a):
return int(a * 0.5)
max_a = max(A)
i = 0
while True:
num = int((i+0.5) * max_a)
if num > M:
print(0)
sys.exit()
found = True
for a in A:
if int(num - 0.5 * a) % a != 0:
found = False
break
if found:
ans = 1
break
i += 1
aa = reduce(lcm, A)
ans += (M - num) // aa
print(int(ans))
| #coding:UTF-8
x = input()
a = x/3600
b = (x%3600)/60
c = (x%3600)%60
print str(a)+":"+str(b)+":"+str(c) | 0 | null | 50,935,441,944,508 | 247 | 37 |
n = int(input())
a = list(map(int, input().split()))
hoge = [0] * n
cnt = 0
for i in range(n):
#hoge[i + 1] = hoge[i] + a[i]
cnt += a[i]
hoge[i] = cnt
hoge_ = [0] * n
cnt = 0
for i in range(n - 1, -1, -1):
cnt += a[i]
hoge_[i] = cnt
ans = float('Inf')
for i in range(n - 1):
ans = min(ans, abs(hoge[i] - hoge_[i + 1]))
print(ans) | import collections
N=int(input())
A=list(map(int,input().split()))
c=collections.Counter(A)
#全体の数列について答えを求めるnC2=n(n-1)/2
ALL=0
for i in c.values():
if i>1:
ALL += i*(i-1)//2
#各要素が影響する分を求める
for i in A:
if c[i]>2:
print(ALL-c[i]+1)
elif c[i]==2:
print(ALL-1)
else:
print(ALL) | 0 | null | 94,909,055,328,972 | 276 | 192 |
N, K = map(int, input().split())
snuke = [False] * (N + 1)
for _ in range(K):
d = int(input())
A = list(map(int, input().split()))
for a in A:
snuke[a] = True
ans = 0
for i in range(1, N + 1):
if snuke[i] == False:
ans += 1
print(ans)
| n,k=map(int,input().split())
sunu=[0]*n
for i in range(k):
d=int(input())
a=list(map(int,input().split()))
for j in range(d):
sunu[a[j]-1]+=1
ans=0
for i in range(len(sunu)):
if sunu[i]==0:
ans+=1
print(ans) | 1 | 24,577,677,739,442 | null | 154 | 154 |
s = list(input())
s = list(set(s))
print('Yes') if len(s) >1 else print('No') | s=input()
for i in range(len(s)-1):
if s[i]!=s[i+1]:
print("Yes")
exit()
print("No")
| 1 | 54,618,037,885,152 | null | 201 | 201 |
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, M = map(int, input().split())
A = list(sorted(map(int, input().split())))
S = sum(A)
acc = [0] * (N + 1)
for i in range(1, N + 1):
acc[i] = acc[i - 1] + A[i - 1]
def check(x):
total = 0
cnt = 0
for a in A:
l = -1
r = N
while r - l > 1:
m = (l + r) // 2
if A[m] + a >= x:
r = m
else:
l = m
cnt += N - r
total += acc[N] - acc[r]
total += a * (N - r)
return (total, cnt)
left = 0
right = 10 ** 6
while right - left > 1:
mid = (left + right) // 2
res = check(mid)
if res[1] >= M:
left = mid
else:
right = mid
res = check(left)
ans = res[0]
print(ans - (res[1] - M) * left)
| import sys
def f(x):
p=0
cnt=0
for i in range(n-1,-1,-1):
while p<n and a[i]+a[p]<x:
p+=1
cnt+=n-p
return cnt
n,m=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
l,r=a[0]*2,a[n-1]*2
md=(r+l)//2
while r-l>0:
if r-l<=1:
if f(r)==m: md=r;break
else: md=l;break
md=(r+l)//2
k=f(md)
if k==m: break
elif k>m: l=md
else: r=md
p=0
cnt=0
ans=0
for q in range(n-1,-1,-1):
try:
while p<n and a[q]+a[p]<=md:
p+=1
except:
b=1
while True:
b+=1
if p==n: break
cnt+=n-p
ans+=a[q]*(n-p)*2
ans+=(m-cnt)*md
print(ans)
| 1 | 107,913,254,105,800 | null | 252 | 252 |
while True:
m, f, r = map(int, raw_input().split())
p = ""
if m == -1 and f == -1 and r == -1:
break
if m == -1 or f == -1:
p = "F"
else:
s = m + f
if s >= 80:
p = "A"
elif s >= 65:
p = "B"
elif s >= 50:
p = "C"
elif s >= 30:
p = "C" if r >= 50 else "D"
else:
p = "F"
print(p) | while True:
x = []
x = input().split( )
y = [int(s) for s in x]
if sum(y) == -3:
break
if y[0] == -1 or y[1] == -1:
print("F")
elif y[0] + y[1] < 30:
print("F")
elif y[0] + y[1] >= 30 and y[0] + y[1] <50:
if y[2] >= 50:
print("C")
else:
print("D")
elif y[0] + y[1] >= 50 and y[0] + y[1] <65:
print("C")
elif y[0] + y[1] >= 65 and y[0] + y[1] <80:
print("B")
elif y[0] + y[1] >= 80:
print("A")
| 1 | 1,239,121,929,650 | null | 57 | 57 |
N = int(input())
a = list(map(int, input().split()))
ans = 0
for index, item in enumerate(a):
if (index+1) % 2 != 0 and item % 2 != 0:
ans += 1
print(ans)
| n = input()
R = [input() for i in xrange(n)]
m = R[0]
ans = -1e10
for r in R[1:]:
ans = max(ans, r - m)
m = min(m, r)
print ans | 0 | null | 3,910,329,761,580 | 105 | 13 |
# Forbidden List
X, N = [int(i) for i in input().split()]
pi = [int(i) for i in input().split()]
pl = []
pu = []
for i in pi:
if i <= X:
pl.append(i)
if X <= X:
pu.append(i)
pl.sort(reverse=True)
pu.sort()
nl = X
for i in pl:
if i == nl:
nl -= 1
nu = X
for i in pu:
if i == nu:
nu += 1
if X - nl <= nu - X:
print(nl)
else:
print(nu)
| S = input()
if S == ('ABC'):
print('ARC')
elif S == ('ARC'):
print('ABC')
else:
print('入力に誤りがあります。ABCまたはARCを入力してください。')
| 0 | null | 19,218,863,095,552 | 128 | 153 |
next_ord = ord(input()) + 1
print(chr(next_ord)) | #<ABC151>
#<A>
s = input()
s = ord(s)
s = s + 1
print(chr(s))
| 1 | 92,154,374,918,270 | null | 239 | 239 |
a= int(input())
h = a//3600
m = (a%3600)//60
s = (a%3600)%60
print('%d:%d:%d' % (h, m, s))
| suit = {"S": 0, "H": 1, "C": 2, "D": 3}
suit_keys = list(suit.keys())
deck = [[suit_keys[i] + " " + str(j + 1) for j in range(13)] for i in range(4)]
for _ in range(int(input())):
card = input().split()
deck[suit[card[0]]][int(card[1]) - 1] = ""
for i in range(4):
for j in range(13):
if deck[i][j] != "":
print(deck[i][j])
| 0 | null | 682,777,608,710 | 37 | 54 |
n = int(input())
ns = []
max_profit = -1000000000
min_value = 1000000000
for i in range(n):
num = int(input())
if i > 0:
max_profit = max(max_profit, num-min_value)
min_value = min(num, min_value)
print(max_profit)
| #-*- coding:utf-8 -*-
def main():
n , data = input_data()
vMax = float('-inf')
vMin = data.pop(0)
for Rj in data:
if vMax < Rj - vMin:
vMax = Rj - vMin
if vMin > Rj:
vMin = Rj
print(vMax)
def input_data():
n = int(input())
lst = [int(input()) for i in range(n)]
return (n , lst)
if __name__ == '__main__':
main() | 1 | 12,411,673,050 | null | 13 | 13 |
H,W = map(int,input().split())
if((H != 1)and(W != 1)):
cnt1 = ((H+1)//2)*((W+1)//2)
cnt2 = (H//2)*(W//2)
ans = cnt1 + cnt2
else:
ans = 1
print(ans) | h, w = map(int, input().split())
print(1) if h == 1 or w == 1 else print((h * w) // 2 + (w * h) % 2) | 1 | 50,656,058,075,360 | null | 196 | 196 |
while True:
h,w=map(int,input().split())
if h==0 and w==0:
break
for i in range(h):
for j in range(w):
if i==0 or j==0 or i==h-1 or j==w-1:
print("#",end="")
else:
print(".",end="")
print("")
print("")
| N = input()
lenN = len(N)
sumN = 0
for x in N:
sumN += int(x)
if sumN > 9:
sumN %= 9
if sumN % 9 == 0:
print('Yes')
else:
print('No') | 0 | null | 2,589,777,557,290 | 50 | 87 |
i = 0
while True:
i += 1
num = raw_input()
if num == "0":
break
print "Case %d: %s" % (i,num) | L=[]
N= 0
while True:
n= int(input())
if(n==0):
break
L.append(n)
N= N+1
for x in range(N):
print("Case",str(x+1)+":",L[x]) | 1 | 480,240,632,362 | null | 42 | 42 |
x = int(input())
m = divmod(x, 500)
print(m[0] * 1000 + m[1] // 5 * 5) | x = int(input())
print(8 - ((x - 400) // 200)) | 0 | null | 24,558,352,096,586 | 185 | 100 |
n = int(input())
ans = -1
for k in range(n, 0, -1):
if n == k * 108 // 100:
ans = k
break
if ans > 0: print(ans)
else: print(':(') | n=int(input())
ans=':('
for i in range(1,n+1):
if int((i*1.08)//1)==n:
ans=i
break
print(ans)
| 1 | 126,123,074,008,228 | null | 265 | 265 |
for i in range(100000):
h,w = map(int,input().split(" "))
if h + w == 0:
break
print("#"*w)
for j in range(h-2):
print("#" + "."*(w-2) + "#")
print("#"*w)
print("") | 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")
| 0 | null | 3,827,556,975,950 | 50 | 101 |
n = int(input())
a = list(map(int, input().split()))
for i in range(1, n):
a[i] += a[i - 1]
ans = a[n-1]
for x in a[:n-1]:
ans = min(ans, abs(a[n-1] - 2 * x))
print(ans)
| n = int(input())
a = list(map(int, input().split()))
cnt = 0
ave = sum(a)/2
for i in range(n):
cnt += a[i]
if cnt >= ave:
ans = min(cnt*2-ave*2, ave*2-(cnt-a[i])*2)
break
print(int(ans)) | 1 | 142,286,434,412,760 | null | 276 | 276 |
def resolve():
import itertools
N = int(input())
A = []
X = []
ans = [0]
for _ in range(N):
a = int(input())
xx = []
for __ in range(a):
x = list(map(int, input().split()))
xx.append(x)
X.append(xx)
A.append(a)
for i in itertools.product([0, 1], repeat=N):
flag = 0
for p in range(N):
for q in range(A[p]):
if i[p] == 1 and X[p][q][1] != i[X[p][q][0]-1]:
flag = 1
if flag == 0:
ans.append(i.count(1))
print(max(ans))
resolve() | # D - Alter Altar
N = int(input())
c = input()
white_l = 0
red_r = 0
for i in range(N):
if c[i]=='R':
red_r += 1
ans = red_r
for i in range(N):
if c[i]=='W':
white_l += 1
else:
red_r -= 1
ans = min(ans, max(red_r,white_l))
print(ans) | 0 | null | 63,686,682,287,200 | 262 | 98 |
N,M,L = map(int,input().split())
ABC = [list(map(int,input().split())) for _ in range(M)]
Q = int(input())
class WarshallFloyd:
def __init__(self,n):
self.n = n
self.inf = 100000000000000
self.d = [[self.inf for _ in range(n)] for _ in range(n)]
for i in range(self.n):
self.d[i][i] = 0
def register(self,v1,v2,l,multiple=True):
self.d[v1][v2] = l
if multiple:
self.d[v2][v1] = l
def solve(self):
for i in range(self.n):
for j in range(self.n):
for k in range(self.n):
self.d[j][k] = min(self.d[j][k],self.d[j][i]+self.d[i][k])
return self.d
W = WarshallFloyd(N)
for a,b,c in ABC:
W.register(a-1,b-1,c)
D = W.solve()
WL = WarshallFloyd(N)
for i in range(N):
for j in range(N):
if D[i][j] <= L and i != j:
WL.register(i,j,1)
DL = WL.solve()
ST = [list(map(int,input().split())) for _ in range(Q)]
for i in range(Q):
s,t = ST[i]
transition = DL[s-1][t-1]
if transition == 100000000000000:
print(-1)
else:
print(transition-1) | N, A, B = map(int, input().split())
A, B = min(A, B), max(A, B)
d = B - A
if d % 2 == 0:
print(d // 2)
else:
if (A - 1 <= N - B):
A, B = A - 1, B - 1
else:
A, B = N - B, N - A
ans = min(B, A + 1 + (B - A - 1) // 2)
print(ans)
| 0 | null | 141,359,722,283,670 | 295 | 253 |
from math import sqrt
a,b,c,d = map(float,input().split())
print(sqrt((c-a)**2+(d-b)**2)) | h,n=list(map(int ,input().split()))
l=list(map(int ,input().split()))
ans=0
count=0
for i in range(0,n):
ans+=l[i]
if(ans==h or ans>h):
count+=1
else:
count+=0
if(count>0):
print("Yes")
else:
print("No") | 0 | null | 39,199,325,623,230 | 29 | 226 |
a,b = map(int,input().split())
leg = 0
for i in range(0,a+1):
if 2*i +4*(a-i) == b:
print('Yes')
exit()
print('No')
| M,N = map(int,input().rstrip().split(" "))
ans=False
for a in range(M + 1):
b=M-a
if 2 * a + 4 * b == N:
ans=True
if ans:
print("Yes")
else:
print("No") | 1 | 13,901,842,949,040 | null | 127 | 127 |
n = int(input())
ans = 'No'
for i in range(1,10):
for j in range(i,10):
if i*j == n:
ans = 'Yes'
print(ans) | n = int(input())
print('Yes' if any(i*j == n for i in range(1, 10) for j in range(1, 10)) else 'No') | 1 | 160,015,482,088,180 | null | 287 | 287 |
n = int(input())
graph = [[-1 for _ in range(n)] for _ in range(n)]
for i in range(n):
a = int(input())
for _ in range(a):
x, y = map(int, input().split())
graph[i][x-1] = y
ans = 0
for p in range(2**n):
q = p
c = 0
t = []
l = 0
while q:
if q&1:
t.append(graph[c])
l += 1
q >>= 1
c += 1
flag = True
for c in range(n):
if p&1:
for s in t:
if s[c] == 0:
flag = False
else:
for s in t:
if s[c] == 1:
flag = False
p >>= 1
if flag:
ans = max(ans, l)
print(ans) | N = int(input())
L = list(map(int, input().split()))
import copy
U = copy.copy(L)
for i in range (0, N):
L[i]+=(i+1)
U[i]= -U[i]+(i+1)
L = sorted(L)
U = sorted(U)
import bisect
count = 0
for i in range (0, N):
count+= bisect.bisect_right(U, L[i])-bisect.bisect_left(U, L[i])
print(count) | 0 | null | 74,045,731,763,262 | 262 | 157 |
n=int(input())
print((n//2)+(n%2)) | a,b=map(int,input().split())
x=str(a)*b
y=str(b)*a
if x<y:
print(x)
else:
print(y) | 0 | null | 71,685,840,800,642 | 206 | 232 |
mod=10**9+7
n,k=map(int,input().split())
l=[0]*(k+1)
for i in range(k):
num=(k-i)
if k//num==1:
l[num]=1
else:
ret=pow(k//num,n,mod)
for j in range(2,k//num+1):
ret-=l[num*j]
ret%=mod
l[num]=(ret)%mod
ans=0
for i in range(k+1):
ans+=(l[i]*i)%mod
print(ans%mod)
| n = int(input())
mode = 0
memo = 0
for i in range(n):
a,b = map(int,input().split())
if a == b:
memo += 1
else:
memo = 0
if memo == 3:
mode = 1
break
if mode:
print("Yes")
else:
print("No") | 0 | null | 19,730,338,992,318 | 176 | 72 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return S().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, size):
self.bit = [0] * size
self.size = size
self.total = 0
def add(self, i, w):
x = i + 1
self.total += w
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
res = 0
x = i + 1
while x:
res += self.bit[x - 1]
x -= x & -x
return res
def interval_sum(self, i, j): # i <= x < j の区間
return self.sum(j - 1) - self.sum(i - 1) if i else self.sum(j - 1)
n = I()
s = list(S())
q = I()
D = defaultdict(lambda:BIT(n))
for j in range(n):
D[s[j]].add(j, 1)
for _ in range(q):
qi, i, c = LS()
if qi == "1":
i = int(i) - 1
D[s[i]].add(i, -1)
D[c].add(i, 1)
s[i] = c
else:
l, r = int(i) - 1, int(c)
ret = 0
for k in range(97, 123):
if D[chr(k)].interval_sum(l, r):
ret += 1
print(ret)
| import bisect
N=input()
S=list(input())
alphabet=[[] for _ in range(26)]
for i,s in enumerate(S):
alphabet[ord(s)-ord('a')].append(i)
Q=int(input())
for _ in range(Q):
Type,A,B=input().split()
if Type=="1":
A=int(A)
s=S[A-1]
if s==B:
continue
o=ord(s)-ord("a")
alphabet[o].pop(bisect.bisect_left(alphabet[o],A-1))
index=bisect.bisect(alphabet[ord(B)-ord("a")],A-1)
alphabet[ord(B)-ord("a")].insert(index,A-1)
S[A-1]=B
else:
A=int(A)
B=int(B)
ans=0
for i in range(26):
indexL=bisect.bisect_left(alphabet[i],A-1)
#indexR=bisect.bisect_right(alphabet[i],B-1)
#ans+=(indexL!=indexR)
if indexL==len(alphabet[i]):
continue
ans+=(alphabet[i][indexL]<=B-1)
print(ans)
| 1 | 62,250,198,788,800 | null | 210 | 210 |
def modpow(val, n, mod):
ret = 1
while n:
if n & 1:
ret = (ret * val) % mod
val = (val * val) % mod
n = n >> 1
return ret
mod = 10 ** 9 + 7
n, k = map(int, input().split())
my_dict = dict()
ret = 0
for i in range(k, 0, -1):
tmp = modpow(k // i, n, mod)
cnt = 2
while True:
val = i * cnt
if val > k:
break
else:
cnt += 1
tmp -= my_dict[val]
my_dict[i] = tmp
ret += tmp * i % mod
print(ret % mod)
| def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import permutations
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N,K = getNM()
ans = 0
rec = [0] * (K + 1)
for X in range(K, 0, -1):
rec[X] = pow(K//X, N, mod)
for i in range(2, K // X + 1):
rec[X] -= rec[i * X] % mod
ans += (X * rec[X]) % mod
print(ans % mod) | 1 | 36,818,310,170,760 | null | 176 | 176 |
a,b = map(int,input().split())
s = list(map(int,input().split()))
num1 =0
num2 =0
if b ==0:
print(a)
exit()
for i in range(100):
num1 = a-i
num2 = a+i
if not num1 in s and not num2 in s:
print(num1)
exit()
if not num1 in s:
print(num1)
exit()
if not num2 in s:
print(num2)
exit() | X,N = map(int, input().split())
P = list(map(int, input().split()))
min = 51
for i in range(102):
if i not in P and abs(X-i) < min:
min = abs(X-i)
ans = i
print(ans) | 1 | 14,012,498,234,710 | null | 128 | 128 |
import bisect
import copy
def check(a, b, bar):
sm = 0
cnt = 0
n = len(a)
for x in a:
i = bisect.bisect_left(a, bar - x)
if i == n:
continue
cnt += n - i
sm += b[i] + x * (n-i)
return cnt, sm
n,m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = copy.deepcopy(a)
for i,_ in enumerate(b[:-1]):
b[n-i-2] += b[n-i-1]
left = 0
right = b[0] * 2
while right - left > 1:
middle = ( right + left ) // 2
if check(a, b, middle)[0] < m:
right = middle
else:
left = middle
print(check(a, b, left)[1] - left * (check(a, b, left)[0]-m) ) | for i in range(1, 10):
for j in range(1, 10):
print "{0}x{1}={2}".format(i, j, i*j) | 0 | null | 53,937,313,965,600 | 252 | 1 |
A = [list(map(int, input().split())) for i in range(3)]
N = int(input())
a = [[False] * 3 for _ in range(3)]
for _ in range(N):
b = int(input())
for i in range(3):
for j in range(3):
if A[i][j] == b:
a[i][j] = True
ans = False
for i in range(3):
if a[i][0] and a[i][1] and a[i][2] or a[0][i] and a[1][i] and a[2][i]:
print('Yes')
exit()
if a[0][0] and a[1][1] and a[2][2] or a[2][0] and a[1][1] and a[0][2]:
print('Yes')
exit()
print('No')
| import numpy as np
CARD_SIZE = 3
def solve(card, called_numbers):
checked_card = np.vectorize(lambda n: n in called_numbers)(card)
for l in checked_card:
if all(l):
return True
for l in zip(*checked_card):
if all(l):
return True
if all([checked_card[n][n] for n in range(CARD_SIZE)]):
return True
if all([checked_card[n][CARD_SIZE - n - 1] for n in range(CARD_SIZE)]):
return True
return False
def resolve():
card = [[int(row) for row in input().split()] for _ in range(CARD_SIZE)]
N = int(input())
called_numbers = {int(input()) for n in range(N)}
ret = solve(card, called_numbers)
print("Yes" if ret else "No")
if __name__ == '__main__':
resolve() | 1 | 59,931,815,084,382 | null | 207 | 207 |
x = int(input())
Level = [i for i in range(400, 2000, 200)]
ans = 9
for level in Level:
if x >= level:
ans -= 1
print(ans) | n = int(input())
if n <= 599:
print(8)
elif 600 <= n <= 799:
print(7)
elif 800 <= n <= 999:
print(6)
elif 1000 <= n <= 1199:
print(5)
elif 1200 <= n <= 1399:
print(4)
elif 1400 <= n <= 1599:
print(3)
elif 1600 <= n <= 1799:
print(2)
elif 1800 <= n <= 1999:
print(1) | 1 | 6,729,308,128,762 | null | 100 | 100 |
def main():
from sys import setrecursionlimit, stdin
from os import environ
from collections import defaultdict, deque, Counter
from math import ceil, floor, gcd
from itertools import accumulate, combinations, combinations_with_replacement
setrecursionlimit(10**6)
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in environ else lambda *x: 0
input = lambda: stdin.readline().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
P = 10**9+7
INF = 10**9+10
N = II()
args = defaultdict(lambda:defaultdict(lambda:[0]*2))
zeros = 0
for _ in range(N):
x,y = map(int,input().split())
if x == 0:
if y == 0:
zeros += 1
else:
args[0][0][0] += 1
continue
elif y == 0:
args[0][0][1] += 1
continue
g = gcd(x,y)
x2,y2 = abs(x//g),abs(y//g)
if x*y < 0:
args[x2][y2][1] += 1
else:
args[y2][x2][0] += 1
ans = 1
for y, a in args.items():
for x, p in a.items():
ans *= (pow(2,p[0],P) + pow(2,p[1],P) -1)
ans %= P
print((ans + zeros -1 + P)%P)
main() | """
n = int(input())
ab = [list(map(int,input().split())) for _ in range(n)]
mod = 1000000007
ab1 = []
ab2 = []
ab3 = []
ab4 = []
count00 = 0
count01 = 0
count10 = 0
for i in range(n):
if ab[i][0] != 0 and ab[i][1] != 0:
ab1.append(ab[i][0]/ab[i][1])
ab2.append(-ab[i][1]/ab[i][0])
if ab[i][0]/ab[i][1] > 0:
ab3.append((ab[i][0]/ab[i][1],-ab[i][1]/ab[i][0]))
else:
ab4.append((ab[i][0]/ab[i][1],-ab[i][1]/ab[i][0]))
elif ab[i][0] == 0 and ab[i][1] == 0:
count00 += 1
elif ab[i][0] == 0 and ab[i][1] == 1:
count01 += 1
else:
count10 += 1
dict1 = {}
dict2 = {}
ab3.sort()
ab4.sort(reverse = True)
print(ab3)
print(ab4)
for i in ab1:
if i in dict1:
dict1[i] += 1
else:
dict1[i] = 1
for i in ab2:
if i in dict2:
dict2[i] += 1
else:
dict2[i] = 1
sorted1 = sorted(dict1.items(), key = lambda x: x[0])
sorted2 = sorted(dict2.items(), key = lambda x: x[0])
print(sorted1)
print(sorted2)
cnt = 0
num1 = n - count00 - count01 - count10
ans = 0
for i in range(len(ab3)):
a,b = ab3[i]
num1 -= 1
if cnt < len(sorted2):
while cnt < len(sorted2):
if sorted2[cnt][0] == a:
ans += pow(2, num1+count01+count10-sorted2[cnt][1], mod)
ans %= mod
break
elif sorted2[cnt][0] < a:
cnt += 1
else:
ans += pow(2, num1+count01+count10, mod)
ans %= mod
break
else:
ans += pow(2, num1+count01+count10, mod) - pow(2, )
ans %= mod
print(ans)
for i in range(len(ab4)):
num1 -= 1
ans += pow(2, num1+count01+count10, mod)
ans %= mod
print(ans)
ans += pow(2, count01, mod) -1
print(ans)
ans += pow(2, count10, mod) -1
print(ans)
ans += count00
print(ans)
print(ans % mod)
"""
from math import gcd
n = int(input())
dict1 = {}
mod = 1000000007
cnt00 = 0
cnt01 = 0
cnt10 = 0
for _ in range(n):
a,b = map(int,input().split())
if a == 0 and b == 0:
cnt00 += 1
elif a == 0:
cnt01 += 1
elif b == 0:
cnt10 += 1
else:
c = gcd(a,b)
if b < 0:
a *= -1
b *= -1
set1 = (a//c, b//c)
if set1 in dict1:
dict1[set1] += 1
else:
dict1[set1] = 1
ans = 1
for k,v in dict1.items():
a,b = k
if dict1[(a,b)] == -1:
continue
if a > 0:
if (-b,a) in dict1:
ans *= 2**v + 2**dict1[(-b,a)] - 1
dict1[(-b,a)] = -1
else:
ans *= 2**v
else:
if (b,-a) in dict1:
ans *= 2**v + 2**dict1[(b,-a)] - 1
dict1[(b,-a)] = -1
else:
ans *= 2**v
ans %= mod
ans *= 2 ** cnt01 + 2 ** cnt10 - 1
ans += cnt00 - 1
print(ans%mod)
| 1 | 20,867,687,956,852 | null | 146 | 146 |
N, K = map(int, input().split())
A = [int(a) for a in input().split()]
print(len([a for a in A if a >= K])) | M1, D1 = input().split()
M2, D2 = input().split()
M1 = int(M1)
M2 = int(M2)
if M1!=M2:
print('1')
else:
print('0') | 0 | null | 152,333,682,154,176 | 298 | 264 |
def solve():
N = int(input())
print((N+1)//2)
if __name__ == "__main__":
solve() | x, y = map(int, input().split())
prize = 0
if x <= 3:
prize += (300000 - (x - 1) * 100000)
if y <= 3:
prize += (300000 - (y - 1) * 100000)
if (x == 1) & (y == 1):
prize += 400000
print(prize) | 0 | null | 99,970,418,756,130 | 206 | 275 |
N = int(input())
m=[]
line = ''
m = [[[0 for k in range(10)] for j in range(3)] for i in range(10)]
for i in range(N):
n = input().split()
b = int(n[0])
f = int(n[1])
r = int(n[2])
v = int(n[3])
m[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
for k in range(10):
line += ' {0}'.format(m[i][j][k])
print(line)
line = ''
if i < 3:
print('#'*20) | k=int(input())
a,b=map(int,input().split(' '))
flag=0
for i in range(a,b+1):
if i%k==0:
flag=1
if flag==1:
print('OK')
else:
print('NG')
| 0 | null | 13,708,917,777,280 | 55 | 158 |
se = set([])
n = int(raw_input())
for i in range(n):
s = raw_input().split()
if s[0] == 'insert':
se.add(s[1])
elif s[0] == 'find':
if s[1] in se:
print 'yes'
else:
print 'no' | from sys import stdin
def main():
a = set()
_ = int(stdin.readline())
for command,value in (line.split() for line in stdin.readlines()):
if command == "insert":
a.add(value)
else:
print("yes" if value in a else "no")
main()
| 1 | 77,683,398,618 | null | 23 | 23 |
import sys
from collections import deque
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N = input()
length = len(N)
K = int(input())
# 左からi桁目まで見て，N以下が確定していて，0でない数字がk個ある数字の個数
dp_1 = [[0] * (10) for _ in range(length)]
# 左からi桁目まで見て，N以下が確定していなくて，0でない数字がk個ある数字の個数
dp_2 = [[0] * (10) for _ in range(length)]
dp_1[0][0] = 1
dp_1[0][1] = int(N[0]) - 1
dp_2[0][1] = 1
for i in range(1, length):
# 小さいのが確定しているものに対して，0以外のものを追加
for k in range(1, K + 2):
dp_1[i][k] += dp_1[i - 1][k - 1] * 9
# 小さいものが確定しているものに対して，0を追加
for k in range(0, K + 2):
dp_1[i][k] += dp_1[i - 1][k]
# 大小がわからないものから，小さいのが確定する
if N[i] == "0":
for k in range(K + 2):
dp_2[i][k] += dp_2[i - 1][k]
else:
# 0を追加する
for k in range(K + 2):
dp_1[i][k] += dp_2[i - 1][k]
# その他の数字を追加
for k in range(1, K + 2):
dp_1[i][k] += dp_2[i - 1][k - 1] * (int(N[i]) - 1)
# 依然として大小関係がわからない
for k in range(1, K + 2):
dp_2[i][k] += dp_2[i - 1][k - 1]
ans = dp_1[-1][K] + dp_2[-1][K]
print(ans)
if __name__ == "__main__":
main()
| import sys
# import numba as nb
import numpy as np
input = sys.stdin.readline
# @nb.njit("i8(i8[:],i8,i8)", cache=True)
def solve(N, K, L):
dp = np.zeros(shape=(L + 1, 2, K + 1), dtype=np.int64)
dp[0][0][0] = 1
for i in range(L):
D = N[i]
for j in range(2):
d_max = 9 if j == 1 else D
for k in range(K + 1):
if k < K:
for d in range(d_max + 1):
dp[i + 1][int(j or (d < D))][k + int(d > 0)] += dp[i][j][k]
else:
dp[i + 1][j][k] += dp[i][j][k]
return dp[L][0][K] + dp[L][1][K]
def main():
N = np.array(list(input().rstrip()), dtype=np.int64)
K = int(input())
L = N.shape[0]
ans = solve(N, K, L)
print(ans)
if __name__ == "__main__":
main()
| 1 | 76,090,157,157,852 | null | 224 | 224 |
s,t = input().split()
a,b=map(int,input().split())
u=input()
print(a-1, b) if s == u else print(a,b-1) | 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 | 51,984,120,694,492 | 220 | 169 |
alpha = str(input())
if alpha in "abcdefghijklmnopqrstuvwxyz":
print("a")
else:
print("A") | a,b=map(int,input().split())
s1=str(a)*b
s2=str(b)*a
print(s1 if s2>s1 else s2) | 0 | null | 47,885,626,544,700 | 119 | 232 |
a = input("").split(" ")
a = [int(aa) for aa in a]
b = input("").split(" ")
b = [int(ab) for ab in b]
c = input("").split(" ")
c = [int(ac) for ac in c]
n = int(input(""))
hav = a + b + c
val = []
for d in range(n):
temp = int(input(""))
val.append(temp)
tf = [0,0,0,0,0,0,0,0,0]
i = 0
for e in hav:
if (e in val) == True:
tf[i] = 1
i += 1
tr = [1,1,1]
if tf[0:3] == tr:
print("Yes")
elif tf[3:6] == tr:
print("Yes")
elif tf[6:9] == tr:
print("Yes")
elif (tf[0]+tf[3]+tf[6]) == 3:
print("Yes")
elif (tf[1]+tf[4]+tf[7]) == 3:
print("Yes")
elif (tf[2]+tf[5]+tf[8]) == 3:
print("Yes")
elif (tf[0]+tf[4]+tf[8]) == 3:
print("Yes")
elif (tf[2]+tf[4]+tf[6]) == 3:
print("Yes")
else:
print("No") | from itertools import accumulate
n, k = map(int, input().split())
a = list(map(int, input().split()))
for _ in range(k):
newa = [0 for _ in range(n)]
for i in range(n):
l = max(0, i - a[i])
r = min(n - 1, i + a[i])
newa[l] += 1
if r + 1 < n:
newa[r + 1] -= 1
a = list(accumulate(newa))
if all(i == n for i in a):
break
print(*a) | 0 | null | 37,766,851,214,362 | 207 | 132 |
k = int(input())
ans = 0
ai = 0
for i in range(k+2):
ai = ((ai * 10) + 7) % k
if ai == 0:
ans = i + 1
print(ans)
exit()
ans = -1
print(ans)
| count = {}
for i in range(int(input())):
S = input()
if S in count:
count[S] += 1
else:
count[S] = 1
ans = max(count.values())
print(*sorted([A[0] for A in count.items() if A[1] == ans])) | 0 | null | 38,111,363,257,732 | 97 | 218 |
H,W=map(int,input().split())
s=[]
for _ in range(H):
s.append(list(input()))
inf=float("inf")
ans=[[inf]*W for _ in range(H)]
if s[0][0]==".":
ans[0][0]=0
else:
ans[0][0]=1
for i in range(H):
for j in range(W):
if j!=W-1:
if s[i][j]=="." and s[i][j+1]=="#":
ans[i][j+1]=min(ans[i][j]+1,ans[i][j+1])
else:
ans[i][j+1]=min(ans[i][j],ans[i][j+1])
if i!=H-1:
if s[i][j]=="." and s[i+1][j]=="#":
ans[i+1][j]=min(ans[i][j]+1,ans[i+1][j])
else:
ans[i+1][j]=min(ans[i][j],ans[i+1][j])
print(ans[H-1][W-1])
| l = [x+' '+y for x in ['S','H','C','D'] for y in [str(i) for i in range(1,14)]]
n = int(input())
while n > 0:
l.remove(input())
n -= 1
for i in l:
print(i) | 0 | null | 25,231,692,998,940 | 194 | 54 |
#個数が無制限のナップザックの問題(ただし、上限に注意)です(どの魔法を順番に選べば良いなどの制約がないのでナップザックDPを選択しました。)。
#dpの配列にはi番目の要素にモンスターの体力をi減らすために必要な最小の魔力を保存します。
#この配列は個数制限がないことに注意してinfではない要素のみを順に更新していけば良いです。
#また、最終的にモンスターの体力を最小の魔力で0以下にすれば良いので、モンスターの体力をh以上減らせる最小の魔力を求めれば良いです。
h,n=map(int,input().split())
a,b=[],[]
for i in range(n):
a_sub,b_sub=map(int,input().split())
a.append(a_sub)
b.append(b_sub)
inf=10000000000000
ma=max(a)#ダメージの最大値
dp=[inf]*(h+1+ma)#与えるダメージの最大値を考慮したDP
dp[0]=0#初期値
for i in range(h+1+ma):# 与えるダメージ合計：0ーH+1+maまで
if dp[i] == inf:#更新してきて、ダメージiになる組み合わせが存在しない場合は飛ばす
continue
for j in range(n): #N個の魔法を試す
ni = i + a[j] #今の状態から新しく与えた場合のダメージ合計
if ni<h+ma:#オーバーキルの範囲を超えるなら、無視
dp[ni] = min(dp[ni], dp[i] + b[j]) #ダメージniを与えるのにより小さい魔力で実現できる場合は更新
print(min(dp[h:]))
| import sys, math
input = sys.stdin.readline
H, N = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(N)]
max_a = max([a for a, b in ab])
dp = [math.inf] * (H+max_a+1)
dp[0] = 0
for i in range(H + 1):
for a, b in ab:
dp[i + a] = min(dp[i + a], dp[i] + b)
print(min(dp[H:]))
| 1 | 80,830,809,842,510 | null | 229 | 229 |
A, B, H, M = map(int, input().split())
# 時針: 12時間720分で360度 1分で0.5度
# 分針: 60分で360度 1分で6度
theta = abs(((0.5 * (H * 60 + M)) - (6 * M)) % 360)
if theta > 180:
theta = 360 - theta
#print(theta)
import math
C = math.sqrt(A ** 2 + B ** 2 - 2 * A * B * math.cos(theta / 180 * math.pi))
print(C) | import math
a, b, h, m = map(int, input().split())
st = (60*h+m)/360*math.pi
lt = m/30*math.pi
sx = a*math.sin(st)
sy = a*math.cos(st)
lx = b*math.sin(lt)
ly = b*math.cos(lt)
print(math.sqrt((lx-sx)**2+(ly-sy)**2))
| 1 | 20,027,145,893,300 | null | 144 | 144 |
while True:
H, W = map(int, input().split())
if not(H or W):
break
for i in range(H):
print('#', end='')
for j in range(W-2):
if i > 0 and i < H - 1:
print('.', end='')
else:
print('#', end='')
print('#')
print() | import numpy as np
a,b,x=map(int,input().split())
if x<=a*a*b/2:
y=2*x/(a*b)
print(360/((2*np.pi)/np.arctan(b/y)))
else:
y=2*x/(a**2)-b
print(360/((2*np.pi)/np.arctan((b-y)/a))) | 0 | null | 82,166,985,452,658 | 50 | 289 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
6
5
3
1
3
4
3
output:
3
"""
import sys
def solve():
# write your code here
max_profit = -1 * float('inf')
min_stock = prices[0]
for price in prices[1:]:
max_profit = max(max_profit, price - min_stock)
min_stock = min(min_stock, price)
return max_profit
if __name__ == '__main__':
_input = sys.stdin.readlines()
p_num = int(_input[0])
prices = list(map(int, _input[1:]))
print(solve()) | #ALDS1_1_D Maximum Profit
n=int(input())
A=[]
max_dif=-1*10**9
for i in range(n):
A.append(int(input()))
min=A[0]
for i in range(n-1):
if(A[i+1]-min>max_dif):
max_dif=A[i+1]-min
if(min>A[i+1]):
min=A[i+1]
print(max_dif) | 1 | 13,537,101,700 | null | 13 | 13 |
n = int(input())
cnt = 0
mx = -1
ps = []
for _ in range(n):
d1,d2 = map(int, input().split())
ps.append((d1,d2))
ps.append((1,2))
for d1,d2 in ps:
if d1 != d2:
mx = max(mx,cnt)
cnt = 0
else:
cnt += 1
print("Yes" if mx>=3 else "No")
| n = int(input())
nums = []
ans = ""
while n >= 1:
n -= 1
ans += chr(ord('a') + n % 26)
n = n // 26
print(ans[::-1]) | 0 | null | 7,116,351,828,612 | 72 | 121 |
import math
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**5+5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N,K = list(map(int,input().split()))
A = sorted(tuple(map(int,input().split())))
B = tuple(A[i+1]-A[i] for i in range(len(A)-1))
lim = math.ceil(len(B)/2)
L = 10**9+7
ans = 0
multi = cmb(N,K,mod)
for j in range(lim):
front = j + 1
back = N - front
tmp_b = 0
tmp_f = 0
if front >= K:
tmp_f = cmb(front,K,mod)
if back >= K:
tmp_b = cmb(back,K,mod)
if j == (len(B)-1)/2:
ans += (multi - tmp_b - tmp_f)*(B[j]) % L
else:
ans += (multi - tmp_b - tmp_f)*(B[j]+B[len(B)-1-j]) % L
print(ans%L) | N, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
result = 0
mod = 10**9+7
def cmb(n, r, mod=mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
n = 10**5+1
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, n+1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
if k==1:
print(0)
else:
result = 0
for i in range(N-k+1):
result += (a[N-i-1]-a[i])*cmb(N-1-i, k-1)
result %= mod
print(result%mod) | 1 | 95,336,573,417,150 | null | 242 | 242 |
k=int(input())
def dfs(keta, val):
lunlun.append(val)
if keta==10:
return
for i in range(-1,2):
add=(val%10)+i
if 0<=add<=9:
dfs(keta+1, val*10+add)
lunlun=[]
for i in range(1,10):
dfs(1, i)
lunlun.sort()
print(lunlun[k-1]) | input = list(map(int, input().split()))
if input[0] > input[1]:
print("safe")
else:
print("unsafe") | 0 | null | 34,522,384,895,922 | 181 | 163 |
# from sys import stdin
# input = stdin.readline
from collections import Counter
def solve():
x,n = map(int,input().split())
if n != 0:
p = set(map(int,input().split()))
if n == 0 or x not in p:
print(x)
return
else:
for i in range(100):
if x - i not in p:
print(x - i)
return
if x + i not in p:
print(x + i)
return
if __name__ == '__main__':
solve()
| import sys
x,n = map(int,input().split())
p = list(map(int,input().split()))
s = 100
min_i = -1
if x not in p:
print(x)
sys.exit()
for i in range(-1,102):
if i not in p and abs(i-x) < s:
s = abs(i-x)
min_i = i
print(min_i)
| 1 | 14,098,558,754,752 | null | 128 | 128 |
n=int(input())
p=n
yakusu=[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
yakusu.append(i)
if i!=n//i:
yakusu.append(n//i)
p-=1
yakusu_1=[]
for i in range(1,int(p**0.5)+1):
if p%i==0:
yakusu_1.append(i)
if i!=p//i:
yakusu_1.append(p//i)
ans=len(yakusu_1)-1
for x in yakusu:
r=n
if x!=1:
while r%x==0:
r//=x
if (r-1)%x==0:
ans+=1
print(ans) | import sys
def input():
return sys.stdin.readline()[:-1]
def main():
N = int(input())
P = []
for k in range(1,1+int((N-1)**(1/2))):
if (N-1)%k == 0:
P.append((N-1)//k)
P.append(k)
P = set(P)
ans = len(P)
for k in range(2,1+int(N**(1/2))):
if N%k == 0:
t = N//k
while t%k == 0:
t //= k
if t%k == 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 1 | 41,394,992,770,560 | null | 183 | 183 |
N, M = map(int, input().split())
route = [[] for _ in range(N)]
sign = [0]*N
#print(route)
for i in range(M):
a,b = map(int, input().split())
route[a-1].append(b-1)
route[b-1].append(a-1)
#print(route)
marked = {0}
q = [0]
for i in q:
for j in route[i]:
if j in marked:
continue
q.append(j)
marked.add(j)
sign[j] = i+1
print('Yes')
[print(i) for i in sign[1:]] | from collections import deque
n,m = map(int,input().split())
ab=[[] for _ in range(n+1)]
for _ in range(m):
a,b=map(int,input().split())
ab[a].append(b)
ab[b].append(a)
ans=[0]*(n+1)
ans[1]=1
que=deque()
que.append(1)
while que:
x=que.popleft()
for i in ab[x]:
if ans[i]==0:
ans[i]=x
que.append(i)
print("Yes")
for j in range(2,n+1):
print(ans[j]) | 1 | 20,636,491,723,072 | null | 145 | 145 |
# ??\?????????
N = int(input())
r = [int(input()) for i in range(N)]
# ?????§????¨????
max_profit = (-1) * (10 ** 9)
min_value = r[0]
for j in range(1, len(r)):
max_profit = max(max_profit, r[j] - min_value)
min_value = min(min_value, r[j])
print(max_profit) | n, m = map(int, input().split())
A = [list(map(int, input().split())) for _ in [None] * n]
b = [int(input()) for _ in [None] * m]
for a in A:
print(sum([i * j for i, j in zip(a, b)]))
| 0 | null | 584,831,520,350 | 13 | 56 |
table = list(map(int,input().split()))
for i in range(2,0,-1):
k = 0
while k < i:
if table[k] > table[k+1]:
table[k],table[k+1] = table[k+1],table[k]
k += 1;
print(table[0],table[1],table[2])
| s=input()
x=list(map(int,s.split()))
x.sort()
print("%d %d %d"%tuple(x)) | 1 | 423,098,593,928 | null | 40 | 40 |
n = int(input())
left = []
mid = []
midminus = []
right = []
L = []
R = []
for i in range(n):
s = input()
l = 0
r = 0
for x in s:
if x == '(':
l += 1
else:
if l > 0:
l -= 1
else:
r += 1
if l > 0 and r == 0:
left.append((l, r))
elif l > 0 and r > 0:
if l > r:
mid.append((r, l)) # a,b-a
else:
midminus.append((r,l))
elif l == 0 and r > 0:
right.append((l, r))
L.append(l)
R.append(r)
if sum(L) != sum(R):
print('No')
exit()
A = 0
B = 0
for x in left:
A += x[0]
for x in right:
B += x[1]
mid = sorted(mid, key=lambda x: (x[0],-x[1]))
midminus = sorted(midminus,key= lambda x:x[0]-x[1])
mid += midminus
l = A
r = 0
for a, b in mid:
if l < a:
print('No')
exit()
l -= a
l += b
print('Yes') | import sys
input=lambda: sys.stdin.readline().strip()
n=int(input())
A=[]
#
PM=[[0,0] for i in range(n)]
for i in range(n):
now=0
mini=0
for j in input():
if j=="(": now+=1
else:
now-=1 ; mini=min(mini,now)
PM[i]=[mini,now]
if sum( [PM[i][1] for i in range(n)] )!=0 :
print("No")
exit()
MINI=0
NOW=0
PMf=[PM[i] for i in range(n) if PM[i][1]>=0]
PMf.sort()
for i in range(len(PMf)):
MINI=min(MINI , NOW+PMf[-i-1][0] )
NOW+=PMf[-i-1][1]
if MINI<0 : print("No") ; exit()
PMs=[PM[i] for i in range(n) if PM[i][1]<0]
PMs=sorted(PMs , key=lambda x : x[1]-x[0])
for i in range(len(PMs)):
MINI=min(MINI , NOW+PMs[-i-1][0] )
NOW+=PMs[-i-1][1]
if MINI<0 : print("No") ; exit()
print("Yes")
| 1 | 23,553,914,644,972 | null | 152 | 152 |
s = input()
n = len(s)
left = [0 for _ in range(n+1)]
right = [0 for _ in range(n+1)]
tmp = 0
for i in range(n):
if s[i] == '<':
tmp += 1
else:
tmp = 0
left[i+1] = tmp
tmp = 0
for i in range(n-1, -1, -1):
if s[i] == '>':
tmp += 1
else:
tmp = 0
right[i] = tmp
ans = 0
for i in range(n+1):
ans += max(right[i], left[i])
print(ans) | import numpy as np
n,m,k = list(map(int, input().split()))
a_list = np.array(input().split()).astype(int)
b_list = np.array(input().split()).astype(int)
a_sum =[0]
b_sum=[0]
for i in range(n):
a_sum.append(a_sum[-1]+ a_list[i])
for i in range(m):
b_sum.append(b_sum[-1] + b_list[i])
#print(a_sum, b_sum)
total = 0
num = m
for i in range(n+1):
if a_sum[i] > k:
break
while (k - a_sum[i]) < b_sum[num]:
num -=1
#print(i, num)
if num == -1:
break
total = max(i+num, total)
print(total) | 0 | null | 83,231,881,767,680 | 285 | 117 |
from collections import deque
n = int(input())
x = input()
memo = {0: 0}
def solve(X):
x = X
stack = deque([])
while x:
if x in memo:
break
stack.append(x)
x = x % bin(x).count("1")
cnt = memo[x] + 1
while stack:
x = stack.pop()
memo[x] = cnt
cnt += 1
return cnt - 1
ans = []
px = x.count("1")
memo1 = [1 % (px - 1)] if px > 1 else []
memo2 = [1 % (px + 1)]
x1 = 0
x2 = 0
for i in range(n):
if px > 1:
memo1.append(memo1[-1] * 2 % (px-1))
memo2.append(memo2[-1] * 2 % (px+1))
for i in range(n):
if x[-i-1] == '1':
if px > 1:
x1 += memo1[i]
x1 %= (px-1)
x2 += memo2[i]
x1 %= (px+1)
for i in range(n):
if x[-i-1] == "1":
if px > 1:
ans.append(solve((x1-memo1[i])%(px-1)) + 1)
else:
ans.append(0)
else:
ans.append(solve((x2+memo2[i])%(px+1)) + 1)
for ansi in reversed(ans):
print(ansi)
| import sys
input = sys.stdin.readline
def main():
N = int(input())
X = input()
popcount_X = X.count("1")
if popcount_X == 0:
ans = [1] * N
elif popcount_X == 1:
ans = [1] * N
ans[-1] = 2
ans[X.index("1")] = 0
else:
X_mod_popcount_X_p = int(X, 2) % (popcount_X + 1)
X_mod_popcount_X_m = int(X, 2) % (popcount_X - 1)
ans = [0] * N
for i in range(N):
if X[i] == "0":
Y = X_mod_popcount_X_p + pow(2, N - 1 - i, mod=popcount_X + 1)
Y = Y % (popcount_X + 1)
else:
Y = X_mod_popcount_X_m - pow(2, N - 1 - i, mod=popcount_X - 1)
Y = Y + (popcount_X - 1)
Y = Y % (popcount_X - 1)
count = 1
while Y > 0:
popcount = bin(Y).count("1")
Y = Y % popcount
count += 1
ans[i] = count
print("\n".join(map(str, ans)))
if __name__ == "__main__":
main()
| 1 | 8,189,740,619,830 | null | 107 | 107 |
a = int(input())
num = a //1000
b = num*1000 - a
if b < 0:
c = (num+1)*1000-a
print(c)
else:
print(b)
| print((10000-int(input()))%1000) | 1 | 8,418,327,580,260 | null | 108 | 108 |
n = int(input())
al = list(map(int, input().split()))
if n%2 == 1:
dp = [ [0]*4 for _ in range(n//2+1) ]
for i in range(n//2):
dp[i+1][0] = dp[i][0] + al[i*2]
dp[i+1][1] = max(dp[i][1]+al[i*2+1], dp[i][0]+al[i*2+1])
dp[i+1][2] = max(dp[i][2]+al[i*2+2], dp[i][0]+al[i*2+2])
dp[i+1][3] = max(dp[i][3]+al[i*2+2], dp[i][1]+al[i*2+2])
ans = max(dp[-1])
print(ans)
else:
dp = [ [0]*2 for _ in range(n//2+1) ]
for i in range(n//2):
dp[i+1][0] = dp[i][0] + al[i*2]
dp[i+1][1] = max(dp[i][1]+al[i*2+1], dp[i][0]+al[i*2+1])
ans = max(dp[-1])
print(ans) | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
# F - Select Half
n = int(input())
a = list(map(int, input().split()))
assert len(a) == n
# memo[i][m] a[0:i+1]からm個選ぶときの最大値
memo = [{} for i in range(n)]
memo[0] = {0: 0, 1: a[0]}
memo[1] = {1: max(a[:2])}
for i in range(2, n):
m = (i + 1) // 2
memo[i][m] = max(memo[i - 1][m], memo[i - 2][m - 1] + a[i])
if i % 2 == 0:
memo[i][m + 1] = memo[i - 2][m] + a[i]
print(memo[-1][n // 2])
| 1 | 37,584,908,815,232 | null | 177 | 177 |
N, K = map(int, input().split())
As = list(map(int, input().split()))
for i in range(K):
if min(As) == N:
break
dBs = [0]*(N+1)
for i in range(N):
A = As[i]
dBs[max(0, i-A)] += 1
dBs[min(N, i+A+1)] -= 1
#print(dBs)
Bs = [dBs[0]]
for i in range(1, N):
B = Bs[i-1]+dBs[i]
Bs.append(B)
As = Bs
print(" ".join(map(str, As)))
| from collections import defaultdict as ddict
h,w,m=map(int,input().split())
xs=[0]*w
ys=[0]*h
xsmx=ysmx=0
pts=set()
for _ in range(m):
y,x=map(int,input().split())
x,y=x-1,y-1
xs[x]+=1
ys[y]+=1
pts.add((x,y))
xsmx=max(xsmx,xs[x])
ysmx=max(ysmx,ys[y])
xsc=[x for x in range(w) if xs[x]==xsmx]
ysc=[y for y in range(h) if ys[y]==ysmx]
ans=xsmx+ysmx-1
ok=False
for y in ysc:
for x in xsc:
if (x,y) not in pts:
ans+=1
ok=True
break
if ok:
break
print(ans)
| 0 | null | 10,186,697,179,680 | 132 | 89 |
n = int(input())
x = list(map(int,input().split()))
ans = 10**18
for i in range(1,101):
t = 0
for j in range(n):
t += (x[j]-i)**2
ans = min(ans,t)
print(ans) | import sys
sys.setrecursionlimit(10**5)
def DFS(i,g):
if i not in done:
done.add(i)
circle.add(i)
g_list[i]=g
for f in F[i]:
DFS(f,g)
else:
return
N,M,K=map(int,input().split())
F=[[] for _ in range(N)]
B=[[] for _ in range(N)]
for f in range(M):
f1,f2=map(int,input().split())
F[f1-1].append(f2-1)
F[f2-1].append(f1-1)
for b in range(K):
b1,b2=map(int,input().split())
B[b1-1].append(b2-1)
B[b2-1].append(b1-1)
Group=[]
circle=set()
done=set()
g_list=[0 for _ in range(N)]
g=0
for i in range(N):
if i not in done:
DFS(i,g)
Group.append(circle)
circle=set()
g+=1
ans=[-1 for _ in range(N)]
for i in range(N):
G=g_list[i]
ans[i]+=len(Group[G])
for fr in F[i]:
if fr in Group[G]:
ans[i]-=1
for bl in B[i]:
if bl in Group[G]:
ans[i]-=1
print(*ans) | 0 | null | 63,429,879,443,378 | 213 | 209 |
n=input()
print(' '.join(map(str,map(int,raw_input().split())[::-1]))) | n = input()
a = map(int, raw_input().split())
s = ""
for i in range(-1, -n, -1):
s += str(a[i]) + " "
s += str(a[-n])
print(s) | 1 | 976,416,582,596 | null | 53 | 53 |
n = int(input())
s = input()
if n % 2 == 1:
print('No')
else:
head = s[:n // 2]
tail = s[n // 2:]
if head == tail:
print('Yes')
else:
print('No')
| s = str(input())
t = str(input())
num = 0
for i in range(len(s)):
if s[i] != t[i]:
num += 1
print(num) | 0 | null | 78,407,954,533,190 | 279 | 116 |
N = int(input())
clips = [input().split() for _ in range(N)]
X = input()
ans = 0
for i,title in enumerate(clips):
if X in title:
for j in range(i+1, N):
ans += int(clips[j][1])
break
print(ans) | #!/usr/bin/env python3
import sys
from itertools import combinations as comb
from itertools import chain
import numpy as np
# form bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
def solve(H, W, K, C):
answer = 0
for hn in range(H + 1):
for wn in range(W + 1):
for h_idxs in comb(range(H), hn):
for w_idxs in comb(range(W), wn):
cs = C.copy()
cs[h_idxs, :] = 0
cs[:, w_idxs] = 0
answer += cs.sum() == K
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
H = int(next(tokens))
W = int(next(tokens))
K = int(next(tokens))
C = np.array(
[
list(map(lambda x: {"#": 1, ".": 0}[x], line))
for line in tokens
]
)
answer = solve(H, W, K, C)
print(answer)
if __name__ == "__main__":
main()
| 0 | null | 52,975,605,145,440 | 243 | 110 |
X, Y = map(int, input().split())
if (2*X-Y)%3==0 and (2*Y-X)%3==0:
a = (2*X-Y)//3
b = (2*Y-X)//3
if a>=0 and b>=0:
MOD = 10**9+7
n = a+b+1
fac = [1]*(n+1)
rev = [1]*(n+1)
for i in range(1,n+1):
fac[i] = i*fac[i-1]%MOD
rev[i] = pow(fac[i], MOD-2, MOD)
comb = lambda a,b:(fac[a]*rev[a-b]*rev[b])%MOD
print(comb(a+b, a))
else:
print(0)
else:
print(0)
| k=int(input())
line="ACL"*k
print(line) | 0 | null | 75,917,479,598,390 | 281 | 69 |
a = int(input())
A = a + a**2 + a**3
print(A) | n=int(input())
s=input()
cnt=0
def judge(n):
pos=0
pos=s.find(n[0],pos)
if pos==-1:
return 0
pos=s.find(n[1],pos+1)
if pos==-1:
return 0
pos=s.find(n[2],pos+1)
if pos==-1:
return 0
return 1
for i in range(1000):
p=str(i).rjust(3,'0')
if judge(p):
cnt+=1
print(cnt) | 0 | null | 69,542,234,615,112 | 115 | 267 |
x = list(map(int, input().split(" ")))
h1 = x[0]
m1 = x[1]
h2 = x[2]
m2 = x[3]
s = x[4]
h = (h2-h1)*60
m = m2-m1
print((h+m)-s) | n = int(input())
x = list(map(int, input().split()))
ans = 1000000
for i in range(1, 101):
s = 0
for j in range(n):
s += (x[j] - i)*(x[j] - i)
ans = min(ans, s)
print(str(ans))
| 0 | null | 41,679,737,025,092 | 139 | 213 |
from itertools import accumulate
def solve(string):
n, m, k, *ab = map(int, string.split())
a, b = [0] + ab[:n], [0] + ab[n:]
a, b = list(accumulate(a)), list(accumulate(b))
i, j = n, 0
while a[i] > k:
i -= 1
while j <= m and a[i] + b[j] <= k:
j += 1
ans = i + j - 1
for i in range(i, -1, -1):
while j <= m and a[i] + b[j] <= k:
j += 1
ans = max(ans, i + j - 1)
return str(ans)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
| N, M, K = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min = 0
cnt = 0
for k in b:
min += k
j = M
for i in range(N+1):
while(j > 0 and min > K):
j -= 1
min -= b[j]
if(min > K):
break
cnt = max(cnt, i + j)
if(i == N):
break
min += a[i]
print(cnt)
| 1 | 10,723,363,580,270 | null | 117 | 117 |
import math
A, B, N = map(int, input().split())
n = min(N, B-1)
print(math.floor(A * n / B))
| N = int(input())
deg = [0 for _ in range(N)]
edges = [[] for _ in range(N - 1)]
a = []
for i in range(N - 1):
in1, in2 = map(int, input().split())
a.append([in1, in2, i])
a = sorted(a, key = lambda x: x[0])
for i in range(N - 1):
edges[i] = [a[i][0] - 1, a[i][1] - 1, a[i][2]]
deg[a[i][0] - 1] += 1
deg[a[i][1] - 1] += 1
deg_max = max(deg)
print(deg_max)
co = [0 for _ in range(N)]
ans = [0 for _ in range(N - 1)]
for i in range(N - 1):
a = edges[i][0]
b = edges[i][1]
temp = 1 + (co[a] % deg_max)
co[a] = temp
co[b] = temp
ans[edges[i][2]] = temp
for i in range(N - 1): print(ans[i]) | 0 | null | 82,347,274,150,420 | 161 | 272 |
import numpy as np
k,n = map(int, input().split())
a = np.array(list(map(int, input().split())))
a.sort()
dif = np.diff(a, n=1)
maximum = max(dif.max(), a[0]+(k-a[-1]))
print(k-maximum) | N = list(map(int,input().split()))
print(N[0]*N[1]) | 0 | null | 29,544,138,486,730 | 186 | 133 |
w, h, x, y, r = [int(n) for n in input().split()]
if x+r > w or y+r > h or x-r < 0 or y-r < 0:
print("No")
else:
print("Yes") | import sys
(W, H, x, y, r) = [int(i) for i in sys.stdin.readline().split()]
if r <= x <= W - r and r <= y <= H - r:
print("Yes")
else:
print("No") | 1 | 457,433,993,898 | null | 41 | 41 |
n = int(input())
mod = 1000000007
def _mod(x, y):
res = 1
for i in range(y):
res = (res * x) % mod
return res
ans = _mod(10, n) - _mod(9, n) - _mod(9, n) + _mod(8, n)
ans %= mod
print(ans)
| import copy
h, w, k = map(int, input().split())
clist0 = []
result = 0
for i0 in range(h):
c = list(input())
clist0.append(c)
for i in range(2**h):
for j in range(2**w):
clist = copy.deepcopy(clist0)
for hi in range(h):
#print(i, hi)
if((i & 2**hi) == 2**hi):
#print(i, hi)
for j2 in range(w):
clist[hi][j2] = "1"
for wi in range(w):
if((j & 2**wi) == 2**wi):
for i2 in range(h):
clist[i2][wi] = "1"
temp = 0
#print(clist)
for ci in clist:
temp += ci.count("#")
if(temp == k):
result +=1
print(result) | 0 | null | 6,091,293,300,542 | 78 | 110 |
N, M = map(int, input().split())
import math
print(math.comb(N, 2)+math.comb(M, 2)) | N,M = map(int,input().split())
if N>=2:
gyu = N*(N-1)//2
else:
gyu = 0
if M>=2:
ki = M*(M-1)//2
else:
ki = 0
print(gyu+ki) | 1 | 45,561,470,972,512 | null | 189 | 189 |
n,k=map(int,input().split())
h=input()
cnt=0
for i in range(n):
if h[i]=="1":
cnt+=1
else:
cnt=0
if cnt>=k:
print(-1)
exit()
h=h[::-1]
h+="0"
idx=0
ans=[]
while 1:
if idx+k>=n:
ans.append(n-idx)
break
for i in range(k,0,-1):
if h[idx+i]=="0":
ans.append(i)
idx+=i
break
ans=reversed(ans)
print(" ".join([str(x) for x in ans]))
| n = int(input())
a = n//2 if n%2==0 else (n//2)+1
print(a) | 0 | null | 98,890,203,047,520 | 274 | 206 |
from math import tan,radians
a,b,w=map(int,input().split())
V=a**2*b
def taiseki(x,a,b):
x=90-x
if tan(radians(x))>a/b:
x=90-x
return V-(a**3*tan(radians(x)))/2
else:
return a*b**2*tan(radians(x))/2
if V==w:
print(0)
exit()
ok,ng=0,90
while ng-ok>0.00000001:
mid=(ok+ng)/2
if taiseki(mid,a,b)>=w:
ok=mid
else:
ng=mid
print(ng) |
[a,b,x] = list(map(int,input().split()))
import math
S = x/a
if S > (a*b)/2:
c = (2*S)/a - b
out = math.degrees(math.atan((b-c)/a))
else:
c = (2*S)/b
out = math.degrees(math.atan(b/c))
print(out)
| 1 | 163,188,820,012,988 | null | 289 | 289 |
n = int(input())
s = [input() for _ in range(n)]
t = ('AC', 'WA', 'TLE', 'RE')
for i in t:
print(i, 'x', s.count(i))
|
n = int(input())
s = [str(input()) for i in range(n)]
a = s.count(('AC'))
b = s.count(('WA'))
c = s.count(('TLE'))
d = s.count(('RE'))
print("AC x {}".format(a))
print("WA x {}".format(b))
print("TLE x {}".format(c))
print("RE x {}".format(d))
| 1 | 8,685,431,668,420 | null | 109 | 109 |
from collections import deque
n,k = map(int, input().split())
a = [0]+list(map(int, input().split()))
genzaiti=1
otozure=[-1]*(10**6)
hantei=True
otozure[1]=0
houmon=0
idou_kaisuu=0
while k>0:
idou_kaisuu+=1
k-=1
genzaiti=a[genzaiti]
if hantei:
if otozure[genzaiti]!=-1:
kaiten=idou_kaisuu-otozure[genzaiti]
k%=kaiten
hantei=False
otozure[genzaiti]=idou_kaisuu
print(genzaiti) | from sys import exit
N,K = map(int,input().split())
town = [None]+list(map(int,input().split()))
flag = [None]+[0]*N
remain = K
piece = 1
cnt = 1
while remain > 0:
if flag[town[piece]] != 0:
q = cnt-flag[town[piece]]
piece = town[piece]
remain -= 1
break
else:
piece = town[piece]
flag[piece] = cnt
remain -= 1
cnt += 1
if remain == 0:
print(piece)
exit(0)
remain %= q
while remain > 0:
piece = town[piece]
remain -= 1
print(piece) | 1 | 22,687,364,032,802 | null | 150 | 150 |
n = int(input())
S = input().split()
q = int(input())
T = input().split()
count = 0
for i in T:
if i in S:
count += 1
print(count) | input()
S = set(input().split())
input()
T = set(input().split())
print(len(S & T))
| 1 | 66,744,420,350 | null | 22 | 22 |
print(1 if input() == '0' else 0) | class AlgUnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n #各要素の親要素の番号を格納するリスト 要素が根（ルート）の場合は-(そのグループの要素数)を格納する
def find(self, x): #要素xが属するグループの根を返す
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y): #要素xが属するグループと要素yが属するグループとを併合する
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x): #要素xが属するグループのサイズ（要素数）を返す
return -self.parents[self.find(x)]
def same(self, x, y): #要素x, yが同じグループに属するかどうかを返す
return self.find(x) == self.find(y)
def members(self, x): #要素xが属するグループに属する要素をリストで返す
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self): #すべての根の要素をリストで返す
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self): #グループの数を返す
return len(self.roots())
def all_group_members(self): #{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
return {r: self.members(r) for r in self.roots()}
def __str__(self): #print()での表示用 ルート要素: [そのグループに含まれる要素のリスト]を文字列で返す
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
if __name__ == "__main__":
N, M = map(int, input().split())
A = [list(map(int, input().split())) for i in range(M)]
for j in range(M):
A[j][0] -= 1
A[j][1] -= 1
uf = AlgUnionFind(N)
for i in range(M):
uf.union(A[i][0], A[i][1])
count = uf.group_count() - 1
print(count)
| 0 | null | 2,609,816,598,350 | 76 | 70 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10
#solve
def solve():
x, y = LI()
d = defaultdict(int)
d[3] = 100000
d[2] = 200000
d[1] = 300000
print(d[1] * 2 + 400000 if x == y == 1 else d[x] + d[y])
return
#main
if __name__ == '__main__':
solve()
| x, y = input().split()
prizes = {'1': 300000, '2': 200000, '3': 100000}
ans = prizes.get(x, 0) + prizes.get(y, 0)
if x == y == '1':
ans += 400000
print(ans)
| 1 | 141,007,737,375,750 | null | 275 | 275 |
def dist (s1,s2):
x1=s1[0]
y1=s1[1]
x2=s2[0]
y2=s2[1]
a=(x1-x2)**2+(y1-y2)**2
return pow(a,0.5)
arr=[]
n=int(input())
for _ in range(n):
inp=list(map(int,input().split()))
arr.append((inp[0],inp[1]))
ans=0
for i in range(len(arr)):
for j in range(len(arr)):
ans+=dist(arr[i],arr[j])
print (ans/n) | n = int(input())
a = map(int, input().split())
cnt = 0
for i, v in enumerate(a):
if (i+1) % 2 == 1 and v % 2 == 1:
cnt+=1
print(cnt) | 0 | null | 78,193,943,712,596 | 280 | 105 |
lis=list(input().split())
num=list(map(int,input().split()))
num[lis.index(input())]-=1
print(str(num[0])+" "+str(num[1]))
| def main():
s, t = input().split()
a, b = map(int, input().split())
u = input()
if u == s:
a -= 1
else:
b -= 1
print(a, b)
if __name__ == '__main__':
main() | 1 | 71,635,833,324,604 | null | 220 | 220 |
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N):
alp = 'abcdefghijklmnopqrstuvwxyz'
number27 = []
cnt = 26
digit = 1
while N > 0:
if N <= cnt:
break
else:
N -= cnt
cnt *= 26
digit += 1
ans = list('a' * digit)
N -= 1
tmp = -1
while N > 0:
N, mod = divmod(N, 26)
ans[tmp] = alp[mod]
tmp -= 1
print(''.join(ans))
if __name__ == '__main__':
# S = input()
N = int(input())
# N, M = map(int, input().split())
# As = [int(i) for i in input().split()]
# Bs = [int(i) for i in input().split()]
solve(N)
# for i in range(1, 100):
# # print(i)
# solve(i)
| import sys
input = sys.stdin.readline
def main():
N = int(input())
ans = ''
while N > 0:
N -= 1
ans += chr(ord('a') + N % 26)
N = N // 26
print(ans[::-1])
main() | 1 | 11,973,880,550,240 | null | 121 | 121 |
N,K = map(int,input().split())
gcddic = {}
mod_n = (10**9+7)
for i in range(K,0,-1):
x = pow((K//i),N,mod_n)
ll=2
while(ll*i<=K):
x -= gcddic[ll*(i)]
ll += 1
gcddic[i] = x
sumnation = 0
for i,l in gcddic.items():
sumnation += i*l
print(sumnation%mod_n) | mod =10**9+7
n=int(input())
if n<2:exit(print(0))
elif n==2:exit(print(2))
ans = 10**n - 9**n*2 + 8**n
ans%=mod
print(ans) | 0 | null | 19,955,716,137,098 | 176 | 78 |
K = int(input())
def check(k):
aaa = 0
prev = 7%k
for i in range(0,k):
aaa+=1
if prev == 0:
return(aaa)
prev = (prev*10+7)%k
return(-1)
print(check(K)) | k=int(input())
num=7
i=1
while True:
if k%2==0 or k%5==0:
i=-1
break
num%=k
if num==0:
break
else:
num*=10
num+=7
i+=1
print(i) | 1 | 6,131,574,812,668 | null | 97 | 97 |
n, k = map(int, input().split())
tmp = n%k
print(min(tmp, abs(tmp-k))) | # -*-coding:utf-8
import fileinput
import math
def main():
offiHouse = [[[0 for i3 in range(10)] for i2 in range(3)] for i1 in range(4)] #y, x, z
n = int(input())
for i in range(n):
a, b, c, d = map(int, input().split())
offiHouse[a-1][b-1][c-1] += d
for i in range(4):
for j in range(3):
for k in range(10):
print('', offiHouse[i][j][k], end='')
print()
if(i != 3):
print('#' * 20)
if __name__ == '__main__':
main() | 0 | null | 20,171,416,670,192 | 180 | 55 |
A, B = map(int, input().split())
ans = 0
for i in range(B):
ans += A
if ans%B == 0:
break
print(ans) | inp = [int(input()) for i in range(10)]
m1, m2, m3 = 0, 0, 0
for h in inp:
if(h > m1):
m3 = m2
m2 = m1
m1 = h
elif(h > m2):
m3 = m2
m2 = h
elif(h > m3):
m3 = h
print(m1)
print(m2)
print(m3) | 0 | null | 57,004,396,826,160 | 256 | 2 |
from sys import stdin
input = stdin.readline
def main():
H, N = list(map(int, input().split()))
A = [0]*N
B = [0]*N
for i in range(N):
A[i], B[i] = map(int, input().split())
# dp = [[0]*(H+1) for _ in range(N+1)]
dp = [0]*(H+1)
for j in range(H+1):
dp[j] = float('inf')
dp[0] = 0
for i in range(1, N+1):
for j in range(1, H+1):
# dp[i][j] = dp[i-1][j]
if j > A[i-1]:
dp[j] = min(dp[j], dp[j-A[i-1]]+B[i-1])
else:
dp[j] = min(dp[j], B[i-1])
# for i in range(N+1):
# print(dp[i])
print(dp[H])
if(__name__ == '__main__'):
main() |
def resolve():
INF = 1<<60
H, N = map(int, input().split())
A, B = [], []
for i in range(N):
a, b = map(int, input().split())
A.append(a)
B.append(b)
dp = [INF]*(H+1)
dp[0] = 0
for h in range(H):
for i in range(N):
to = min(H, A[i]+h)
dp[to] = min(dp[to], dp[h]+B[i])
print(dp[H])
if __name__ == "__main__":
resolve()
| 1 | 81,511,058,314,730 | null | 229 | 229 |
x = input()
print pow(x, 3) | #
# panasonic2020b d
#
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """1"""
output = """a"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2"""
output = """aa
ab"""
self.assertIO(input, output)
def resolve():
global N
N = int(input())
T = []
func("a", "a", T)
for t in T:
print(t)
def func(mw, s, T):
if len(s) == N:
T.append(s)
return
for i in range(ord(mw)-ord("a")+2):
mw = max(mw, chr(ord("a")+i))
ns = s + chr(ord("a")+i)
func(mw, ns, T)
if __name__ == "__main__":
# unittest.main()
resolve()
| 0 | null | 26,501,377,777,788 | 35 | 198 |
import sys
def main():
input = sys.stdin.buffer.readline
n = int(input())
ab = [map(int, input().split()) for _ in range(n)]
a, b = [list(i) for i in zip(*ab)]
new_a = sorted(a)
new_b = sorted(b)
if n % 2 == 1:
min_m = new_a[(n + 1) // 2 - 1]
max_m = new_b[(n + 1) // 2 - 1]
print((max_m - min_m) + 1)
else:
min_m = (new_a[n // 2 - 1] + new_a[n // 2])
max_m = (new_b[n // 2 - 1] + new_b[n // 2])
print((max_m - min_m) + 1)
if __name__ == '__main__':
main()
| n = int(input())
al = []
bl = []
for i in range(n):
a,b = [int(i) for i in input().split()]
al.append(a)
bl.append(b)
al = sorted(al)
bl = sorted(bl)
median_a = al[n//2]if n % 2 else (al[n // 2] + al[n//2 - 1]) / 2
median_b = bl[n//2]if n % 2 else (bl[n // 2] + bl[n//2 - 1]) / 2
if n % 2:
print(int((median_b - median_a + 1)))
else:
print(int((median_b - median_a) * 2 + 1)) | 1 | 17,189,952,392,160 | null | 137 | 137 |
import sys
# input = sys.stdin.readline
def main():
S, T =input().split()
print(T,S,sep="")
if __name__ == "__main__":
main() | S,T = input().split()
T+=S
print(T) | 1 | 102,609,369,997,068 | null | 248 | 248 |
import numpy as np
from numba import njit
(N, K) = map(int, input().split())
A = np.array(list(map(int, input().split())))
@njit
def solve(N,K,A):
for j in range(0, K):
B = np.zeros(N, dtype=np.int64)
for i in range(0,N):
f = max(0, i - A[i])
t = min(N-1, i + A[i])
#for j in range(max(0, f), min(N, t)+1):
# B[j] += 1
B[f] += 1
if t+1 < N:
B[t+1] -= 1
A = np.cumsum(B)
if np.all(A == N):
return A
i += 1
return A
print(" ".join(map(str, solve(N,K,A)))) | n,k=map(int,input().split())
a=list(map(int,input().split()))
c=[n for i in range(n)]
for j in range(k):
d=[0 for i in range(n+1)]
for i in range(n):
d[max(i-a[i],0)]+=1
d[min(i+a[i]+1,n)]-=1
e=[d[0]]
for i in range(n-1):#ちょっと特殊な累積和 普通のものの[1:-1]
e.append(e[i]+d[i+1])
#print(d,e,sep='\n')
#print(e)
a=e
if e==c:
break
print(*a)
| 1 | 15,345,538,688,034 | null | 132 | 132 |
X,Y,Z=map(int,input().split(" "))
tmp=Y
Y=X
X=tmp
tmp=Z
Z=X
X=tmp
print(X,Y,Z,end=" ") | def max_profit(A, n):
minv = A[0]
for j in range(1, n):
if j == 1:
maxv = A[j] - A[j-1]
if maxv < A[j] - minv:
maxv = A[j] - minv
if minv > A[j]:
minv = A[j]
print(maxv)
n=int(input())
A=[int(input()) for i in range(n)]
max_profit(A, n)
| 0 | null | 19,102,532,273,188 | 178 | 13 |
def q_d():
n = int(input())
a = list(map(int, input().split()))
break_num = 0
current_index = 1
for i in range(n):
if a[i] == current_index:
current_index += 1
else:
break_num += 1
if break_num == n:
print(-1)
else:
print(break_num)
if __name__ == '__main__':
q_d()
| import sys
n = int(input())
a = list(map(int,input().split()))
ans = 0
if 1 not in a:
print(-1)
sys.exit()
index = 1
for i in a:
if i != index:
ans+=1
else:
index+=1
print(ans)
| 1 | 114,775,430,420,128 | null | 257 | 257 |
from collections import defaultdict
H, W, M = list(map(int, input().split()))
hw = [list(map(int, input().split())) for _ in range(M)]
d1 = defaultdict(int)
d2 = defaultdict(int)
b = defaultdict(int)
for h, w in hw:
d1[h] += 1
d2[w] += 1
b[(h, w)] = 1
m1 = max(d1.values())
m2 = max(d2.values())
e1 = [k for k in d1.keys() if d1[k] == m1]
e2 = [k for k in d2.keys() if d2[k] == m2]
flag = True
for x in e1:
for y in e2:
if b[(x, y)] == 1:
pass
else:
flag = False
break
if not flag:
break
if flag:
print(m1+m2-1)
else:
print(m1+m2) | def main():
h, w, m = map(int, input().split())
hp = [0]*h
wp = [0]*w
hw = set()
for _ in range(m):
h1, w1 = map(int, input().split())
hp[h1-1] += 1
wp[w1-1] += 1
hw.add((h1, w1))
h_max = max(hp)
w_max = max(wp)
hh = [i+1 for i, v in enumerate(hp) if v == h_max]
ww = [i+1 for i, v in enumerate(wp) if v == w_max]
ans = h_max + w_max
for hb in hh:
for wb in ww:
if (hb, wb) not in hw:
print(ans)
exit()
print(ans-1)
if __name__ == '__main__':
main() | 1 | 4,677,205,494,480 | null | 89 | 89 |
ans = [0 for _ in range(10001)]
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
w = x*x + y*y + z*z + x*y + y*z + z*x
if w <= 10000:
ans[w] += 1
print(*ans[1:int(input())+1], sep="\n") | import math
N = int(input())
#f(n) を以下の 2 つの条件の両方を満たすような 3 つの整数の組 (x,y,z)の個数とします。
# 1≤x,y,z
# x**2 + y**2 + z**2 + xy + yz + zx = n
# x,y,zの最大値を考える。
# x**2 + 1**2 + 1**2 + x + 1 + x = n
# x**2 + 2x = n - 3
# x**2 + 2x -n + 3 = 0
# x = {-2 ± sqrt(2**2 - 4*1*(-n+3))}/2*1
# x = {-2 ± sqrt(4 + 4n -12)}/2
# 1 ≤ xより
# x = {-2 + sqrt(4n - 8)}/2 = {-2 + 2 * sqrt(n - 2)}/2 = -1 + sqrt(n - 2)
# ∴ 1 ≤ x ≤ math.floor(-1 + sqrt(n - 2))
# y,zも同様。
# N <= 10**4 より、x,y,xで全探索しても(10**2)**3 = 10**6 で間に合う
ans_dict = {i:set() for i in range(1,N+1)}
if N != 1:
for i in range(1,1 + math.floor(-1 + math.sqrt(N - 2))):
for j in range(1,1 + math.floor(-1 + math.sqrt(N - 2))):
for k in range(1,1 + math.floor(-1 + math.sqrt(N - 2))):
n = i**2 + j**2 + k**2 + i*j + j*k + k*i
if 1 <= n <= N:
ans_dict[n].add((i,j,k))
for i in range(1,N+1):
print(len(ans_dict[i]))
else:
print(0) | 1 | 7,969,784,999,552 | null | 106 | 106 |
N = int(input())
s = []
t = []
for i in range(N) :
p, q = input().split()
s.append(p)
t.append(int(q))
X = input()
xi = s.index(X)
ans = 0
for i in range(xi+1, N) :
ans += t[i]
print(ans)
| N = int(input())
music = []
for i in range(N):
music.append(input().split())
X = (input())
Time = 0
kama = False
for s,t in music:
if kama:
Time += int(t)
if s == X:
kama = True
print(Time) | 1 | 97,098,460,137,602 | null | 243 | 243 |
X,N = map(int, input().split())
P = list(map(int, input().split()))
table = [0] * 102
ans = X
dist = 102
for p in P:
table[p] = 1
for i in range(102):
if table[i] != 0:
continue
if abs(i - X) < dist:
ans = i
dist = abs(i - X)
elif abs(i - X) == dist:
ans = min(i, ans)
print(str(ans)) | a, b, c = map(int, input().split())
divisors = []
i = 1
while(i * i < c):
if(c % i == 0):
divisors.append(i)
divisors.append(c // i)
i += 1
if(i * i == c):
divisors.append(i)
ans = 0
for i in range(len(divisors)):
if(a <= divisors[i] <= b):
ans += 1
print(ans) | 0 | null | 7,328,427,803,168 | 128 | 44 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.