code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,629B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
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())
lst_1=list(map(int,input().split()))
# print(lst_1)
for i in range(n-k):
if(lst_1[i+k]>lst_1[i]):
print("Yes")
else:print("No")
| 1 | 7,082,920,201,630 | null | 102 | 102 |
hon=[2,4,5,7,9]
pon=[0,1,6,8]
bon=[3]
N=int(input())
if N%10 in hon:
print('hon')
elif N%10 in pon:
print('pon')
else:
print('bon')
|
#a=list(map(int,input().split()))
a=[]
for i in range(10):
tmp = int(input())
a.append(tmp)
b=sorted(a, reverse=True)
print(b[0])
print(b[1])
print(b[2])
| 0 | null | 9,542,977,316,054 | 142 | 2 |
from collections import defaultdict
d=defaultdict(int)
N,K=map(int,input().split())
A=[0]+list(map(int,input().split()))
S=[None]*(N+1)
S[0]=0
cnt=0
d[0]=1
for i in range(1,N+1):
S[i]=(S[i-1]+A[i]-1)%K
for i in range(1,N+1):
if i-K>=0:
d[S[i-K]]-=1
cnt+=d[S[i]]
d[S[i]]+=1
print(cnt)
|
X = int(input())
def is_Prime(x):
for i in range(2, x+1):
if i * i + 1 > x:
return True
if x % i == 0:
return False
for i in range(X, 2*X+1):
if is_Prime(i):
print(i)
break
| 0 | null | 121,420,163,353,628 | 273 | 250 |
H = int(input())
i=0
count=0
while(H>0):
H=H//2
count += 2**i
i+=1
print(count)
|
t = int(input(''))
s = t % 60
h = t // (60 * 60)
m = (t % 3600) // 60
print(str(h) + ":" + str(m) + ":" + str(s))
| 0 | null | 40,154,392,265,300 | 228 | 37 |
K = int(input())
def gcd(a,b):
if a % b == 0:
return b
return gcd(b, a%b)
dec = {}
for a in range(1,K+1):
for b in range(1, K+1):
if gcd(a,b) not in dec:
dec[gcd(a,b)] = 1
else:
dec[gcd(a,b)] += 1
ans = 0
for c in range(1, K+1):
for key in dec.keys():
ans += gcd(c, key)*dec[key]
print(ans)
|
import math
k = int(input())
sum = 0
for a in range(1,k+1):
for b in range(1,k+1):
x = math.gcd(a, b)
for c in range(1,k+1):
sum += math.gcd(x, c)
print(sum)
| 1 | 35,438,980,684,772 | null | 174 | 174 |
h,w,k=map(int,input().split())
c=list(list(input()) for _ in range(h))
ans=0
for n in range(2**(h+w)):
l={}
o={}
x=0
for m in range(h+w):
if (n>>m)&1:
if m>=h:
o[m-h]=1
else:
l[m]=1
for i in range(h):
if not i in l:
for j in range(w):
if not j in o:
if c[i][j]=="#":
x+=1
if x==k:
ans+=1
print(ans)
|
import copy
H, W, K = list(map(int, input().split()))
c = [0]*H
for i in range(H):
char = input()
c[i] = []
for j in range(W):
if char[j] == "#":
c[i].append(1)
else:
c[i].append(0)
count = 0
for i in range(2**H):
for j in range(2**W):
d = copy.deepcopy(c)
i2 = i
j2 = j
for k in range(H):
if i2 & 1:
d[k] = [0]*W
i2 >>= 1
for l in range(W):
if j2 & 1:
for m in range(H):
d[m][l] = 0
j2 >>= 1
s = sum(map(sum, d))
if s == K:
count += 1
print(count)
| 1 | 8,847,750,037,248 | null | 110 | 110 |
K,N=map(int,input().split())
A=[int(i) for i in input().split()]
dlist=[]
for i in range(1,N):
d=A[i]-A[i-1]
dlist.append(d)
dlist.append(A[0]+K-A[N-1])
print(K-max(dlist))
|
K, N = map(int, input().split())
Alst = list(map(int, input().split()))
zero = Alst[0] + K
M = 0
now = Alst[0]
for i in Alst:
dis = i - now
if dis > M:
M = dis
now = i
last = zero - now
if last > M:
M = last
print(K - M)
| 1 | 43,348,989,080,410 | null | 186 | 186 |
def a_painting():
from math import ceil
H = int(input())
W = int(input())
N = int(input())
return ceil(N / max(H, W))
print(a_painting())
|
n=int(input())
a=list(map(int,input().split()))
b=[(v,s) for s,v in enumerate(a)]
b.sort(reverse=True)
dp=[[0 for i in range(n+1)] for i in range(n+1)]
for i in range(n+1):
for j in range(n+1-i):
if i+j==0:
continue
v=b[i+j-1][0]
pos=b[i+j-1][1]
if i==0:
dp[0][j]=dp[0][j-1]+v*abs(n-j-pos)
elif j==0:
dp[i][0]=dp[i-1][0]+v*abs(i-1-pos)
else:
dp[i][j]=max(dp[i-1][j]+v*abs(i-1-pos),dp[i][j-1]+v*abs(n-j-pos))
ans=0
for i in range(n):
happy=dp[i][n-i]
if happy>ans:
ans=happy
print(ans)
| 0 | null | 61,314,052,288,798 | 236 | 171 |
S = int(raw_input())
print '%d:%d:%d' %(S/3600,(S/60)%60,S%60)
|
sec_in = int(input())
hour = sec_in // 3600
minute = (sec_in % 3600) // 60
sec = sec_in % 60
print('{0}:{1}:{2}'.format(hour,minute,sec))
| 1 | 326,236,992,788 | null | 37 | 37 |
integers=[]
i=0
j=0
while True:
num=int(input())
integers.append(num)
if integers[i]==0:
del integers[i]
break
i+=1
while j<i:
print('Case {}: {}'.format(j+1,integers[j]))
j+=1
|
# C - Go to School
N = int(input())
A = list(map(int,input().split()))
A = [(i+1,A[i]) for i in range(N)]
A.sort(key=lambda x:x[1])
A = [str(a[0]) for a in A]
print(' '.join(A))
| 0 | null | 90,591,065,013,030 | 42 | 299 |
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)
|
import numpy as np
from numba import njit, i8
@njit(i8[:](i8, i8, i8[:]), cache=True)
def myfunc(n, k, A):
for _ in range(k):
l = np.zeros((n + 1,), dtype=np.int64)
for i, a in enumerate(A[:-1]):
l[max(0, i - a)] += 1
l[min(n, i + a + 1)] -= 1
A = np.cumsum(l)
if np.all(A[:-1] == n):
break
return A
def main():
n, k = map(int, input().split())
A = np.array(list(map(int, input().split())), dtype=np.int64)
A = np.append(A, 0)
print(*myfunc(n, k, A)[:-1])
if __name__ == "__main__":
main()
| 1 | 15,407,677,823,500 | null | 132 | 132 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
X=int(input())
if X>=1800:
print(1)
elif X>=1600:
print(2)
elif X>=1400:
print(3)
elif X>=1200:
print(4)
elif X>=1000:
print(5)
elif X>=800:
print(6)
elif X>=600:
print(7)
elif X>=400:
print(8)
|
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,776,365,778,322 | null | 100 | 100 |
l = []
while True:
a,op,b = input().split()
if op == '?':
break
A = int(a)
B = int(b)
if op == '+':
l.append(A+B)
elif op == '-':
l.append(A-B)
elif op == '*':
l.append(A*B)
elif op == '/':
l.append(A//B)
for i in l:
print(i)
|
while True:
a, b, c = input().split()
a = int(a)
c = int(c)
if b == "?":
break
if b == "+":
print(a + c)
if b == "-":
print(a - c)
if b == "*":
print(a * c)
if b == "/":
print(a // c)
| 1 | 676,948,435,962 | null | 47 | 47 |
a,b=map(int,input().split())
print(a*b if a>=1 and a<=9 and 0<b<10 else -1)
|
n = int(input())
num = [input() for _ in range(n)]
print(len(set(num)))
| 0 | null | 94,558,623,727,502 | 286 | 165 |
a,b=map(int,input().split())
print("%d %d %0.5f"%(a/b,a%b,a/b))
|
l=raw_input()
k=l.split()
a=0.0
b=0.0
a=int(k[0])
b=int(k[1])
#
print int((a-(a%b))/b),
print int(a%b),
a*=1.0
b*=1.0
if b==1:
print a*1.0
else:
if a/b>0.0000002:
print a/b
else: print "0.00000001.99999982"
| 1 | 598,338,281,728 | null | 45 | 45 |
while True:
s = input().split()
a = int(s[0])
op = s[1]
b = int(s[2])
if op == "?":
break
if op == "+":
print(a+b)
if op == "-":
print(a-b)
if op == "*":
print(a*b)
if op == "/":
print(a//b)
|
while True:
exp = input()
if '?' in exp: break
print('%d' % (int(eval(exp))))
| 1 | 704,988,739,952 | null | 47 | 47 |
print 'win' if sum(map(int, raw_input().split(' '))) <= 21 else 'bust'
|
#!/usr/bin/env python3
def main():
A1, A2, A3 = map(int, input().split())
A=A1+A2+A3
if A >=22:
ans='bust'
else:
ans='win'
print(ans)
if __name__ == "__main__":
main()
| 1 | 118,889,916,290,180 | null | 260 | 260 |
l = map(int,raw_input().split())
if l[0] < l[1] < l[2]:
print 'Yes'
else:
print 'No'
|
from collections import defaultdict
N, *A = map(int, open(0).read().split())
ctr1 = defaultdict(int)
ctr2 = defaultdict(int)
for i in range(N):
ctr2[i + A[i]] += 1
if i - A[i] > 0:
ctr1[i - A[i]] += 1
ans = 0
for v in ctr1:
ans += ctr1[v] * ctr2[v]
print(ans)
| 0 | null | 13,258,299,572,256 | 39 | 157 |
N,K,C=list(map(int,input().split()))
S=input()
R=[]
L=[]
i=0
while i<N:
if S[i]=="o":
R.append(i)
i+=C+1
else:
i+=1
i=N-1
while i>=0:
if S[i]=="o":
L.append(i)
i-=(C+1)
else:
i-=1
R=R[:K+1]
L=L[:K+1]
L.reverse()
for i in range(K):
if R[i]==L[i]:
print(str(R[i]+1),end=" ")
|
import sys
input = sys.stdin.readline
n = int(input())
num = list(map(int, input().split()))
mod = 10**9+7
num = tuple(num)
def gcd(a, b):
while b: a, b = b, a % b
return a
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
lcd = dict()
for i in num:
j = primeFactor(i)
for x,y in j.items():
if not x in lcd.keys():
lcd[x] = y
else:
lcd[x] = max(lcd[x],y)
lc = 1
for i,j in lcd.items():
lc *= pow(i,j,mod)
ans =0
for i in range(n):
ans += lc*pow(num[i], mod-2, mod)
ans %= mod
print(ans)
| 0 | null | 63,892,335,284,804 | 182 | 235 |
from math import pi as pi
N=int(input().rstrip())
print(float(2.00*pi*N))
|
a,b=map(int,raw_input().split())
print a/b,a%b,"%.6f"%(1.*a/b)
| 0 | null | 15,923,479,445,670 | 167 | 45 |
n = int(input())
lst = [ int(i) for i in input().split() ]
visited = {}
for d in lst:
if d in visited.keys():
visited[d] += 1
else:
visited[d] = 1
count = 0
for d in visited.keys():
count += int(visited[d]*(visited[d]-1)/2)
for d in lst:
v = visited[d] - 1
ans = count - v
print(ans)
|
N= int(input())
a = [0]*110000
if N == 2:
print(2)
else:
for i in range(2,N):
k = i
j = 2
while k<110000:
a[k]+=1
k = int((k/(j-1))*j)
j+=1
for i in range(N,110001):
if a[i]>0:
continue
elif a[i]==0:
print(i)
break
| 0 | null | 76,506,341,852,576 | 192 | 250 |
cin = open(0).read().strip().split('\n')
n = int(cin[0])
g = [list(map(lambda x: int(x)-1, a.split(' ')[2:])) for a in cin[1:]]
first_order = [-1] * n
last_order = [-1] * n
ptr = 1
def dfs(g, seen, idx):
global first_order, first_order, ptr
first_order[idx] = ptr
ptr += 1
seen[idx] = True
for i in g[idx]:
# idxから行ける各頂点について
if seen[i]: continue
dfs(g, seen, i)
last_order[idx] = ptr
ptr += 1
seen = [False] * n
dfs(g, seen, 0)
# 孤立している頂点対策
for i in range(n):
if not seen[i]:
ans = dfs(g, seen, i)
# 出力
for idx, (f, l) in enumerate(zip(first_order, last_order)):
print(idx+1, f, l)
|
def dfs(v, cnt):
D[v] = cnt
cnt += 1
for c in edge[v]:
if D[c] == -1:
cnt = dfs(c, cnt)
F[v] = cnt
cnt += 1
return cnt
V = int(input())
edge = [[] for _ in range(V)]
for _ in range(V):
u, _, *v = map(lambda x: int(x)-1, input().split())
edge[u] = sorted(v)
D, F = [-1] * V, [-1] * V
c = 1
for i in range(V):
if D[i] == -1:
c = dfs(i, c)
for i, (d, f) in enumerate(zip(D, F)):
print(i+1, d, f)
| 1 | 2,644,487,710 | null | 8 | 8 |
h, w, k = list(map(int, input().split()))
m = [list(input()) for _ in range(h)]
ans = 0
for bh in range(1 << h):
for bw in range(1 << w):
B = 0
for H in range(h):
for W in range(w):
if ((bh >> H) & 1) == 0 and ((bw >> W) & 1) == 0 and m[H][W] == "#":
B += 1
if B == k:
ans += 1
print(ans)
|
N, K, C = map(int, input().split())
S = input()
L = []
R = []
count_L = C
count_R = C
for i in range(N):
if S[i] == "o" and count_L >= C:
count_L = 0
L.append(i)
else:
count_L += 1
if S[N-i-1] == "o" and count_R >= C:
count_R = 0
R.append(N-i-1)
else:
count_R += 1
if len(L) >= K and len(R) >= K:
break
for l, r in zip(L, R[::-1]):
if l == r:
print(l+1)
| 0 | null | 24,696,057,037,630 | 110 | 182 |
n = int(input())
xy = [list(map(int, input().split())) for _ in range(n)]
xy.sort(key=lambda x: x[0] + x[1])
mn1, mx1 = xy[0], xy[-1]
xy.sort(key=lambda x: x[0] - x[1])
mn2, mx2 = xy[0], xy[-1]
li = [mn1, mx1, mn2, mx2]
ans = 0
for x1, y1 in li:
for x2, y2 in li:
dist = abs(x1 - x2) + abs(y1 - y2)
ans = max(ans, dist)
print(ans)
|
# -*- coding: utf-8 -*-
N=int(input())
x,y=map(int,input().split())
R=x
L=x
U=y
B=y
P=[(x,y)]
for i in range(1,N):
x,y=map(int,input().split())
P.append((x,y))
if R<x:R=x
if L>x:L=x
if U<y:U=y
if B>y:B=y
p=P[0]
UR=p
dUR=abs(R-p[0])+abs(U-p[1])
UL=p
dUL=abs(L-p[0])+abs(U-p[1])
BR=p
dBR=abs(R-p[0])+abs(B-p[1])
BL=p
dBL=abs(L-p[0])+abs(B-p[1])
for p in P[1:]:
if dUR>abs(R-p[0])+abs(U-p[1]):
UR=p
dUR=abs(R-p[0])+abs(U-p[1])
if dUL>abs(L-p[0])+abs(U-p[1]):
UL=p
dUL=abs(L-p[0])+abs(U-p[1])
if dBR>abs(R-p[0])+abs(B-p[1]):
BR=p
dBR=abs(R-p[0])+abs(B-p[1])
if dBL>abs(L-p[0])+abs(B-p[1]):
BL=p
dBL=abs(L-p[0])+abs(B-p[1])
ans=abs(UR[0]-BL[0])+abs(UR[1]-BL[1])
ans2=abs(UL[0]-BR[0])+abs(UL[1]-BR[1])
if ans2>ans: ans=ans2
print(ans)
| 1 | 3,369,480,500,782 | null | 80 | 80 |
# 169 B
N = int(input())
A = list(map(int, input().split()))
A.sort()
ans = 1
for i in range(N):
ans *= A[i]
if ans > 10**18:
print(-1)
break
else:
print(ans)
|
in_num = list(map(int, input().split()))
print(in_num.index(0)+1)
| 0 | null | 14,650,533,375,270 | 134 | 126 |
input_str = input().split()
amount_to_make = int(input_str[0])
lot_size = int(input_str[1])
time_to_make_one_lot = int(input_str[2])
proceeded_time = 0
made_amount = 0
while made_amount < amount_to_make:
made_amount += lot_size
proceeded_time += time_to_make_one_lot
print(proceeded_time)
|
import math
import numpy as np
import numba
from numba import njit, b1, i4, i8, f8
from numba import jit
import collections
import bisect
from collections import deque
from copy import copy, deepcopy
import time
def main():
N,X,T = map(int,input().split())
print(math.ceil(N/X) * T)
if __name__ == '__main__':
main()
| 1 | 4,273,045,058,162 | null | 86 | 86 |
val = int(input())
print(val * val * val)
|
ri = lambda S: [int(v) for v in S.split()]
def rii(): return ri(input())
a, b = rii()
print(min(str(a) * b, str(b) * a))
| 0 | null | 42,231,537,431,326 | 35 | 232 |
def selection_sort(a,n):
count=0
for i in range(n):
ch=False
minj=i
for j in range(i,n):
if a[j] < a[minj]:
minj = j
ch = True
if(ch):
count+=1
a[i],a[minj] = a[minj],a[i]
return count
if __name__ == "__main__":
n=int(input())
a=list(map(int,input().split()))
count=selection_sort(a,n)
print(*a)
print(count)
|
N=int(input())
A=list(map(int,input().split()))
p=round(sum(A)/N)
print(sum(map(lambda x: (x-p)**2, A)))
| 0 | null | 32,677,478,505,980 | 15 | 213 |
def main():
N, S = map(int, input().split())
A = tuple(map(int, input().split()))
MOD = 998244353
dp = [[0]*(S+1) for _ in range(N+1)]
dp[0][0] = 1
# morau
for i, a in enumerate(A):
dp[i][0] = pow(2, i, MOD)
for j in range(S+1):
if j >= a:
dp[i+1][j] = 2 * dp[i][j]
dp[i+1][j] %= MOD
dp[i+1][j] += dp[i][j-a]
dp[i+1][j] %= MOD
else:
dp[i+1][j] = 2 * dp[i][j]
dp[i+1][j] %= MOD
print(dp[N][S])
if __name__ == "__main__":
main()
|
def imas(hoge_l, p, track):
s_weights = 0
now_track = 1
for val in hoge_l:
s_weights += val
if s_weights > p:
s_weights = val
now_track += 1
if now_track > track:
return False
return True
num, track = [int(x) for x in input().split()]
hoge_l = list()
for _ in range(num):
hoge_l.append(int(input()))
left = 0
right = 100000 * 10000
while left < right :
mid = (right + left) // 2
if imas(hoge_l, mid, track):
right = mid
else:
left = mid + 1
max_num = max(hoge_l)
if max_num > right:
right = max_num
print (right)
| 0 | null | 8,904,540,988,568 | 138 | 24 |
word = input()
if word == "ABC":
print("ARC")
else:
print("ABC")
|
n = int(input())
if n/1.08==n//1.08:
print(n//1.08)
elif int(-(-n//1.08) * 1.08) == n:
print(int(-(-n//1.08)))
else:
print(':(')
| 0 | null | 75,196,375,907,702 | 153 | 265 |
import sys
input = sys.stdin.readline
N = int(input())
op = []
ed = []
mid = [0]
dg = 10**7
for _ in range(N):
s = list(input())
n = len(s)-1
a,b,st = 0,0,0
for e in s:
if e == '(':
st += 1
elif e == ')':
if st > 0:
st -= 1
else:
a += 1
st = 0
for i in range(n-1,-1,-1):
if s[i] == ')':
st += 1
else:
if st > 0:
st -= 1
else:
b += 1
if a > b:
ed.append(b*dg + a)
elif a == b:
mid.append(a)
else:
op.append(a*dg + b)
op.sort()
ed.sort()
p = 0
for e in op:
a,b = divmod(e,dg)
if p < a:
print('No')
exit()
p += b-a
q = 0
for e in ed:
b,a = divmod(e,dg)
if q < b:
print('No')
exit()
q += a-b
if p == q and p >= max(mid):
print('Yes')
else:
print('No')
|
s2 = list(input()*2)
p = list(input())
for i in range(len(s2)-len(p)):
a = [ s2[i+j] for j in range(len(p))]
if a == p:
print("Yes")
break
else:
print("No")
| 0 | null | 12,638,833,050,688 | 152 | 64 |
n = int(input())
s = input()
ans=[]
for i in s:
a = chr(ord('A')+(ord(i)-ord('A')+n)%26)
ans.append(a)
print(('').join(ans))
|
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if a == b:
print("NO")
As = v * t + a
Bs = w * t + b
if v > w:
if abs(a - b)/abs(v - w) <= t:
print("YES")
else:
print("NO")
else:
print("NO")
| 0 | null | 74,569,662,665,190 | 271 | 131 |
k=int(input())
n=len(input())
mod=10**9+7
def prepare(m, mod=10 ** 9 + 7):
fac = [1] * (m + 1)
inv = [1] * (m + 1)
for i in range(1, m + 1):
fac[i] = fac[i - 1] * i % mod
inv[-1] = pow(fac[-1], mod - 2, mod)
for i in range(m - 1, -1, -1):
inv[i] = inv[i + 1] * (i + 1) % mod
return fac, inv
fac, inv = prepare(n+k)
def cmb(n, r):
assert n >= r >= 0
return fac[n] * inv[n - r] * inv[r] % mod
ans=0
for i in range(0,k+1):
ans+=pow(25,k-i,mod)*pow(26,i,mod)%mod*cmb(n+k-i-1,k-i)%mod
ans%=mod
print(ans)
|
K=int(input())
L=len(input())
from numba import*
@njit(cache=1)
def f():
m=10**9+7
max_n=2*10**6
fac=[1]*(max_n+1)
inv=[1]*(max_n+1)
ifac=[1]*(max_n+1)
for n in range(2,max_n+1):
fac[n]=(fac[n-1]*n)%m
inv[n]=m-inv[m%n]*(m//n)%m
ifac[n]=(ifac[n-1]*inv[n])%m
d=[1]*(K+1)
d2=[1]*(K+1)
for i in range(K):
d[i+1]=d[i]*25%m
d2[i+1]=d2[i]*26%m
a=0
for i in range(K+1):
a=(a+fac[L+i-1]*ifac[i]%m*ifac[L-1]%m*d[i]%m*d2[K-i]%m)%m
return a
print(f())
| 1 | 12,786,860,180,480 | null | 124 | 124 |
from collections import deque
n, d, a = map(int, input().split())
XH = [list(map(int, input().split())) for _ in range(n)]
XH.sort()
# X:座標、 C:倒すための必要爆発回数
XC = [[x, (h - 1) // a + 1] for x, h in XH]
q = deque([])
accum_dmg = 0
ans = 0
for x, c in XC:
# q[-][0]は爆発が届く右端の座標
# 爆発が届いていない地点に来たら累積ダメージを減らす
while q and x > q[0][0]:
_, dmg = q.popleft()
accum_dmg -= dmg
cnt = max(0, c - accum_dmg)
ans += cnt
accum_dmg += cnt
if cnt:
q.append([x + 2 * d, cnt])
print(ans)
|
import sys
def input():
return sys.stdin.readline().strip()
n, d, a = map(int, input().split())
x = []
h = {} # x:h
for _ in range(n):
i, j = map(int, input().split())
x.append(i)
h[i] = j
x.sort()
x.append(x[-1] + 2*d + 1)
# attackで累積和を用いる
ans = 0
attack = [0 for _ in range(n+1)]
for i in range(n):
attack[i] += attack[i-1]
if attack[i] >= h[x[i]]:
continue
if (h[x[i]] - attack[i]) % a == 0:
j = (h[x[i]] - attack[i]) // a
else:
j = (h[x[i]] - attack[i]) // a + 1
attack[i] += a * j
ans += j
# 二分探索で、x[y] > x[i] + 2*d、を満たす最小のyを求める
# start <= y <= stop
start = i + 1
stop = n
k = stop - start + 1
while k > 1:
if x[start + k//2 - 1] <= x[i] + 2*d:
start += k//2
else:
stop = start + k//2 - 1
k = stop - start + 1
attack[start] -= a * j
print(ans)
| 1 | 82,231,628,601,682 | null | 230 | 230 |
t = input()
al = input()
count = 0
for i in range(len(al)):
if al[i:].startswith('ABC'):
count += 1
print(count)
|
N=int(input())
S=input()
ans=0
for i in range(N-2):
if S[i]=='A':
i+=1
if S[i]=='B':
i+=1
if S[i]=='C':
ans+=1
print(ans)
| 1 | 99,554,326,097,080 | null | 245 | 245 |
import itertools
def check(targets):
if targets[1] > targets[0] and targets[2] > targets[1]:
return True
else:
return False
if __name__ == "__main__":
A, B, C = map(int, input().split())
K = int(input())
targets = [A, B, C]
answer = 'No'
cases = itertools.product([0, 1, 2], repeat=K)
for case in cases:
copy_targets = targets.copy()
for i in case:
copy_targets[i] = copy_targets[i] * 2
if check(copy_targets):
answer = 'Yes'
break
print(answer)
|
# coding:utf-8
a, b, c = map(int, input().split())
k = int(input())
counter = 0
while a >= b:
counter += 1
b = b * 2
while b >= c:
counter += 1
c = c * 2
if counter <= k:
print('Yes')
else:
print('No')
| 1 | 6,848,417,246,270 | null | 101 | 101 |
def selectionSort(N, A):
c= 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]
c += 1
return (A, c)
A, c = selectionSort(int(input()), list(map(int, input().split())))
print(*A)
print(c)
|
n = int(raw_input())
a = map(int,raw_input().split(' '))
nswap=0
for i in range(n):
min_v = a[i]
min_p = i
for j in range(i,n):
if min_v > a[j]:
min_v = a[j]
min_p = j
if min_p != i:
a[i],a[min_p]=a[min_p],a[i]
nswap+=1
print ' '.join([str(v) for v in a])
print nswap
| 1 | 22,614,630,332 | null | 15 | 15 |
while True:
h, w = map(int, raw_input().split())
if (h == 0) & (w == 0):
break
line0 = ""
line1 = "."
for i in range(w):
if i % 2 == 0:
line0 += "#"
else:
line0 += "."
line1 += line0[:-1]
for j in range(h):
if j % 2 == 0:
print line0
else:
print line1
print ""
|
def main():
s = list(input())
for i in range(len(s)):
s[i] = "x"
L = "".join(s)
print(L)
if __name__ == "__main__":
main()
| 0 | null | 36,878,191,467,920 | 51 | 221 |
num = list(map(lambda x:int(x),input().split()))
if num[0] < num[1] and num[1] < num[2]:
print("Yes")
else:
print("No")
|
n = int(input())
list_ = []
for _ in range(n):
x, l = map(int, input().split())
list_.append([x-l, x+l])
list_.sort(key=lambda x: x[1])
res = n
pos = -float('inf')
for l, r in list_:
if l < pos:
res -= 1
else:
pos = r
print(res)
| 0 | null | 44,872,197,955,108 | 39 | 237 |
S = input()
W = ['SUN','MON','TUE','WED','THU','FRI','SAT']
w = W.index(S)
print(7 - w)
|
s=input()
l=[ "SUN","MON","TUE","WED","THU","FRI","SAT"]
ind=l.index(s)
if ind==0:
print(7)
else:
print(7-ind)
| 1 | 133,417,343,995,780 | null | 270 | 270 |
n=int(input())
s=[input() for _ in range(n)]
d0={}
d1={}
ma=0
mab=0
for si in s:
a,b=0,0
for x in si:
if x=='(':
b+=1
else:
b-=1
a=min(b,a)
a=-a
if b>=0:
if a in d0:
d0[a].append([a,b])
else:
d0[a]=[[a,b]]
ma=max(ma,a)
else:
if a+b in d1:
d1[a+b].append([a,b])
else:
d1[a+b]=[[a,b]]
mab=max(mab,a+b)
now=0
for i in range(ma+1):
if i not in d0:continue
if now>=i:
for a,b in d0[i]:
now+=b
else:
print('No')
exit()
for i in range(mab,-1,-1):
if i not in d1:continue
for a,b in d1[i]:
if now>=a:
now+=b
else:
print('No')
exit()
if now==0:
print('Yes')
else:
print('No')
|
import sys
import itertools
sys.setrecursionlimit(10000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
if __name__ == "__main__":
a,b,c,d = map(int,input().split())
e = a*c
f = a*d
g = b*c
h = b*d
ans = max(e,f)
ans = max(ans,g)
ans = max(ans,h)
print(ans)
| 0 | null | 13,255,258,358,912 | 152 | 77 |
from math import gcd
def main():
N = int(input())
A = list([int(x) for x in input().split()])
max_a = max(A)
before = 0
result = [0 for _ in range(max_a + 1)]
for i in A:
before = gcd(before, i)
result[i] += 1
is_pairwise = True
for i in range(2, max_a + 1):
cnt = 0
for j in range(i, max_a + 1, i):
cnt += result[j]
if cnt > 1:
is_pairwise = False
break
if is_pairwise:
print('pairwise coprime')
exit()
if before == 1:
print('setwise coprime')
else:
print('not coprime')
if __name__ == '__main__':
main()
|
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
DD = ((1,0),(0,1),(-1,0),(0,-1))
N = NI()
A = LI()
# 1000までの素数列
t = [True] * 1000
for i in range(2,33):
j = 2
while i * j < 1000:
t[i*j] = False
j += 1
p = []
for i in range(2,1000):
if t[i]: p.append(i)
cnt = [0] * 1000000
for x in A:
nf = True
for d in p:
if d > x: break
if x % d == 0:
while x % d == 0:
x //= d
if cnt[d]:
nf = False
break
cnt[d] += 1
else:
if x > 1:
if cnt[x]:
nf = False
break
cnt[x] += 1
continue
if nf: continue
break
else:
print('pairwise coprime')
return
g = A[0]
for x in A[1:]:
g = math.gcd(g,x)
if g == 1:
print('setwise coprime')
return
print('not coprime')
if __name__ == '__main__':
main()
| 1 | 4,093,876,365,898 | null | 85 | 85 |
n = int(input())
s, t = input().split()
a = []
for i in range(n):
a.append(s[i])
a.append(t[i])
print(''.join(a))
|
def main():
X = int(input())
if X == 2:
print(2)
exit()
if X % 2 == 0:
X += 1
while True:
flag = True
for i in range(3, X, 2):
if X % i == 0:
flag = False
break
if flag is True:
print(X)
break
else:
X += 2
if __name__ == '__main__':
main()
| 0 | null | 109,054,167,595,362 | 255 | 250 |
from operator import itemgetter
N,M = map(int,input().split())
PS = [list(map(str,input().split())) for i in range(M)]
for i in range(M) :
PS[i][0] = int(PS[i][0])
submits = [["null"] for i in range(N)]
for i in range(M) :
submits[PS[i][0]-1][0] = PS[i][0]-1
submits[PS[i][0]-1].append(PS[i][1])
ac = 0
pena = 0
for i in range(len(submits)) :
if submits[i][0] == "null" :
continue
flag = False
wabuf1 = 0
for j in range(1,len(submits[i])) :
if submits[i][j] == "AC" :
ac += 1
flag = True
break
else :
wabuf1 += 1
if flag == True :
pena += wabuf1
print(ac,pena)
|
import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
def celi(a,b):
return -(-a//b)
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n,m=map(int,input().split())
ps=[input().split() for i in range(m)]
dic={}
anslst=[0]*n
for i in range(m):
p,s=ps[i]
if s=="AC":
dic[p]=1
else:
if p in dic:
continue
else:
anslst[int(p)-1]+=1
ans=0
for i in dic.keys():
ans+=anslst[int(i)-1]
print(len(dic),ans)
| 1 | 93,475,656,100,914 | null | 240 | 240 |
H, W, K = map(int, input().split())
c = [input() for _ in range(H)]
ans = 0
for R in range(2**H):
for C in range(2**W):
n = 0
for y in range(H):
if R>>y&1:
for x in range(W):
if C>>x&1:
if c[y][x]=="#":
n += 1
if n==K:
ans += 1
print(ans)
|
# import sys
# input = sys.stdin.readline
import itertools
import collections
from decimal import Decimal
from functools import reduce
# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
H, W, k = input_list()
maze = [list(input()) for _ in range(H)]
ans = 0
for row_bit in itertools.product(range(2), repeat=H):
for col_bit in itertools.product(range(2), repeat=W):
cnt = 0
for row in range(H):
for col in range(W):
if maze[row][col] == "#" and (row_bit[row] and col_bit[col]):
cnt += 1
if cnt == k:
ans += 1
print(ans)
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
def bfs(H, W, black_cells, dist):
d = 0
while black_cells:
h, w = black_cells.popleft()
d = dist[h][w]
for dy, dx in ((1, 0), (0, 1), (-1, 0), (0, -1)):
new_h = h + dy
new_w = w + dx
if new_h < 0 or H <= new_h or new_w < 0 or W <= new_w:
continue
if dist[new_h][new_w] == -1:
dist[new_h][new_w] = d + 1
black_cells.append((new_h, new_w))
return d
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| 1 | 8,949,267,500,578 | null | 110 | 110 |
n = int(input())
A = list(map(int,input().split()))
ans = 0
for i in range(n-1):
if A[i] >= A[i+1]:
ans += A[i]-A[i+1]
A[i+1] = A[i]
print(ans)
|
n = int(input())
a = list(map(int,input().split()))
max_num = a[0]
ans = 0
for i in range(1,n):
max_num = max(max_num, a[i])
if max_num != a[i]:
ans += (max_num - a[i])
print(ans)
| 1 | 4,546,394,186,740 | null | 88 | 88 |
a = input()
print('a' if a.islower() else 'A')
|
def word():
K = int(input())
S = str(input())
A = ""
if len(S) <= K:
print(S)
return
else:
for i in range(K):
A = A + S[i]
A = A + "..."
print(A)
return
word()
| 0 | null | 15,429,240,402,048 | 119 | 143 |
n,a,b=map(int,input().split())
s=a+b
if n%s==0:
print(int(n/s)*a)
else:
if n%s>=a:
print(int(n//s+1)*a)
else:
print(int(n//s)*a+n%s)
|
N,A,B=map(int,input().split())
print(A*(N//(A+B))+min(A,N%(A+B)))
| 1 | 55,562,150,910,072 | null | 202 | 202 |
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N = I()
d = LI()
ans = 0
for i in range(N-1):
for j in range(i+1,N):
ans += d[i]*d[j]
print(ans)
|
N=int(input())
d=list(map(int, input().split()))
sum=0
for i in range(0,N-1):
for j in range(i+1,N):
sum=sum+d[i]*d[j]
print(sum)
| 1 | 168,170,503,055,620 | null | 292 | 292 |
# -*- coding: utf-8 -*-
A, B=map(int,input().split())
if(A<=B):
print("unsafe")
else:
print("safe")
|
import math
import time
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
s,w=map(int,stdin.readline().split())
if(w>=s):
print("unsafe")
else:
print("safe")
| 1 | 29,392,449,221,488 | null | 163 | 163 |
hp, dmg = map(int, input().split())
if hp % dmg == 0: print(int(hp//dmg))
else: print(int(hp//dmg) + 1)
|
print((lambda x: (x[0]-1)//x[1]+1)(list(map(int,input().split()))))
| 1 | 76,965,529,353,502 | null | 225 | 225 |
def insertionsort(A, n, g, 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
return cnt
A = []
n = int(raw_input())
for i in range(n):
A.append(int(raw_input()))
cnt = 0
G = [1]
while G[-1] * 3 + 1 < n:
G.append(G[-1] * 3 + 1)
G.reverse()
m = len(G)
for i in range(m):
cnt = insertionsort(A, n, G[i], cnt)
print m
print " ".join(map(str, G))
print cnt
for num in A:
print num
|
from sys import stdin
input = stdin.readline
N, M = map(int, input().split())
friends = [tuple(map(int, inp.strip().split())) for inp in stdin.read().splitlines()]
father = [-1] * N
def getfather(x):
if father[x] < 0: return x
father[x] = getfather(father[x])
return father[x]
def union(x, y):
x = getfather(x)
y = getfather(y)
if x != y:
if father[x] > father[y]:
x,y = y,x
father[x] += father[y]
father[y] = x;
for a, b in friends:
union(a - 1, b - 1)
# print(max(Counter([getfather(i) for i in range(N)]).values()))
print(max([-father[getfather(i)] for i in range(N)] or [0]) )
| 0 | null | 1,995,126,984,968 | 17 | 84 |
alpha = input()
if alpha == alpha.upper():
print('A')
else:
print('a')
|
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9
def main():
S = input()
weeks = ['SUN','MON','TUE','WED','THU','FRI','SAT']
for i in range(len(weeks)):
if weeks[i] == S:
print(7-i)
return
if __name__ == '__main__':
main()
| 0 | null | 72,462,744,773,952 | 119 | 270 |
def insertionSort(A, n, g):
cnt = 0
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt = cnt + 1
A[j+g] = v
return cnt
n = int(input())
a = []
g = []
for i in range(n):
x = int(input())
a.append(x)
count = 0
m = 1;
while m<= n:
g.append(m)
m = (m*3) + 1
l = len(g)
print(str(l))
l = l-1
while l>0:
print(str(g[l]) + " ", end = '')
count += insertionSort(a, n, g[l])
l = l-1
print(str(g[l]))
count += insertionSort(a, n, g[l])
print(str(count))
for i in a:
print(str(i))
|
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
first = a1 * t1 - b1 * t1
second = (a2 * t2 - b2 * t2)
last = second + first
if first * last > 0:
ans = 0
elif (abs(last) == 0):
ans = 'infinity'
else:
s = abs(first) // abs(last)
t = abs(first) % abs(last)
ans = 2 * s
if t != 0:
ans += 1
print(ans)
| 0 | null | 66,164,941,959,392 | 17 | 269 |
a,b = input().split()
a = int(a)
b = int(b)
sign = "=="
if (a < b) : sign = "<"
if (a > b) : sign = ">"
print("a",sign,"b")
|
I = input().split()
if int(I[0]) < int(I[1]):
print("a < b")
if int(I[0]) > int(I[1]):
print("a > b")
if int(I[0]) == int(I[1]):
print("a == b")
| 1 | 367,878,893,030 | null | 38 | 38 |
n=int(input())
k=[1]
ans=[]
c=26
wa=0
while wa+c<n:
k.append(c)
wa+=c
c=c*26
n=n-1-wa
for i in k[::-1]:
ans.append(n//i)
n=n%i
t=''
for i in ans:
t+=chr(97+i)
print(t)
|
def int_to_str(n):
if n == 0:
return "a"
elif n == 1:
return "b"
elif n == 2:
return "c"
elif n == 2:
return "c"
elif n == 2:
return "c"
elif n == 2:
return "c"
elif n == 2:
return "c"
elif n == 2:
return "c"
elif n == 2:
return "c"
def Base_10_to_n(X, n):
if (int(X/n)):
if X%n != 0:
return Base_10_to_n(int(X/n), n)+chr((X%n)+96)
else:
return Base_10_to_n(int(X/n)-1, n)+chr(26+96)
if(X%n != 0):
return str(chr(X%n+96))
else:
return ""
N = int(input())
s = Base_10_to_n(N,26)
print(s)
| 1 | 11,878,421,197,512 | null | 121 | 121 |
N = int(input())
A = map(int, input().split())
cnt = 0
for i, a in enumerate(A):
if ((i + 1) * a) % 2:
cnt += 1
print(cnt)
|
N = int(input())
answer = 'No'
for i in range(1, 9 + 1):
for j in range(1, 9 + 1):
if N == i * j:
answer = 'Yes'
print(answer)
| 0 | null | 83,696,186,544,422 | 105 | 287 |
for i in range(1,10):
for j in range(1,10):
print(i,"x",j,"=",i*j,sep="")
j+=1
i+=1
|
for i in range(1,10):
for s in range(1,10):
result = str(i) + "x" + str(s) + "=" + str(int(i)*int(s))
print(result)
| 1 | 1,268,792 | null | 1 | 1 |
from itertools import permutations as p
N = int(input())
P = tuple(map(int,input().split()))
Q = tuple(map(int,input().split()))
j = 0
for i in p(range(1, N + 1)):
j += 1
if i == P: a = j
if i == Q: b = j
if a - b >= 0: print(a - b)
else: print(b - a)
|
class Dice:
def __init__(self, labels):
self.labels = labels
def north(self):
self.change([2, 6, 3, 4, 1, 5])
def south(self):
self.change([5, 1, 3, 4, 6, 2])
def east(self):
self.change([4, 2, 1, 6, 5, 3])
def west(self):
self.change([3, 2, 6, 1, 5, 4])
def change(self, convert):
result = []
for i in range(6):
result.append(self.labels[convert[i] - 1])
self.labels = result
dice = Dice(list(map(int, input().split())))
for direction in input():
if direction == 'N':
dice.north()
if direction == 'S':
dice.south()
if direction == 'E':
dice.east()
if direction == 'W':
dice.west()
print(dice.labels[0])
| 0 | null | 50,385,498,991,920 | 246 | 33 |
N = int(input())
A = {a for a in input().split()}
if len(A) == N:
print("YES")
else:
print("NO")
|
def main(X, Y):
for n_crane in range(X + 1):
n_turtle = X - n_crane
y = n_crane * 2 + n_turtle * 4
if y == Y:
print('Yes')
return
print('No')
if __name__ == "__main__":
X, Y = [int(s) for s in input().split(' ')]
main(X, Y)
| 0 | null | 43,922,617,199,590 | 222 | 127 |
from sys import stdin
from collections import deque
n = int(stdin.readline())
g = [None] * n
for _ in range(n):
u, _, *cs = [int(s) for s in stdin.readline().split()]
g[u-1] = [c - 1 for c in cs]
ds = [-1] * n
v = [False] * n
v[0] = True
q = deque([(0, 0)])
while len(q):
u, d = q.popleft()
ds[u] = d
for c in g[u]:
if not v[c]:
v[c] = True
q.append((c, d + 1))
for u, d in enumerate(ds):
print(u + 1, d)
|
import sys,heapq
input = sys.stdin.readline
def main():
n,u,v = map(int,input().split())
u,v = u-1,v-1
edge = [[] for _ in range(n)]
for _ in [0]*(n-1):
a,b = map(int,input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
#cost:vからの距離
cost = [0]*n
new = [v]
c = 1
while len(new):
tank = []
for e in new:
for go in edge[e]:
if go != v and cost[go] == 0:
cost[go] = c
tank.append(go)
c += 1
new = tank
if cost[u]%2 == 1:
res = cost[u]//2
now = u
for _ in [0]*res:
for e in edge[now]:
if cost[now] > cost[e]:
now = e
new = [now]
while len(new):
tank = []
for e in new:
for go in edge[e]:
if cost[go] > cost[e]:
tank.append(go)
res += 1
new = tank
print(res-1)
else:
res = cost[u]//2-1
now = u
for _ in [0]*res:
for e in edge[now]:
if cost[now] > cost[e]:
now = e
new = [now]
while len(new):
tank = []
for e in new:
for go in edge[e]:
if cost[go] > cost[e]:
tank.append(go)
res += 1
new = tank
print(res)
if __name__ == '__main__':
main()
| 0 | null | 58,811,617,438,870 | 9 | 259 |
x = int(input())
if x == 1:
print("0")
elif x == 0:
print("1")
|
x = int(input())
if(x==0):
print("1")
elif(x==1):
print("0")
| 1 | 2,919,498,692,138 | null | 76 | 76 |
from sys import stdin, stdout
import math
import bisect
import datetime
n = int(stdin.readline().strip())
arr = list(map(int, stdin.readline().strip().split()))
arr.insert(0,0)
d={}
for i in range(len(arr)):
d[i] = arr[i]
arr = sorted(d.items(), key=lambda a: a[1])
dp = [[0 for i in range(2005)] for j in range(2005)]
for i in range(1, n + 1):
dp[i][i]=arr[1][1]*abs(arr[1][0]-i)
for l in range(2, n + 1):
pos, val = arr[l]
for left in range(1, n - l + 2):
right = left + l - 1
dp[left][right] = max(dp[left + 1][right] + val * abs(pos - left), dp[left][right - 1] + val * abs(pos - right))
stdout.writelines(str(dp[1][n]) + '\n')
|
# 解説AC
import sys
input = sys.stdin.buffer.readline
n = int(input())
A = list(map(int, input().split()))
B = []
for i, e in enumerate(A):
B.append((e, i + 1))
B.sort(reverse=True)
# dp[i][j]: Aiまで入れた時、左にj個決めた時の最大値
dp = [[-1] * (n + 1) for _ in range(n + 1)]
dp[0][0] = 0
for i in range(n):
for j in range(i + 1): # 左の個数
k = i - j # 右の個数
ni = i + 1
val, idx = B[i]
dp[ni][j] = max(dp[ni][j], dp[i][j] + abs(n - k - idx) * val)
dp[ni][j + 1] = max(dp[ni][j + 1], dp[i][j] + abs(idx - (j + 1)) * val)
ans = 0
for i in range(n + 1):
ans = max(ans, dp[n][i])
print(ans)
| 1 | 33,605,643,866,018 | null | 171 | 171 |
H = int(input())
W = int(input())
N = int(input())
for i in range(min(H,W)):
N -= max(H, W)
if N <= 0:
print(i+1)
exit()
|
while True:
a,op,b=input().split()
a,b=int(a),int(b)
if op=="+":
print(a+b)
elif op=="-":
print(a-b)
elif op=="*":
print(a*b)
elif op=="/":
print(a//b)
else:
break
| 0 | null | 45,020,877,240,740 | 236 | 47 |
import math
x=int(input())
ans=0
for i in range (1,x+1):
for j in range(1,x+1):
chk=math.gcd(i,j)
for k in range (1,x+1):
ans=ans+math.gcd(chk,k)
print(ans)
|
import math
from functools import reduce
K = int(input())
def gcd(*numbers):
return reduce(math.gcd, numbers)
ans = 0
for a in range(1,K+1):
if (a==1):
ans += K*K
continue
for b in range(1,K+1):
t = gcd(a,b)
if(t==1):
ans += K
continue
for c in range(1,K+1):
ans += gcd(t,c)
print(ans)
| 1 | 35,304,357,065,600 | null | 174 | 174 |
import math
a, b, c = map(int, input().split())
#_ab = math.sqrt(a * b)
#print(_ab)
if c - (a + b) < 0:
print("No")
else:
#right = math.pow(c - (a + b), 2)
right = (c - (a + b)) ** 2
left = 4 * a * b
if left < right:
print("Yes")
else:
print("No")
|
n = int(input())
print((10**n-2*9**n+8**n)%1000000007)
| 0 | null | 27,457,043,485,180 | 197 | 78 |
from collections import deque
import sys
import copy
N_MAX = 200000 + 5
INF = 10**9 + 7
sys.setrecursionlimit(N_MAX)
MOD = 10**9 + 7
### BFS ###
nextH = [0, 1, 0, -1]
nextW = [1, 0, -1, 0]
def bfs(u, S):
S[u[0]][u[1]] = 0 # state を変更
q = deque()
q.append(u)
m = 0
while q:
u = q.popleft()
for h, w in zip(nextH, nextW):
h += u[0]
w += u[1]
if not (0 <= h < len(S) and 0 <= w < len(S[0])):
continue
if S[h][w] == '.': # state を確認
S[h][w] = S[u[0]][u[1]] + 1 # state を変更
m = max(m, S[h][w])
q.append((h, w))
return m
def main():
H, W = map(int, sys.stdin.readline().rstrip().split())
S = []
for _ in range(H):
S.append([x for x in sys.stdin.readline().rstrip()])
# print(S)
m = 0
for h in range(H):
for w in range(W):
D = copy.deepcopy(S)
if S[h][w] == '.':
m = max(m, bfs((h, w), D))
print(m)
main()
|
N,M = (int(x) for x in input().split())
A = [int(x) for x in input().split()]
A = sorted(A,reverse=True)
if A[M-1] * 4 * M >= sum(A):
print("Yes")
else:
print("No")
| 0 | null | 66,556,885,289,248 | 241 | 179 |
ini = lambda : int(input())
inm = lambda : map(int,input().split())
inl = lambda : list(map(int,input().split()))
gcd = lambda x,y : gcd(y,x%y) if x%y else y
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
#code-------------------------------------------------
x = ini()
for b in range(-121,121):
for a in range(b,121):
if (a ** 5) - (b ** 5) == x:
break
else:
continue
break
print(a,b)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
X = int(readline())
def make_divisors(n):
lower_divisors = []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
i += 1
return lower_divisors
A = make_divisors(X)
for a in A:
for b in range(10**3,-(10**3),-1):
Y = X // a
if ((b+a)**4 + b*(b+a)**3 + b**2*(b+a)**2 + b**3*(b+a) + b**4) == Y:
print(b+a,b)
sys.exit()
| 1 | 25,385,107,198,902 | null | 156 | 156 |
A, B, M = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
b = [int(_) for _ in input().split()]
xyc = [[int(_) for _ in input().split()] for i in range(M)]
rets = [min(a) + min(b)]
for x, y, c in xyc:
rets += [a[x-1] + b[y-1] - c]
print(min(rets))
|
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c0 = min(a) + min(b)
for i in range(M):
x, y, c = map(int, input().split())
x -= 1
y -= 1
cnext = a[x] + b[y] - c
c0 = min(c0, cnext)
print(c0)
| 1 | 53,962,211,758,628 | null | 200 | 200 |
A = list(map(int, input().split()))
N=A[0]
R=A[1]
if N>=10:
print(R)
else:
print(100*(10-N)+R)
|
n, r = map(int, input().split())
if n > 9:
print(r)
else:
print(r - 100*n + 1000)
| 1 | 63,649,998,102,820 | null | 211 | 211 |
import math
n=int(input())
while n != 0 :
sums = 0.0
s = list(map(float,input().split()))
m = sum(s)/n
for i in range(n):
sums += ((s[i]-m)**2)/n
print(math.sqrt(sums))
n = int(input())
|
i=0
while True:
N=int(input())
if N==0:
break
else:
a = list(map(float,input().split()))
m=sum(a)/N
#print(m)
for i in range(N):
a[i]=(float)(a[i]-m)**2
#print(a[i])
i+=1
A=(sum(a)/N)**(1/2)
print(A)
| 1 | 187,344,631,882 | null | 31 | 31 |
n=int(input())
A=[]
for i in range(n):
a=str(input())
A.append(a)
import collections
c = collections.Counter(A)
ma= c.most_common()[0][1]
C=[i[0] for i in c.items() if i[1] >=ma ]
C.sort(reverse=False)
for j in range(len(C)):
print(C[j])
|
import sys
w = sys.stdin.readline().strip().lower()
cnt = 0
while True:
line = sys.stdin.readline().strip()
if line == 'END_OF_TEXT':
break
words = line.split(' ')
for i in words:
if i.lower() == w:
cnt += 1
print(cnt)
| 0 | null | 35,994,824,486,640 | 218 | 65 |
n = int(input())
s = input()
prev = ""
ans = ""
for i in range(n):
if s[i] == prev:
continue
prev = s[i]
ans += s[i]
print(len(ans))
|
n = int(input())
s = input()
for i in range(n-1):
if s[i] == s[i+1]:
s = s[:i] + " " + s[i+1:]
print(len(s.replace(" ", "")))
| 1 | 169,857,571,856,544 | null | 293 | 293 |
a,b,c,d = map(int,input().split())
while a > 0 and c > 0 :
c -= b
a -= d
if c <= 0 :
print('Yes')
else :
print('No')
|
A,B,C,D=map(int,input().split())
while 1:
C=C-B
if C<=0:
print("Yes")
break
A=A-D
if A<=0:
print("No")
break
| 1 | 29,522,272,673,128 | null | 164 | 164 |
D=int(input())
C=list(map(int, input().split()))
S=[list(map(int,input().split())) for i in range(D)]
T=[]
for i in range(D):
T.append(int(input()))
def dissat(day):
dissat = 0
for i in range(26):
if T[day-1]-1 == i:
continue
dissat += C[i]*(day-lastdays[i])
return dissat
def last(day):
lastdays[T[day-1]-1] = day
sat = 0
lastdays = [0]*26
# main
for i in range(D):
# dayi
last(i)
sat += S[i][T[i]-1] - dissat(i+1)
print(sat)
|
X = int(input())
print('Yes' if X >= 30 else 'No')
| 0 | null | 7,892,779,316,036 | 114 | 95 |
n,m = map(int,input().split())
graph = [[] for i in range(n)]
for i in range(m):
a,b = map(lambda z:int(z)-1,input().split())
graph[a].append(b)
graph[b].append(a)
size = [0 for i in range(n)]
check = [True for i in range(n)]
for i in range(n):
if check[i]:
tmp = 1
stack = [i]
check[i] = False
while stack:
now = stack.pop()
size[now] = tmp
tmp+=1
for to in graph[now]:
if check[to]:
check[to] = False
stack.append(to)
print(max(size))
|
from collections import defaultdict
def main():
N, M = map(int, input().split())
g = defaultdict(set)
for _ in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
g[a].add(b)
g[b].add(a)
def dfs(u, visited: set):
stack = [u]
visited.add(u)
while stack:
u = stack.pop()
for v in g[u]:
if v not in visited:
stack.append(v)
visited.add(v)
count = dict()
for u in range(N):
if u in count:
continue
visited = set()
dfs(u, visited)
# print(visited)
count[u] = len(visited)
for v in visited:
count[v] = len(visited)
print(max(count.values()))
if __name__ == '__main__':
import sys
sys.setrecursionlimit(10000)
main()
| 1 | 3,986,654,603,460 | null | 84 | 84 |
N, K = (int(x) for x in input().split())
check=[False]*N
ans=N
for i in range(K):
d=int(input())
A=list(map(int, input().split()))
for j in range(d):
if check[A[j]-1]==False:
ans-=1
check[A[j]-1]=True
print(ans)
|
import math
def taxminus(X):
return X/1.08,(X+1)/1.08
N=int(input())
min,max=taxminus(N)
min=math.ceil(min)
if min>=max:
print(":(")
else:
print(min)
| 0 | null | 75,579,487,186,710 | 154 | 265 |
import queue
n = int(input())
graph = {}
for _ in range(n):
i = list(map(int,input().split()))
graph[i[0]] = i[2:]
dist = [-1 for i in range(n)]
todo = queue.Queue()
seen = set()
dist[0] = 0
todo.put(1)
while (not todo.empty()):
now = todo.get()
for nx in graph[now]:
if (dist[nx-1] != -1):
continue
dist[nx-1] = dist[now-1] + 1
todo.put(nx)
for i in range(n):
print(i+1, dist[i])
|
from sys import stdin
from collections import deque
n = int(input())
d = [-1] * (n + 1)
def bfs():
d[1] = 0
dq = deque([1])
while len(dq) != 0:
v = dq.popleft()
for c in G[v]:
if d[c] != -1 : continue
d[c] = d[v] + 1
dq.append(c)
for i, x in enumerate(d[1:], start=1):
print(i, x)
G = [0] + [list(map(int, input().split()[2:])) for i in range(n)]
bfs()
| 1 | 4,492,265,940 | null | 9 | 9 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
m = map(int,read().split())
xl = zip(m,m)
c = [(x-l,x+l) for x,l in xl]
from operator import itemgetter
c.sort()
c.sort(key=itemgetter(1))
ans = 1
chk = c[0][1]
for i,j in c:
if i >= chk:
ans +=1
chk = j
print(ans)
|
N = int(input())
XL = [list(map(int, input().split())) for x in range(N)]
XL = sorted(XL, key=lambda x: x[0]+x[1])
cnt = 0
prev_right = -10**9+10
for x, l in XL:
left = x - l
right = x + l
if left >= prev_right:
cnt += 1
prev_right = right
print(cnt)
| 1 | 89,894,282,562,110 | null | 237 | 237 |
# #
# author : samars_diary #
# 13-09-2020 │ 12:41:59 #
# #
import sys, os.path
#if(os.path.exists('input.txt')):
#sys.stdin = open('input.txt',"r")
#sys.stdout = open('output.txt',"w")
sys.setrecursionlimit(10 ** 5)
def mod(): return 10**9+7
def i(): return sys.stdin.readline().strip()
def ii(): return int(sys.stdin.readline())
def li(): return list(sys.stdin.readline().strip())
def mii(): return map(int, sys.stdin.readline().split())
def lii(): return list(map(int, sys.stdin.readline().strip().split()))
#print=sys.stdout.write
def solve():
n,x,t=mii()
print(t*(n//x)+t*(bool(n%x)))
solve()
|
n=int(input())
s=input()
ans=0
for i in range(1000):
i=str(i).zfill(3)
a=0
for c in s:
if c==i[a]:
a+=1
if a==3:
ans+=1
break
print(ans)
| 0 | null | 66,139,761,978,868 | 86 | 267 |
n, k = map(int, input().split())
p = list(map(int, input().split()))
s = sum(p[:k])
ret = s
for i in range(k, n):
s += p[i] - p[i - k]
ret = max(ret, s)
print((ret + k) / 2.0)
|
r, c = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(r)]
for i in range(r):
matrix[i].append(sum(matrix[i]))
matrix.append(list(map(sum, zip(*matrix))))
# matrix.append([sum(i) for i in zip(*matrix)])
for row in matrix:
print(' '.join(str(e) for e in row))
| 0 | null | 38,278,358,526,840 | 223 | 59 |
X = int(input())
for i in range(1, 1000):
if 100 * i <= X and X <= 105 * i:
print(1)
exit()
print(0)
|
N = input()
for i in range(1,12):
if i * 1000 - int(N) < 0:
continue
else:
print(i * 1000 - int(N))
break
| 0 | null | 67,631,922,689,980 | 266 | 108 |
N, D, A = map(int, input().split())
XH = sorted([tuple(map(int, input().split())) for _ in range(N)])
ans, r, S, R = 0, 0, [0] * (N + 2), []
for l in range(N):
while r + 1 < N and XH[r + 1][0] - XH[l][0] <= 2 * D:
r += 1
S[l + 1] += S[l]
bomb = (max(XH[l][1] - S[l + 1], 0) + A - 1) // A
ans += bomb
S[l + 1] += bomb * A
S[r + 1 + 1] -= bomb * A
R.append(r)
print(ans)
|
T1,T2 = map(int, input().split())
A1,A2 = map(int, input().split())
B1,B2 = map(int, input().split())
d1 = (A1-B1)*T1
d2 = (A2-B2)*T2
if d1<0: d1,d2 = -d1,-d2
if d1+d2==0: print("infinity")
elif d1+d2>0: print(0)
elif d1%(-d1-d2) == 0: print(2*(d1//(-d1-d2)))
else: print(2*(d1//(-d1-d2))+1)
| 0 | null | 106,900,133,214,462 | 230 | 269 |
input()
x = input()
a = x.split()
b = list(map(int,a))
print("{} {} {}".format(min(b),max(b),sum(b)))
|
n = int(input())
count_list = [0] * 4
for i in range(n):
text = input()
if text == "AC":
count_list[0] += 1
elif text == "WA":
count_list[1] += 1
elif text == "RE":
count_list[3] += 1
else:
count_list[2] += 1
print("AC x " + str(count_list[0]))
print("WA x " + str(count_list[1]))
print("TLE x " + str(count_list[2]))
print("RE x " + str(count_list[3]))
| 0 | null | 4,702,660,983,200 | 48 | 109 |
n,m=map(int,input().split())
h=list(map(int,input().split()))
AB=[list(map(int,input().split())) for _ in range(m)]
from math import gcd
ans=[1 for _ in range(n)]
for ab in AB:
if h[ab[0]-1]>h[ab[1]-1]:
ans[ab[1]-1]=0
elif h[ab[0]-1]<h[ab[1]-1]:
ans[ab[0]-1]=0
else:
ans[ab[0]-1]=0
ans[ab[1]-1]=0
print(sum(ans))
|
N,M = map(int,input().split())
H = list(map(int,input().split()))
bad = []
for i in range(M):
A,B = map(int,input().split())
if H[A-1] > H[B-1]:
bad.append(B-1)
elif H[A-1] < H[B-1]:
bad.append(A-1)
else:
bad.append(A-1)
bad.append(B-1)
print(N-len(set(bad)))
| 1 | 24,993,869,326,048 | null | 155 | 155 |
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
mod=10**9+7
n=int(input())
dic={}
cnt=0
for _ in range(n):
a,b=map(int,input().split())
if a!=0 and b!=0:
g=gcd(abs(a),abs(b))
if a*b>0:
if (abs(a)//g,abs(b)//g) not in dic:
dic[(abs(a)//g,abs(b)//g)]=1
else:
dic[(abs(a)//g,abs(b)//g)]+=1
else:
if (-abs(a)//g,abs(b)//g) not in dic:
dic[(-abs(a)//g,abs(b)//g)]=1
else:
dic[(-abs(a)//g,abs(b)//g)]+=1
else:
if a==0 and b==0:
cnt+=1
elif a==0:
if (1,0) not in dic:
dic[(1,0)]=1
else:
dic[(1,0)]+=1
elif b==0:
if (0,1) not in dic:
dic[(0,1)]=1
else:
dic[(0,1)]+=1
ans=1
s=set()
for a,b in dic.keys():
if (a,b) in s:
continue
s.add((a,b))
if a!=0 and b!=0:
if a>0:
if (-b,a) in dic:
s.add((-b,a))
cnt1=dic[(a,b)]
cnt2=dic[(-b,a)]
ans*=(pow(2,cnt1,mod)+pow(2,cnt2,mod)-1)%mod
ans%=mod
else:
ans*=pow(2,dic[(a,b)])
ans%=mod
elif a<0:
if (b,-a) in dic:
s.add((b,-a))
cnt1=dic[(a,b)]
cnt2=dic[(b,-a)]
ans*=(pow(2,cnt1,mod)+pow(2,cnt2,mod)-1)%mod
ans%=mod
else:
ans*=pow(2,dic[(a,b)],mod)
ans%=mod
else:
if (b,a) in dic:
s.add((b,a))
cnt1=dic[(a,b)]
cnt2=dic[(b,a)]
ans*=(pow(2,cnt1,mod)+pow(2,cnt2,mod)-1)%mod
ans%=mod
else:
ans*=pow(2,dic[(a,b)],mod)
ans%=mod
print((ans+cnt-1)%mod)
|
from math import gcd
mod = 1000000007
n = int(input())
counter = {}
zeros = 0
for i in range(n):
a, b = map(int, input().split())
if (a == 0 and b == 0):
zeros += 1
continue
g = gcd(a, b)
a //= g
b //= g
if (b < 0):
a = -a
b = -b
if (b == 0 and a < 0):
a = -a
counter[(a, b)] = counter.get((a, b), 0)+1
counted = set()
ans = 1
for s, s_count in counter.items():
if s not in counted:
if s[0] > 0 and s[1] >= 0:
t = (-s[1], s[0])
else:
t = (s[1], -s[0])
t_count = counter.get(t, 0)
now = pow(2, s_count, mod)-1
now += pow(2, t_count, mod)-1
now += 1
ans *= now
ans %= mod
counted.add(s)
counted.add(t)
print((ans - 1 + zeros) % mod)
| 1 | 20,879,146,101,308 | null | 146 | 146 |
x_low,x_up,y_low,y_up=map(int,input().split())
a1=x_low*y_low
a2=x_low*y_up
a3=x_up*y_low
a4=x_up*y_up
ans=max(a1,a2,a3,a4)
print(ans)
|
a, b, c, d = map(int, input().split())
ans = -float("INF") # 答えがマイナスになることがあるので、負の無限大を初期値にしておきます
for x in (a, b):
for y in (c, d):
ans = max(ans, x * y)
print(ans)
| 1 | 3,039,374,558,788 | null | 77 | 77 |
import sys
input = sys.stdin.readline
A,B = list(map(int,input().split()))
print(A*B)
|
#coding:utf-8
import math
datas = [float(x) for x in input().split()]
p1 = (datas[0], datas[1])
p2 = (datas[2], datas[3])
print(math.sqrt(math.pow(p1[0]-p2[0], 2)+math.pow(p1[1]-p2[1],2)))
| 0 | null | 8,011,891,973,892 | 133 | 29 |
a, b = map(int, input().split())
ans = -1
for v in range((100*10)+100):
t8 = int(v * 0.08)
t10 = int(v * 0.1)
if t8 > a or t10 > b:
break
if t8 == a and t10 == b:
ans = v
break
print(ans)
|
n = int(input())
q = list(map(int,input().split()))
ans = 0
for i in range(n):
for j in range(n):
if i == j:
continue
ans += q[i] * q[j]
print(ans//2)
| 0 | null | 112,937,166,594,372 | 203 | 292 |
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush
from decimal import *
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
##### 割り算の切り上げ #####
# tmp = -(-4 // 3)
##### dict の for文 #####
# for k, v in d.items():
# print(k, v)
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():
N = inputInt()
pazuru_nobori = []
pazuru_kudari = []
for i in range(N):
S = inputStr()
tmp = 0
min_tmp = 0
for s in S:
if s == "(":
tmp += 1
else:
tmp -= 1
if min_tmp > tmp:
min_tmp = tmp
if tmp >= 0:
pazuru_nobori.append((min_tmp,tmp))
else:
pazuru_kudari.append((min_tmp,tmp))
pazuru_nobori.sort()
pazuru_nobori = pazuru_nobori[::-1]
score = 0
for i,val in enumerate(pazuru_nobori):
min_tmp,tmp = val
if score + min_tmp < 0:
print("No")
sys.exit()
score += tmp
pazuru_kudari_non = []
for i,val in enumerate(pazuru_kudari):
min_tmp,tmp = val
min_tmp_2 = min_tmp - tmp
tmp_2 = -1 * tmp
pazuru_kudari_non.append((min_tmp_2,tmp_2))
pazuru_kudari_non.sort()
pazuru_kudari_non = pazuru_kudari_non[::-1]
score2 = 0
for i,val in enumerate(pazuru_kudari_non):
min_tmp,tmp = val
if score2 + min_tmp < 0:
print("No")
sys.exit()
score2 += tmp
if score2 == score:
print("Yes")
else:
print("No")
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
if N < K or K-1 < 0:
return 0
else:
return combination(N-1, K-1, mod)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
stk = []
stk.append(edge)
while len(stk) > 0:
p = stk.pop()
for e in graph[p]:
if parent[p] == e:
continue
else:
parent[e] = p
counter[e] += counter[p]
stk.append(e)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
|
import sys
readline = sys.stdin.readline
def main():
N = int(readline())
Sp = []
Sm = []
total = 0
bm = 0
for i in range(N):
l = readline().strip()
b = 0
h = 0
for j in range(len(l)):
if l[j] == '(':
h += 1
else:
h -= 1
b = min(b, h)
if h == 0 and b != 0:
bm = min(bm, b)
elif h > 0:
Sp.append([b, h])
elif h < 0:
Sm.append([b-h, -h])
total += h
Sp.append([bm, 0])
if total != 0:
print('No')
exit()
Sp.sort(key=lambda x:x[0], reverse=True)
p = check(Sp)
if p < 0:
print('No')
exit()
Sm.sort(key=lambda x:x[0], reverse=True)
m = check(Sm)
if m < 0:
print('No')
exit()
print('Yes')
def check(S):
h = 0
for i in range(len(S)):
if h + S[i][0] < 0:
return -1
else:
h += S[i][1]
return h
if __name__ == '__main__':
main()
| 1 | 23,701,708,256,996 | null | 152 | 152 |
H = int(input())
ans,attack = 1,0
while(H > 1):
attack += 1
H //= 2
for i in range(1,attack+1):
ans += 2**i
print(ans)
|
from math import *
H = int(input())
print(2**(int(log2(H))+1)-1)
| 1 | 79,688,070,588,060 | null | 228 | 228 |
tmp = input().split(" ")
A = int(tmp[0])
B = int(tmp[1])
if A <= 9 and B <= 9:
print(A * B)
else:
print("-1")
|
a, b = map(int, input().split())
if a > 0 and a < 10:
if b > 0 and b < 10:
print(a * b)
else:
print(-1)
else:
print(-1)
| 1 | 158,394,268,600,832 | null | 286 | 286 |
n = int(input())
for i in range(0, n):
a, b, c = sorted(map(int, input().split()))
print("YES" if c*c == a*a+b*b else "NO")
|
import sys
n=int(input())
for i in range(n):
list=input().split()
list=[int(j) for j in list]
list.sort()
if list[0]*list[0]+list[1]*list[1]==list[2]*list[2]:
print("YES")
else:print("NO")
| 1 | 281,174,336 | null | 4 | 4 |
n=int(input())
a=[]
l=[]
for i in range(n):
A=int(input())
L=[list(map(int,input().split())) for _ in range(A)]
a.append(A)
l.append(L)
ans=0
for i in range(2**n):
b=[0]*n
for j in range(n):
if (i>>j)&1:
b[j]=1
for k in range(n):
for h in range(a[k]):
hito=l[k][h][0]-1
singi=l[k][h][1]
if b[k]==1 and b[hito]!=singi:
break
else:
continue
break
else:
ans=max(ans,sum(b))
print(ans)
|
n = int(input())
ans = [1]*n
T = [[-1]*n for _ in range(n)]
for ni in range(n):
a = int(input())
for ai in range(a):
x, y = map(int,input().split())
T[ni][x-1] = y
mx = 0
for i in range(pow(2,n)):
tmx = -1
B = bin(i)[2:].zfill(n)
S = [i for i,b in enumerate(B) if b=='1']
for s in S:
_Ts = [i for i,t in enumerate(T[s]) if t==1]
_Tf = [i for i,t in enumerate(T[s]) if t==0]
if not (set(_Ts)<=set(S) and set(_Tf)&set(S)==set()):
tmx = 0
break
if tmx==-1: tmx=len(S)
mx = max(mx, tmx)
print(mx)
| 1 | 121,893,469,823,368 | null | 262 | 262 |
import math
a = int(input())
b = int(input())
n = int(input())
dum = max(a,b)
ans = n/dum
print(math.ceil(ans))
|
h = int(input())
w = int(input())
n = int(input())
n_push = []
for n_h in range(h+1):
for n_w in range(w+1):
n_tmp = (n_h)*w + (n_w)*h - ((n_h)*(n_w))
if n_tmp>=n:
n_push.append(n_h + n_w)
print(min(n_push))
| 1 | 89,141,802,419,718 | null | 236 | 236 |
n = int(input())
taro = 0
hanako = 0
for i in range(n):
t,h =input().split()
if t > h:
taro+=3
elif t<h:
hanako += 3
else:
taro += 1
hanako += 1
print("%d %d" % (taro,hanako))
|
import math
def getDistance( x, y, n, p ):
dxy = 0
for i in range( n ):
dxy += abs( x[i] - y[i] )**p
return dxy**(1/float( p ) )
n = int( raw_input() )
x = [ float( i ) for i in raw_input( ).split( " " ) ]
y = [ float( i ) for i in raw_input( ).split( " " ) ]
print( getDistance( x, y, n, 1 ) )
print( getDistance( x, y, n, 2 ) )
print( getDistance( x, y, n, 3 ) )
dxy = [ 0 ]*(n+1)
for i in range( n ):
dxy[i] = abs( x[i] - y[i] )
print( max( dxy ) )
| 0 | null | 1,096,640,849,936 | 67 | 32 |
N=int(input())
n=N
ans=0
def make_divisors(n):
divisors = []
for i in range(1,int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n//i:
divisors.append(n//i)
return divisors
l=make_divisors(N-1)
r=make_divisors(N)
ans=len(l)-1
for i in range(len(r)):
N=n
K=r[i]
if K==1:
continue
while(N%K==0):
N=N//K
if N%K==1:
#print(K)
ans+=1
print(ans)
|
n = int(input())
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
# その数自身
ans = 1
# 1以外のn-1の約数
ans += len(make_divisors(n-1)) - 1
d = make_divisors(n)
for k in range(1,(len(d)+1)//2):
i = d[k]
j = n//i
while j % i == 0:
j //= i
if j % i == 1:
ans += 1
print(ans)
| 1 | 41,602,829,840,320 | null | 183 | 183 |
x=int(input())
x+=1
print(x%2)
|
n = int(input())
a_list = list(map(int, input().split()))
dai = 0
for i in range(1, n):
if a_list[i] < a_list[i-1]:
dai += a_list[i-1] - a_list[i]
a_list[i] += a_list[i-1] - a_list[i]
# print(dai)
else:
continue
print(dai)
| 0 | null | 3,695,441,606,540 | 76 | 88 |
def make_array_for_comb(N, mod=10**9+7):
fact = [1,1]
fact_inv = [1,1]
inv = [0,1]
for i in range(2, N+1):
fact.append((fact[-1]*i) % mod)
# モジュラ逆数の性質
inv.append((-inv[mod%i] * (mod//i)) % mod)
fact_inv.append((fact_inv[-1]*inv[i]) % mod)
return fact, fact_inv
def comb(n, r, mod=10**9+7):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * fact_inv[r] * fact_inv[n-r] % mod
import sys
input = sys.stdin.readline
mod = 10**9+7
n,k = [int(i) for i in input().split()]
fact, fact_inv = make_array_for_comb(n,mod)
a = [int(i) for i in input().split()]
a = sorted(a)
a = tuple(a)
ans = 0
for i in range(0,n-k+1):
p = a[i]*comb(n-1-i,k-1,mod)
ans -= (p%mod)
ans %= mod
for i in range(k-1,n):
q = a[i]*comb(i,k-1,mod)
ans += (q%mod)
ans %= mod
print(ans)
|
N,K= map(int, input().split())
p = 10**9+7
f=[1]
for i in range(1,N+1):
f.append(f[-1]*i % p)
def nCk(n,k):
return f[n]*pow(f[n-k], p-2, p)*pow(f[k], p-2, p)
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(N-K+1):
ans -= (a[i] * nCk(N-i-1, K-1)) % p
ans += (a[N-i-1] * nCk(N-i-1, K-1)) % p
print(ans % p)
| 1 | 95,743,524,527,980 | null | 242 | 242 |
A,B,N=map(int,input().split())
i=min(B-1,N)
tmp=(A*i)//B-A*(i//B)
print(tmp)
|
A, B, N = map(int, input().split())
x = min(N, B-1)
print(A * x //B)
| 1 | 28,094,940,201,130 | null | 161 | 161 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.