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
|
|---|---|---|---|---|---|---|
import sys
sys.setrecursionlimit(10**9)
input = lambda: sys.stdin.readline().rstrip()
inpl = lambda: list(map(int,input().split()))
N, M, L = inpl()
road = [[] for _ in range(N)]
ABC = []
for i in range(M):
A, B, C = inpl()
if C <= L:
road[A-1].append((B-1,C))
road[B-1].append((A-1,C))
ABC.append((A-1,B-1,C))
INF = 10**12
cur1 = [[INF]*N for _ in range(N)]
for a, b, c in ABC:
cur1[a][b] = cur1[b][a] = c
for k in range(N):
prev1 = cur1
cur1 = [[INF]*N for _ in range(N)]
for j in range(N):
for i in range(N):
cur1[j][i] = min(prev1[j][i], prev1[k][i]+prev1[j][k])
cur2 = [[INF]*N for j in range(N)]
for j in range(N):
for i in range(N):
if cur1[j][i] <= L:
cur2[j][i] = 1
for k in range(N):
prev2 = cur2
cur2 = [[INF]*N for _ in range(N)]
for j in range(N):
for i in range(N):
cur2[j][i] = min(prev2[j][i], prev2[k][i]+prev2[j][k])
Q = int(input())
ST = [inpl() for _ in range(Q)]
for s,t in ST:
if cur2[s-1][t-1] >= INF:
print(-1)
else:
print(cur2[s-1][t-1]-1)
|
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
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
#####MakeDivisors######
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
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N,M,L = IL()
class WarshallFloyd():
def __init__(self, N):
self.N = N
self.d = [[float("inf") for i in range(N)] for i in range(N)]
def add(self, u, v, c, directed=False):
if directed is False:
self.d[u][v] = c
self.d[v][u] = c
else:
self.d[u][v] = c
def WarshallFloyd_search(self):
for k in range(self.N):
for i in range(self.N):
for j in range(self.N):
self.d[i][j] = min(self.d[i][j], self.d[i][k] + self.d[k][j])
hasNegativeCycle = False
for i in range(self.N):
if self.d[i][i] < 0:
hasNegativeCycle = True
break
for i in range(self.N):
self.d[i][i] = 0
return hasNegativeCycle, self.d
W = WarshallFloyd(N)
for _ in range(M):
u,v,c = IL()
if c>L: continue
W.add(u-1,v-1,c)
_,d = W.WarshallFloyd_search()
W = WarshallFloyd(N)
for u in range(N):
for v in range(u+1,N):
if d[u][v] > L: continue
W.add(u,v,1)
_,d = W.WarshallFloyd_search()
Q = I()
for _ in range(Q):
s,t = IL()
if d[s-1][t-1] == INF:
print(-1)
else:
print(d[s-1][t-1]-1)
| 1 | 173,794,396,269,682 | null | 295 | 295 |
n , k , c = map(int,input().split())
s = input()
L = []
R = []
i = 0
j = n-1
while i<n and len(L)<k :
if s[i] == "o" :
L.append(i)
i += c
i += 1
while j>-1 and len(R)<k :
if s[j] == "o" :
R.append(j)
j -= c
j -= 1
R.reverse()
for x in range(k):
if R[x] == L[x]:
print(R[x]+1)
|
def main():
n, k, c = map(int,input().split())
s = input()
schedule = [w == "o" for w in s]
left = []
l_day = 0
right = []
r_day = n - 1
while len(left) < k:
if schedule[l_day]:
left.append(l_day)
l_day += c
l_day += 1
while len(right) < k:
if schedule[r_day]:
right.append(r_day)
r_day -= c
r_day -= 1
right.reverse()
for i in range(k):
if left[i] == right[i]:
print(left[i] + 1)
if __name__ == "__main__":
main()
| 1 | 40,721,907,654,350 | null | 182 | 182 |
import bisect
n = int(input())
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n-1):
b = l[:i]
c = l[i+1:]
for j in b:
ans += bisect.bisect_left(c, l[i] + j)#2番目の棒より短く(left), 一定以上の長さを持つ([i+1:])
print(ans)
|
N=int(input())
*L,=map(int,input().split())
L.sort()
from bisect import*
i=0
ans=0
while i<N:
j=i+1
while j<N:
ans+=bisect_left(L,L[i]+L[j])-j-1
j+=1
i+=1
print(ans)
| 1 | 172,368,019,788,022 | null | 294 | 294 |
N = int(input())
S = input()
if S == S[:N//2]*2:
print("Yes")
else:
print("No")
|
n, k = [ int( val ) for val in raw_input( ).split( " " ) ]
w = []
maxW = sumW = 0
for i in range( n ):
num = int( raw_input( ) )
sumW += num
w.append( num )
if maxW < num:
maxW = num
minP = 0
if 1 == k:
minP = sumW
elif n == k:
minP = maxW
else:
left = maxW
right = 100000*10000
while left <= right:
middle = ( left+right )//2
truckCnt = i = loadings = 0
while i < n:
loadings += w[i]
if middle < loadings:
truckCnt += 1
if k < truckCnt+1:
break
loadings = w[i]
i += 1
if truckCnt+1 <= k:
minP = middle
if k < truckCnt+1:
left = middle + 1
else:
right = middle - 1
print( minP )
| 0 | null | 73,304,170,203,430 | 279 | 24 |
import math
class Pos:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return str(self.x) + ' ' + str(self.y)
def koch_curve(i, n, start, end):
if i < n:
f = get_pos(start, end, 1/3)
t = get_pos(start, end, 2/3)
s = get_sec_pos(start, end, f, t)
koch_curve(i + 1, n, start, f)
print(f)
koch_curve(i + 1, n, f, s)
print(s)
koch_curve(i + 1, n, s, t)
print(t)
koch_curve(i + 1, n, t, end)
def get_pos(start, end, m):
dX = (end.x - start.x) * m
dY = (end.y - start.y) * m
return Pos(start.x + dX, start.y + dY)
def get_sec_pos(start, end, f, t):
x = y = 0
if f.y == t.y:
x = start.x + (end.x - start.x) / 2
len = math.fabs(t.x - f.x)
h = math.sqrt(len**2 - (len/2)**2)
if start.x < end.x:
y = start.y + h
else:
y = start.y - h
elif f.x < t.x and f.y < t.y:
x = start.x
y = t.y
elif f.x > t.x and f.y < t.y:
x = end.x
y = f.y
elif f.x > t.x and f.y > t.y:
x = start.x
y = t.y
else:
x = end.x
y = f.y
return Pos(x, y)
n = int(input())
start = Pos(0, 0)
end = Pos(100, 0)
print(start)
koch_curve(0, n, start, end)
print(end)
|
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
import math
DEG60 = math.pi/3
def repl_edge(n, edges):
# print('n=',n, 'edges=', len(edges))
if n == 0:
return edges
new_list = list()
for edge in edges: # single tupple
p1 = edge[0]
p2 = edge[1]
p_angle = edge[2]
s = ((p1[0]*2+p2[0])/3, (p1[1]*2+p2[1])/3)
t = ((p1[0]+p2[0]*2)/3, (p1[1]+p2[1]*2)/3)
r = abs((t[0]-s[0])**2 + (t[1]-s[1])**2) ** 0.5
angle = p_angle + DEG60
u = (s[0] + math.cos(angle)*r, s[1] + math.sin(angle)*r)
# print('r=', r, 'u=', u, 'angle=', angle)
new_list += [(p1, s, p_angle), (s, u, p_angle+DEG60), \
(u, t, p_angle-DEG60), (t, p2, p_angle)]
new_list = repl_edge(n-1, new_list)
return new_list
n = int(sys.stdin.readline())
p1 = (0.0, 0.0)
p2 = (100.0, 0.0)
edges = [(p1, p2, 0.0)]
edges = repl_edge(n, edges)
for edge in edges:
print(round(edge[0][0],6), round(edge[0][1],6))
print(round(edges[-1][1][0],6), round(edges[-1][1][1],6))
| 1 | 124,152,957,502 | null | 27 | 27 |
K = int(input())
S = input()
s = len(S)
L = []
mod = 10 ** 9 + 7
N = 2 * 10**6
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
def cmb(n, r):
return fac[n] * ( finv[r] * finv[n-r] % mod ) % mod
for i in range(2, N + 1):
fac.append( ( fac[-1] * i ) % mod )
inv.append( mod - ( inv[mod % i] * (mod // i) % mod ) )
finv.append( finv[-1] * inv[-1] % mod )
for i in range(K+1):
L.append( cmb(i+s-1, s-1) * pow(25, i, mod) % mod )
ans = []
for i, x in enumerate(L):
if i == 0:
ans.append(x)
else:
ans.append( ( ans[i-1]*26%mod + x ) % mod )
print(ans[K])
|
k = int(input())
s = input()
mod = 10**9 + 7
ans = 0
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
comb = Combination(2*10**6+10)
for i in range(k+1):
ans += pow(25, k-i, mod) * pow(26, i, mod) * comb(len(s)+k-i-1, len(s)-1)
ans %= mod
print(ans)
| 1 | 12,790,143,255,092 | null | 124 | 124 |
import sys
sys.setrecursionlimit(10**9)
n, m, k = map(int, input().split())
F = [[] for i in range(n)]
B = [[] for i in range(n)]
l = [0]*n
for i in range(m):
a, b = map(int, input().split())
F[a - 1].append(b - 1)
F[b - 1].append(a - 1)
for i in range(k):
c, d = map(int, input().split())
B[c - 1].append(d - 1)
B[d - 1].append(c - 1)
seen = [0]*n
cnt = 0
r = []
def dfs(x):
if seen[x] == 0:
r[cnt].add(x)
seen[x] = 1
for i in F[x]:
dfs(i)
for i in range(n):
if seen[i] == 0:
r.append(set())
dfs(i)
cnt += 1
ans = [0]*n
for i in r:
lr = len(i)
for j in i:
ans[j] = lr - len(F[j]) - len(i & set(B[j])) - 1
print(*ans)
|
N,K = map(int,input().split())
count =0
for i in range(K,N+2):
if i ==N+1:
count+=1
else:
a = (i-1)
a = a/2
a = a*i
b = (N+N-(i-1))/2
b = b*i
count +=b-a+1
#print(i,count,a,b)
print(int(count%(10**9+7)))
| 0 | null | 47,390,571,072,550 | 209 | 170 |
n,k=map(int,input().split())
# 1以上k以下の整数がn個
mod=int(1e+9 + 7)
d=[0]*(k+1)
ans=0
for i in range(k,0,-1):
m=k//i
d[i]=pow(m,n, mod)
d[i]-=sum([d[j*i]for j in range(2,m+1)])
ans+=(d[i]*i)%mod
print((ans)%mod)
#print(d)
|
MOD = int(1e9+7)
def main():
N, K = map(int, input().split())
dp = [0] * (K+1)
ans = 0
for i in range(1, K+1)[::-1]:
tmp = pow(K//i, N, MOD)
for j in range(i*2, K+1, i):
tmp = (tmp - dp[j]) % MOD
dp[i] = tmp
ans = (ans + tmp * i) % MOD
print(ans)
if __name__ == "__main__":
main()
| 1 | 36,699,551,893,200 | null | 176 | 176 |
# -*- coding: utf-8 -*-
loop = 1
while(loop):
l = input().strip().split()
H = int(l[0])
W = int(l[1])
if(H == 0 and W == 0):
break
else:
for y in (range(H)):
for x in (range(W)):
if((x % 2 == 0) and(y % 2 == 0) or (x % 2 != 0) and(y % 2 != 0)):
print("#",end="")
else:
print(".",end="")
print()
print()
|
N, K = map(int, input().split())
data = list(map(int, input().split()))
for x in range(K):
# print(data)
raise_data = [0] * (N + 1)
for i, d in enumerate(data):
raise_data[max(0, i - d)] += 1
raise_data[min(N, i + d + 1)] -= 1
height = 0
ended = 0
for i in range(N):
height += raise_data[i]
data[i] = height
if height == N:
ended += 1
if ended == N:
# print(x)
break
print(*data)
| 0 | null | 8,146,048,240,928 | 51 | 132 |
N = int(input())
S = input()
ris = [i for i, s in enumerate(S) if s == "R"]
gis = [i for i, s in enumerate(S) if s == "G"]
bis = [i for i, s in enumerate(S) if s == "B"]
all = len(ris) * len(gis) * len(bis)
cnt = 0
for i in range(N):
for j in range(i+1, N):
k = 2*j - i
if 0 <= k < N:
if S[i] != S[j] and S[i] != S[k] and S[j] != S[k]:
cnt += 1
ans = all - cnt
print(ans)
|
n = int(input())
s = input()
#print(s)
tot = s.count('R') * s.count('G') * s.count('B')
#print(tot)
for i in range(n):
for d in range(1,n):
j = i+d
k = j+d
if k > n-1:
break
if s[i]!=s[j] and s[j]!=s[k] and s[k]!=s[i]:
tot -= 1
print(tot)
| 1 | 36,021,043,239,300 | null | 175 | 175 |
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return map(list, zip(*read_all))
#################
T1,T2 = LI()
A1,A2 = LI()
B1,B2 = LI()
if A1 > B1 and A2 > B2:
print(0)
exit()
if A1 < B1 and A2 < B2:
print(0)
exit()
if A1 > B1:
t = (A1-B1)*T1 / (B2-A2)
delta = (A1-B1)*T1+(A2-B2)*T2
if t == T2:
print('infinity')
exit()
elif t > T2:
print(0)
exit()
else:
if delta > 0:
print(math.floor((T2-t)*(B2-A2)/delta) + 1)
exit()
else:
x = (A1-B1)*T1 / (-delta)
if int(x) == x:
print(2*int(x))
else:
print(2*math.floor(x)+1)
else:
t = (B1-A1)*T1 / (A2-B2)
delta = (B1-A1)*T1+(B2-A2)*T2
if t == T2:
print('infinity')
exit()
elif t > T2:
print(0)
exit()
else:
if delta > 0:
print(math.floor((T2-t)*(A2-B2)/delta) + 1)
exit()
else:
x = (B1-A1)*T1 / (-delta)
if int(x) == x:
print(2*int(x))
else:
print(2*math.floor(x)+1)
|
while True:
m, t, f = map( int, raw_input().split())
if m == -1 and t == -1 and f == -1:
break
if m == -1 or t == -1:
r = "F"
elif (m + t) >= 80:
r = "A"
elif (m + t) >= 65:
r = "B"
elif (m + t) >= 50:
r = "C"
elif (m + t) >= 30:
if f >= 50:
r = "C"
else:
r = "D"
else:
r = "F"
print r
| 0 | null | 66,079,191,918,752 | 269 | 57 |
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
N = input()
K = int(input())
lenN = len(N)
# has less number before
dp0 = [[0]*5 for _ in range(lenN+1)]
# not had yet
dp1 = [[0]*5 for _ in range(lenN+1)]
dp1[0][0] = 1
for i in range(lenN):
k = int(N[i])
for zero in range(4):
dp0[i+1][zero] += dp0[i][zero]
dp0[i+1][zero+1] += dp0[i][zero] * 9
if k != 0:
dp0[i+1][zero] += dp1[i][zero]
dp0[i+1][zero+1] += dp1[i][zero] * (k-1)
dp1[i+1][zero+1] += dp1[i][zero]
else:
dp1[i+1][zero] += dp1[i][zero]
ans = dp0[lenN][K] + dp1[lenN][K]
print(ans)
if __name__ == '__main__':
solve()
|
n = int(input())
a = [set() for i in range(n)]
e = []
for i in range(n-1):
b, c = map(int, input().split())
b -= 1
c -= 1
a[b].add(c)
a[c].add(b)
e.append(c)
col = [0 for i in range(n)]
visited = [False for i in range(n)]
visited[0] = True
v = [0]
while v:
d = v.pop(0)
k = 1
for i in a[d]:
if visited[i] == False:
if col[d] == k:
k += 1
col[i] = k
visited[i] = True
v.append(i)
k += 1
print (max(col))
for i in e:
print (col[i])
| 0 | null | 105,441,523,128,700 | 224 | 272 |
N = int(input())
a = list(map(int, input().split()))
left = []
for i in range(N):
if left:
if a[i] == left[-1] + 1:
left.append(a[i])
else:
if a[i] == 1:
left.append(a[i])
if left:
print(N - len(left))
else:
print(-1)
|
r = int(input())
print(r * 3.14159265 * 2);
| 0 | null | 73,082,642,843,672 | 257 | 167 |
# coding: utf-8
def getint():
return int(input().rstrip())
def main():
n = getint()
values = []
for i in range(n):
values.append(getint())
maxv = values[1] - values[0]
minv = values[0]
for j in range(1,n):
maxv = max(maxv, values[j]-minv)
minv = min(minv, values[j])
print(maxv)
if __name__ == '__main__':
main()
|
N = int(input())
if(N%2 != 0):
print(0)
else:
cnt = 0
n = 1
while n <= N:
n *= 5
if(n > N):
break
num = n*2
cnt += N//num
print(cnt)
| 0 | null | 58,107,188,869,552 | 13 | 258 |
a,b=map(int,input().split())
for i in range(2000):
if int(i*0.08)==a and int(i*0.1)==b:
print(i)
exit()
print("-1")
|
#!/usr/bin/env python3
import sys
import math
a, b = map(int, input().split())
c = math.ceil(b / 0.1)
for i in range(c, c + 10):
if math.floor(i * 0.1) == b:
if math.floor(i * 0.08) == a:
print(i)
sys.exit()
print(-1)
| 1 | 56,319,436,185,470 | null | 203 | 203 |
N,A,B = map(int,input().split())
if A%2 != 0 and B%2 == 0:
ans = (B-A-1)//2 + min(A-1,N-B) + 1
elif A%2 == 0 and B%2 != 0:
ans = (B-A-1)//2 + min(A-1,N-B) + 1
else:
ans = (B-A)//2
print(ans)
|
s=input()
n=len(s)//2
s1=s[:n]
s2=s[-n:]
s2=s2[::-1]
cnt=0
for i in range(len(s1)):
if s1[i]!=s2[i]:
cnt+=1
print(cnt)
| 0 | null | 114,625,233,963,172 | 253 | 261 |
import sys
def f(P):
i=0
for _ in[0]*k:
s=0
while s+w[i]<=P:
s+=w[i];i+=1
if i==n: return n
return i
n,k=map(int,input().split())
w=list(map(int,sys.stdin.read().splitlines()))
l=0;r=n*100000
while r-l>1:
m=(l+r)//2
if f(m)>=n:r=m
else:l=m
print(r)
|
n,k = map(int,input().split())
w = []
for i in range(0,n):
w.append(int(input()))
def check(p):
i = 0
for j in range(0,k):
sm = 0
while sm + w[i] <= p:
sm = sm + w[i]
i = i + 1
if i == n:
return n
return i
def solve():
r = 1000000000
l = 0
while r-l > 1:
mid = int((r+l)/2)
v = check(mid)
if(v >= n):
r = mid
else:
l = mid
return r
print(solve())
| 1 | 83,636,452,380 | null | 24 | 24 |
from math import sqrt
n = int(input())
p = 0
for i in range(n):
x = int(input())
ad = 1
if x>2 and x%2==0:
ad = 0
else:
j=3
while j < (int(sqrt(x))+1):
if x%j == 0:
ad = 0
break
else:
j += 2
p += ad
print(p)
|
import math
N = input()
c = 0
p = [0 for i in range(N)]
for i in range(0,N):
p[i] = input()
for i in range(N):
s = math.sqrt(p[i])
j = 2
while(j <= s):
if(p[i]%j == 0):
break
j += 1
if(j > s):
c += 1
print c
| 1 | 9,491,739,602 | null | 12 | 12 |
def check(p):
s = w[0]
track = 1
for i in range(1, n):
if s + w[i] <= p:
s += w[i]
else:
track += 1
if track > k: return False
s = w[i]
return True
n, k = [int(i) for i in input().split()]
w = []
for i in range(n):
w.append(int(input()))
L = max(w)
R = sum(w)
if check(L):
print(L)
else:
while L + 1 < R:
M = (L + R) // 2
if check(M):
R = M
else:
L = M
print(R)
|
def f(p, k, W):
i = 0
t = 0
s = 0
while i < len(W) and t < k:
if s + W[i] <= p:
s += W[i]
i += 1
else:
s = 0
t += 1
return i
n, k = map(int, input().split())
W = [int(input()) for _ in range(n)]
l = 0
r = 100000 * 10000 // k
while r - l > 1:
mid = (l + r) // 2
v = f(mid, k, W)
if v >= n:
r = mid
else:
l = mid
print(r)
| 1 | 88,645,822,608 | null | 24 | 24 |
n,k = map(int, input().split())
a_list = list(map(int, input().split()))
for i in range(len(a_list)):
if i+k > len(a_list)-1:
break
if a_list[i] < a_list[i+k]:
print("Yes")
else:
print("No")
|
N, K = input().split()
N = int(N)
K = int(K)
scores = [int(s) for s in input().split()]
sums = []
k = K-1
for i in range(k,N-1):
if(scores[i-k] < scores[i+1]):
print("Yes")
else:
print("No")
| 1 | 7,116,224,146,582 | null | 102 | 102 |
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
N = int(input())
d1 = make_divisors(N)
d2 = make_divisors(N - 1)
ans = len(d2) - 1
for n in d1:
if n == 1:
continue
n2 = N
while n2 % n == 0:
n2 //= n
if n2 % n == 1:
if n not in d2:
ans += 1
print(ans)
|
N, K = map(int,input().split())
def abc(n,m):
a,b = divmod(n,m)
return a,b
count = 0
a = 1
while a !=0 :
a,b = abc(N,K)
N = a
count += 1
print(count)
| 0 | null | 53,053,541,770,732 | 183 | 212 |
def roundone(a, b):
abc = "123"
return abc.replace(a, "").replace(b, "")
def main():
a = str(input())
b = str(input())
print(roundone(a, b))
if __name__ == '__main__':
main()
|
A = input()
B = input()
answer = [str(i) for i in range(1, 4)]
answer.remove(A)
answer.remove(B)
print(''.join(answer))
| 1 | 111,192,895,656,050 | null | 254 | 254 |
K = int(input())
ans = ""
for _ in range(K):
ans += "ACL"
print(ans)
|
import sys
a = int(sys.stdin.readline().strip())
print("ACL" * a)
| 1 | 2,148,428,277,880 | null | 69 | 69 |
n=int(input())
a=list(map(int,input().split()))
MOD= 10**9 + 7
toki = [0]*(n+1)
shigi=0
toki[0] = sum(a)-a[0]
for i in range(1, n-1):
toki[i] = toki[i-1]-a[i]
for i in range(n-1):
shigi += (a[i] * toki[i])
print(shigi%MOD)
|
s = input()
while s[:2] == 'hi':
s = s[2:]
if s == '': print('Yes')
else: print('No')
| 0 | null | 28,416,731,452,338 | 83 | 199 |
H,N=map(int,input().split())
deathblows=map(int,input().split())
if sum(deathblows) >= H:
print('Yes')
else:
print('No')
|
h, n = map(int, input().split())
print('No' if sum(list(map(int, input().split())))<h else 'Yes')
| 1 | 78,258,355,182,930 | null | 226 | 226 |
import math
from math import cos, sin
a,b,C=map(float,input().split())
C = math.radians(C)
S = 0.5*a*b*sin(C)
L = math.sqrt(b**2+a**2-2*a*b*cos(C))+a+b
h = 2*S / a
print(S)
print(L)
print(h)
|
import math
n = int(input())
for i in range(n+1):
if math.floor(i * 1.08) == n:
print(i)
exit(0)
print(":(")
| 0 | null | 62,738,834,777,860 | 30 | 265 |
N,K = map(int,input().split())
m = 10**9 + 7
ans = 0
cnt_arr = [0]*(K+1)
for i in range(K,0,-1):
cnt = pow(int(K//i), N, mod=m)
j = 2
while i*j<=K:
cnt -= cnt_arr[i*j]
j+=1
cnt_arr[i]=cnt
ans += i*cnt
print(int(ans%m))
|
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N,M=MI()
S=list(input())
S2=S[::-1]
now=0
ans=[]
while now!=N:
nxt=now+M
if nxt>N:
nxt=N
while S2[nxt]=="1":
nxt-=1
if now==nxt:
ans=[-1]
break
ans.append(nxt-now)
now=nxt
print(' '.join(map(str, ans[::-1])))
main()
| 0 | null | 88,129,069,400,492 | 176 | 274 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce, lru_cache
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = 10**6#float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
#from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, T = MAP()
AB = [LIST() for _ in range(N)]
AB.sort(key = lambda x:x[0])
t = [0]*T
ans = 0
for A, B in AB:
for i in range(T-1, 0, -1):
if t[i]:
if T <= i+A:
ans = max(ans, t[i]+B)
else:
t[i+A] = max(t[i+A], t[i]+B)
if T <= A:
ans = max(ans, B)
else:
t[A] = max(t[A], B)
ans = max(ans, max(t))
print(ans)
|
time = int(input())
hour=int(time/3600)
minutes=int((time-hour*3600)/60)
seconds=int(time-(hour*3600)-(minutes*60))
print(str(hour)+':'+str(minutes)+':'+str(seconds))
| 0 | null | 76,092,894,808,320 | 282 | 37 |
n = int(input())
ls = [int(input()) for _ in range(n)]
result = []
biggest = 0
for i in range(n-1):
last = ls.pop()
if last > biggest:
biggest = last
result.append(last - min(ls))
print(max(result))
|
a,b,c=input().split()
if(a==b)+(b==c)+(c==a)==1:
print('Yes')
else:
print('No')
| 0 | null | 33,959,434,536,580 | 13 | 216 |
#coding:UTF-8
def FN(n):
if n==0 or n==1:
F[n]=1
return F[n]
if F[n]!=None:
return F[n]
F[n]=FN(n-1)+FN(n-2)
return F[n]
if __name__=="__main__":
n=int(input())
F=[None]*(n+1)
ans=FN(n)
print(ans)
|
import math
a, b, x = map(int, input().split())
if x/(a*a*b) <= 0.5: #水が水筒の半分以下の場合
h = x/a/b*2
hy2 = (h*h + b*b)
cosa = (hy2 + b*b - h*h )/(2*(hy2**0.5)*b)
d = 180 - math.degrees(math.acos(cosa)) - 90
else:
rest = (a*a*b - x)/a
tan = rest*2/(a*a) #空の部分の面積は、a*atanθ/2 = a*a*b - x
d = math.degrees(math.atan(tan))
print(d)
| 0 | null | 81,493,554,470,900 | 7 | 289 |
import collections
import sys
S1 = collections.deque()
S2 = collections.deque()
S3 = collections.deque()
for i, j in enumerate(sys.stdin.readline()):
if j == '\\':
S1.append(i)
elif j == '/':
if S1:
left_edge = S1.pop()
new_puddle = i - left_edge
while True:
if S2:
if S2[-1] > left_edge:
S2.pop()
new_puddle += S3.pop()
else:
break
else:
break
S2.append(left_edge)
S3.append(new_puddle)
else:
pass
print(sum(S3))
print(len(S3), *S3)
|
sectional_view = input()
list_index_down = []
list_index_area_left = []
list_area = []
for index_now, mark in enumerate(sectional_view):
if mark == "\\":
list_index_down += [index_now]
elif mark == "/" and list_index_down:
index_down_last = list_index_down.pop()
area = index_now - index_down_last
while ((list_index_area_left) and
(list_index_area_left[-1] > index_down_last)):
area += list_area.pop()
list_index_area_left.pop()
list_index_area_left.append(index_down_last)
list_area.append(area)
print(sum(list_area))
print(len(list_area),*(list_area))
| 1 | 61,211,412,848 | null | 21 | 21 |
N, M = map(int, input().split())
totalN = 1/2*(N-1)*N
totalM = 1/2*(M-1)*M
import math
print(math.floor(totalN + totalM))
|
from sys import stdin
input = stdin.readline
def Judge(S, T):
ls = len(S)
lt = len(T)
m = 0
for i in range(ls-lt+1):
tmp = 0
for j in range(lt):
if S[i+j] == T[j]:
tmp += 1
if m < tmp:
m = tmp
return lt - m
S = input().strip()
T = input().strip()
print(Judge(S, T))
| 0 | null | 24,587,118,909,610 | 189 | 82 |
def f(a):
return a * a % m
n, x, m = map(int, input().split())
a = x
i = 1
li = [a]
num2index = {a: 1}
while f(a) not in num2index and i + 1 <= n:
i += 1
a = f(a)
li.append(a)
num2index[a] = i
if i == n:
ans = sum(li)
else:
before_loop = num2index[f(a)]
loop, left = divmod(n - i, i - before_loop + 1)
loop_sm = loop * sum(li[before_loop-1:])
left_sm = sum(li[before_loop-1:before_loop-1+left])
ans = sum(li) + loop_sm + left_sm
print(ans)
|
s=input()
print('YNeos'[s[2::3]!=s[3:5]::2])
| 0 | null | 22,581,247,205,866 | 75 | 184 |
MOD = 10 ** 9 + 7
n, k = map(int, input().split())
alst = list(map(int, input().split()))
alst.sort()
if n == k:
ans = 1
for num in alst:
ans *= num
ans %= MOD
print(ans)
exit()
if k == 1:
print(alst[-1] % MOD)
exit()
if alst[0] >= 0:
ans = 1
alst.sort(reverse = True)
for i in range(k):
ans *= alst[i]
ans %= MOD
print(ans)
exit()
if alst[-1] <= 0:
ans = 1
if k % 2 == 1:
alst = alst[::-1]
for i in range(k):
ans *= alst[i]
ans %= MOD
print(ans)
exit()
blst = []
for num in alst:
try:
blst.append([abs(num), abs(num) // num])
except ZeroDivisionError:
blst.append([abs(num), 0])
blst.sort(reverse = True,key = lambda x:x[0])
if blst[k - 1] == 0:
print(0)
exit()
minus = 0
last_minus = 0
last_plus = 0
ans_lst = []
for i in range(k):
if blst[i][1] == -1:
minus += 1
last_minus = blst[i][0]
elif blst[i][1] == 1:
last_plus = blst[i][0]
else:
print(0)
exit()
ans_lst.append(blst[i][0])
next_minus = 0
next_plus = 0
flg_minus = False
flg_plus = False
for i in range(k, n):
if blst[i][1] == -1 and (not flg_minus):
next_minus = blst[i][0]
flg_minus = True
if blst[i][1] == 1 and (not flg_plus):
next_plus = blst[i][0]
flg_plus = True
if (flg_plus and flg_minus) or blst[i][1] == 0:
break
if minus % 2 == 0:
ans = 1
for num in ans_lst:
ans *= num
ans %= MOD
print(ans)
else:
minus_s = last_minus * next_minus
plus_s = last_plus * next_plus
ans = 1
if minus == k:
ans_lst.remove(last_minus)
ans_lst.append(next_plus)
elif minus_s == plus_s == 0:
if next_minus == 0:
ans_lst.remove(last_minus)
ans_lst.append(next_plus)
else:
print(0)
exit()
elif minus_s > plus_s:
ans_lst.remove(last_plus)
ans_lst.append(next_minus)
else:
ans_lst.remove(last_minus)
ans_lst.append(next_plus)
for num in ans_lst:
ans *= num
ans %= MOD
print(ans)
|
n = int(input())
s = input()
ans = 0
ans = s.count('R')*s.count('G')*s.count('B')
for i in range(0,n-2):
for j in range(1,n-1):
k = -i + 2*j
if j < k <= n-1:
if s[i] == s[j]:
continue
if s[i] == s[k]:
continue
if s[j] == s[k]:
continue
else:
continue
ans -= 1
print(ans)
| 0 | null | 22,672,908,507,650 | 112 | 175 |
n = int(input())
if(n % 2 !=0):
print(0)
exit()
ketasu = len(str(n))
ans = 0
for i in range(1, 100):
ans += n // (2 * 5 **i)
print(ans)
|
# 41m AC
from collections import Counter
import sys
def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
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 S(): return input()
def LS(): return input().split()
INF = float('inf')
n = I()
if n % 2 != 0:
print(0)
exit()
ans = 0
i = 10
while i <= n:
ans += n // i
i *= 5
print(ans)
| 1 | 115,790,972,631,488 | null | 258 | 258 |
s = input()
days_of_the_week = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
n = days_of_the_week.index(s)
print(7 - days_of_the_week.index(s))
|
week_list =["","SAT","FRI","THU","WED","TUE","MON","SUN"]
print(week_list.index(input()))
| 1 | 133,229,648,216,100 | null | 270 | 270 |
days = ['SUN','MON','TUE','WED','THU','FRI','SAT']
s = input()
x = days.index(s)
print(7-x)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
SS = ['SUN','MON','TUE','WED','THU','FRI','SAT']
S = readline().decode().rstrip()
for i in range(7):
if S == SS[i]:
print(7-i)
sys.exit()
| 1 | 133,634,344,267,724 | null | 270 | 270 |
#B
S=input()
N=len(S)
con_2=S[:(N-1)//2]
con_3=S[((N+3)//2-1):]
if S==S[::-1] and con_2==con_2[::-1] and con_3==con_3[::-1]:
print('Yes')
else:
print('No')
|
def main():
s = input()
n = len(s)
rule1 = True
rule2 = True
rule3 = True
for i in range(n):
if s[i] != s[n - 1 - i]:
rule1 = False
break
for i in range(n // 2):
if s[i] != s[n // 2 - 1 - i]:
rule2 = False
break
for i in range(n // 2):
if s[n // 2 + 1 + i] != s[n - 1 - i]:
rule3 = False
break
if rule1 and rule2 and rule3:
ans = "Yes"
else:
ans = "No"
print(ans)
if __name__ == "__main__":
main()
| 1 | 46,332,393,632,782 | null | 190 | 190 |
from collections import deque
import sys
input = sys.stdin.readline
n,m=map(int,input().split())
k=[0]*(n+1)
r=[[] for i in range(n+1)]
R=[[] for i in range(n+1)]
for i in range(m):
a,b=map(int,input().split())
r[a].append(b)
r[b].append(a)
R[a].append(b)
R[b].append(a)
dep=[-1]*(n+1)
dep[0]=0
dep[1]=0
data=deque([1])
d=0
while len(data)>0:
p=data.popleft()
for i in r[p]:
if dep[i]==-1:
dep[i]=dep[p]+1
k[i]=p
data.append(i)
r[p]=[]
if not all(dep[i+1]>=0 for i in range(n)):
print("No")
else:
print("Yes")
for i in range(2,n+1):
print(k[i])
|
#create date: 2020-07-02 22:54
import sys
stdin = sys.stdin
from collections import deque
def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def main():
n, m = na()
g = [[] for i in range(n)]
for i in range(m):
a, b = na()
g[a-1].append(b-1)
g[b-1].append(a-1)
q = deque([0])
d = [-1] * n
d[0] = 0
while q:
v = q.popleft()
for w in g[v]:
if d[w] != -1:
continue
d[w] = v
q.append(w)
if -1 in d:
print("No")
else:
print("Yes")
for di in d[1:]:
print(di+1)
if __name__ == "__main__":
main()
| 1 | 20,315,377,523,868 | null | 145 | 145 |
n,m = map(int,input().split())
import heapq
def dijkstra(s):
d = 1
hq = [(0, s)]
heapq.heapify(hq) # リストを優先度付きキューに変換
cost = [float('inf')] * n # 行ったことのないところはinf
cost[s] = 0 # 開始地点は0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]: # コストが現在のコストよりも高ければスルー
continue
for u in e[v]:
tmp = 1 + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost
e = [[] for _ in range(n)]
for _ in range(m):
a,b = map(int,input().split())
a,b = a-1, b-1
e[a].append(b)
e[b].append(a) # 有向グラフでは削除
d = dijkstra(0)
# print(d)
# print(e)
ans = [0]*(n)
for i in range(1,n):
for j in e[i]:
# print(i,j)
if d[j] == d[i] - 1:
ans[i] = j + 1
continue
print("Yes")
print(*ans[1:], sep="\n")
|
def resolve():
x,y=(int(i) for i in input().split())
if x==1 and y==1:
print(1000000)
return
c=0
if x==1:
c+=300000
if x==2:
c+=200000
if x==3:
c+=100000
if y==1:
c+=300000
if y==2:
c+=200000
if y==3:
c+=100000
print(c)
if __name__ == "__main__":
resolve()
| 0 | null | 80,592,635,953,868 | 145 | 275 |
X=int(input())
ans=0
for i in range(X,10**5+100):
cond=True
for j in range(2,int(i**0.5)+1):
if i%j==0:
cond=False
break
if cond:
ans=i
break
print(ans)
|
X = int(input())
res = X
j = 0
Flags = []
flg = True
for i in range(2,X+1):
j = i+i
flg = True
while flg:
Flags.append(j)
if j > X:
flg = False
j += i
while res in Flags:
res += 1
print(res)
| 1 | 105,971,590,978,990 | null | 250 | 250 |
A=int(input())
B=int(input())
if 1 not in [A,B]:
print(1)
if 2 not in [A,B]:
print(2)
if 3 not in [A,B]:
print(3)
|
a = int(input())
b = int(input())
ans = list(filter(lambda x: x != a and x != b, [1, 2, 3]))
print(ans[0])
| 1 | 110,887,620,225,162 | null | 254 | 254 |
N = int(input())
query = [[] for _ in range(N)]
color = []
m = [0]*N
for n in range(N-1):
a, b = map(int, input().split())
query[a-1].append(b-1)
query[b-1].append(a-1)
color.append((min(a, b), max(a, b)))
m[a-1] += 1
m[b-1] += 1
print(max(m))
from collections import deque
queue = deque()
queue.appendleft(0)
checked = [-1]*N
checked[0] = 0
dic = {}
while queue:
v = queue.pop()
oya = checked[v]
lis = query[v]
cnt = 1
for i in lis:
if checked[i]!=-1:
continue
if cnt==oya:
cnt += 1
queue.appendleft(i)
dic[(min(v+1, i+1), max(v+1, i+1))] = cnt
checked[i] = cnt
cnt += 1
for n in range(N-1):
a, b = color[n]
print(dic[(min(a, b), max(a, b))])
|
N = int(input())
ab = [list(map(int,input().split())) for i in range(N-1)]
graph = [[] for _ in range(N+1)]
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
from collections import deque
todo = deque([1])
seen = deque([])
parent = [0] * (N+1)
# 親と子の関係を作る
while todo:
x = todo.popleft()
seen.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
todo.append(y)
# 根以外の頂点は、唯一の親を持つことから、
# vの親がpであるとき → color[v] に辺 pvの色を持たせると定めて色を管理
color = [-1] * (N+1)
for x in seen:
ng = color[x]
c = 1
for y in graph[x]:
if y == parent[x]:
continue
if c == ng:
c += 1
color[y] = c
c += 1
ans = []
for a,b in ab:
ans.append(color[b])
print(max(ans))
for i in ans:
print(i)
| 1 | 136,120,433,324,724 | null | 272 | 272 |
# 1 <= N <= 1000000
N = int(input())
total = []
# N項目までに含まれる->N項目は含まない。だからN項目は+1で外す。
for x in range(1, N+1):
if x % 15 == 0:
"FizzBuzz"
elif x % 5 == 0:
"Buzz"
elif x % 3 == 0:
"Fizz"
else:
total.append(x) #リストに加える
print(sum(total))
|
N = int(input())
n = min(N, 10**6)
is_Prime = [True] * (n + 1)
is_Prime[0] = False
is_Prime[1] = False
for i in range(2, int(n**(1/2)+1)):
for j in range(2*i, n+1, i):
if j % i == 0:
is_Prime[j] = False
P = [i for i in range(n+1) if is_Prime[i]]
count = 0
for p in P:
count_p = 0
while N % p == 0:
count_p += 1
N /= p
count += int((-1+(1+8*count_p)**(1/2))/2)
if p == P[-1] and N != 1:
count += 1
print(count)
| 0 | null | 26,027,187,888,898 | 173 | 136 |
n = int(input())
cnt = [0] * 11000
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
value = x*x + y*y + z*z + x*y + y*z + z*x
if value <= n:
cnt[value] += 1
for i in range(1,n+1):
print(cnt[i])
|
from collections import deque
n = int(input())
q = deque(range(1, 10))
for _ in range(n - 1):
x = q.popleft()
r = x % 10
y = 10 * x
if r == 0:
q.extend([y, y+1])
elif r == 9:
q.extend([y+8, y+9])
else:
q.extend([y+r-1, y+r, y+r+1])
print(q.popleft())
| 0 | null | 24,038,502,052,698 | 106 | 181 |
for i in range(1,10):
for j in range(1,10):
print "%dx%d=%d" % (i,j,i*j)
|
i = 1
while i < 10 :
j = 1
while j < 10 :
print(str(i) + "x" + str(j) + "=" + str(i*j))
j += 1
i += 1
| 1 | 187,340 | null | 1 | 1 |
def modinv(a,m):
return pow(a,m-2,m)
n,k = map(int,input().split())
P = 10**9+7
ans = 1
nCl = 1
n1Cl = 1
for l in range(1,min(k+1,n)):
nCl = nCl*(n+1-l)*modinv(l,P)%P
n1Cl = n1Cl*(n-l)*modinv(l,P)%P
ans = (ans+nCl*n1Cl)%P
print(ans)
|
n,k=map(int,input().split())
k=min(k,n-1)
mod=10000*100000+7
def mpow(a,b,m=100000*10000+7):#returns a**b%m
ret=1
while b>0:
if b&1:
ret=(ret*a)%m
a=(a*a)%m
b>>=1
return ret
fact=[1]*(n+1)
ifact=[1]*(n+1)
for i in range(2,n+1):
fact[i]=(fact[i-1] *i)%mod
ifact[n]=mpow(fact[n],mod-2)
for i in range(n-1,1,-1):
ifact[i]=((i+1)*ifact[i+1])%mod
def nCr(n,r):
if r==0 or r==n:
return 1
val=(fact[n]*ifact[r])%mod
return (val*ifact[n-r])%mod
ans=0
for h in range(k+1):
ans=(ans+(nCr(n,h)*nCr(n-1,n-h-1))%mod)%mod
print(ans)
| 1 | 66,934,765,288,704 | null | 215 | 215 |
n, m = input().split()
a = list(map(int, input().split()))
s = 0
for i in a:
s += int(i)
if int(s) <= int(n):
print(int(n) - int(s))
else:
print("-1")
|
N, M = map(int, input().split())
A_list = list(map(int, input().split()))
for i in range(M):
N -= A_list[i]
if N < 0:
print(-1)
break
if i == M-1:
print(N)
| 1 | 32,029,037,799,708 | null | 168 | 168 |
from collections import deque
n = int(input())
adj = [[]]
for i in range(n):
adj.append(list(map(int, input().split()))[2:])
ans = [-1]*(n+1)
ans[1] = 0
q = deque([1])
visited = [False] * (n+1)
visited[1] = True
while q:
x = q.popleft()
for y in adj[x]:
if visited[y] == False:
q.append(y)
ans[y] = ans[x]+1
visited[y] = True
for j in range(1, n+1):
print(j, ans[j])
|
x,y = map(int,input().split())
a = (4*x-y)/2
b = (-2*x+y)/2
if a%1 == 0 and 0 <= a and b%1 == 0 and 0 <=b:
print("Yes")
else:
print("No")
| 0 | null | 6,913,353,269,060 | 9 | 127 |
# coding:utf-8
def gcd(a,b):
while b:
a, b = b, a % b
return a
n = map(int, raw_input().split())
n.sort(reverse=True)
print gcd(n[0],n[1])
|
x,y=map(int,input().split())
c=x%y
while c!=0:
x=y
y=c
c=x%y
print(y)
| 1 | 7,156,652,860 | null | 11 | 11 |
n = int(input())
a = list(map(int, input().split()))
a = [[e, i] for i, e in enumerate(a, 1)]
a.sort(reverse=True)
dp = [[0] * (n + 1) for _ in range(n + 1)]
for t, (e, idx) in enumerate(a, 1):
for i in range(1, t + 1):
j = t - i
dp[i][j] = max(dp[i][j], dp[i-1][j] + e * abs(idx - i))
for j in range(1, t + 1):
i = t - j
dp[i][j] = max(dp[i][j], dp[i][j-1] + e * abs(idx - (n - j + 1)))
ans = 0
for i in range(1, n + 1):
j = n - i
ans = max(ans, dp[i][j])
print(ans)
|
a_1= [[0 for i in range(10)] for j in range(3)]
a_2= [[0 for i in range(10)] for j in range(3)]
a_3= [[0 for i in range(10)] for j in range(3)]
a_4= [[0 for i in range(10)] for j in range(3)]
def print_ninzu(a):
print("",end=" ")
print(" ".join(map(str,a[0])))
print("",end=" ")
print(" ".join(map(str,a[1])))
print("",end=" ")
print(" ".join(map(str,a[2])))
n = int(input())
for i in range(n):
com = list(map(int,input().split()))
if com[0] == 1:
a_1[com[1]-1][com[2]-1] += com[3]
if com[0] == 2:
a_2[com[1]-1][com[2]-1] += com[3]
if com[0] == 3:
a_3[com[1]-1][com[2]-1] += com[3]
if com[0] == 4:
a_4[com[1]-1][com[2]-1] += com[3]
print_ninzu(a_1)
print("####################")
print_ninzu(a_2)
print("####################")
print_ninzu(a_3)
print("####################")
print_ninzu(a_4)
| 0 | null | 17,496,166,865,288 | 171 | 55 |
n = int(input())
s = input()
nr = s.count('R')
nw = len(s)-nr
a = ('R'*nr)+('W'*nw)
c = 0
for i in range(n):
if(s[i:i+1] != a[i:i+1]):
c += 1
print(c // 2)
|
n = int(input())
cl = input()
if cl[:cl.count('R')].count('W') != 0:
print(min(cl[:cl.count('R')].count('W'), cl.count('R')))
else:
print(0)
| 1 | 6,297,840,807,452 | null | 98 | 98 |
X, Y, Z = map(int, input().split())
print('{} {} {}'.format(Z, X, Y))
|
X, Y, Z = list(map(str, input().split()))
print(Z+' '+X+' '+Y)
| 1 | 38,074,771,621,950 | null | 178 | 178 |
n,m = map(int, input().split())
d = list(map(int, input().split()))
inf = float('inf')
dp = [inf for i in range(n+1)]
dp[0] = 0
for i in range(m):
for j in range(d[i], n+1):
dp[j] = min(dp[j], dp[j-d[i]]+1)
print(dp[-1])
|
import sys
if __name__ == "__main__":
n, m = map(lambda x: int(x), input().split())
coins = list(map(lambda x: int(x), input().split()))
table = [sys.maxsize] * (n + 2)
table[0] = 0
for i in range(n + 1):
for coin in coins:
if (i + coin <= n):
table[i + coin] = min(table[i + coin], table[i] + 1)
print(table[n])
| 1 | 136,891,216,782 | null | 28 | 28 |
a = input()
s = a % 60
a = (a - s) / 60
m = a % 60
a = (a - m) / 60
h = a
print "%s:%s:%s" % (str(h), str(m), str(s))
|
total_sec = int(input())
h = int(total_sec / 3600)
last_seconds = total_sec % 3600
m = int(last_seconds / 60)
s = last_seconds % 60
print(f'{h}:{m}:{s}')
| 1 | 326,439,456,890 | null | 37 | 37 |
#import collections
# c = collections.Counter()
#import itertools as it
#import math
#import numpy as np
#import sys
#sys.exit()
#a = int(input())
k = int(input())
#a, b = map(int, input().split())
'''
# = list(map(int, input().split()))
'''
'''
n = input()
a = [int(input()) for i in range(n)]
'''
'''
n,m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(m)]
'''
#-------------------------------#
#len(t)==len(s)+1
#print(t[0:-1])
#print(a+pow(a,2)+pow(a,3))
for i in range(k):
print("ACL", end='')
|
input = int(raw_input())
h = input / 3600
input -= h * 3600
m = input / 60
input -= m * 60
print str(h) + ":" + str(m) + ":" + str(input)
| 0 | null | 1,243,860,692,008 | 69 | 37 |
#self.r[x] means root of "x" if "x" isn't root, else number of elements
class UnionFind():
def __init__(self, n):
self.r = [-1 for i in range(n)]
#use in add-method
def root(self, x):
if self.r[x] < 0: #"x" is root
return x
self.r[x] = self.root(self.r[x])
return self.r[x]
#add new path
def add(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return False
self.r[x] += self.r[y]
self.r[y] = x
return True
n, m = map(int, input().split())
UF = UnionFind(n)
for i in range(m):
a, b = map(lambda x: int(x)-1, input().split())
UF.add(a, b)
ans = 0
for i in UF.r:
if i < 0:
ans += 1
print(ans-1)
|
s = input()
n = len(s) // 2
if "hi"*n == s:
print("Yes")
else:
print("No")
| 0 | null | 27,896,495,346,460 | 70 | 199 |
S = input()
T = input()
ans = 1000
for i in range(len(S)-len(T)+1):
diff = 0
for j in range(len(T)):
if S[i+j] != T[j]:
diff += 1
if ans > diff:
ans = diff
print(ans)
|
from collections import defaultdict
n, k = map(int, input().split())
a = list(map(lambda x: int(x) - 1, input().split()))
s = [0] * (n + 1)
for i in range(n):
s[i + 1] = (s[i] + a[i]) % k
mp = defaultdict(int)
ans = 0
for i in range(n + 1):
ans += mp[s[i]]
mp[s[i]] += 1
if i >= k - 1:
mp[s[i - k + 1]] -= 1
print(ans)
| 0 | null | 70,937,355,599,968 | 82 | 273 |
S=input()
INF=10**12
# dp[i][j]: 下からi桁目まで決めた時の、くりさがりがjの時の最小値
# i: 0~N, j:2値, 前の桁でくりさがりが発生している場合に1
dp=[[INF for _ in range(2)] for _ in range(10**6+5)]
S=S[::-1]
S+="0"
N=len(S)
dp[0][0]=0
# 配るDP, 今の状態を見て次の状態を決めていく
for i in range(N):
for j in range(2):
# x: i桁目の数字, 前の桁でくりさがりが発生している場合はインクリメント
x=int(S[i])
x+=j
for a in range(10):
ni=i+1
nj=0
b=a-x
if b<0:
nj=1
b+=10
dp[ni][nj]=min(dp[ni][nj], dp[i][j]+a+b)
print(dp[N][0])
|
N = [int(_) for _ in input()]
dp = [[0, 0] for _ in range(len(N))]
dp[0][0] = min(N[0], 11 - N[0])
dp[0][1] = min(N[0] + 1, 10 - N[0])
for i in range(1, len(N)):
dp[i][0] = min(dp[i - 1][0] + N[i], dp[i - 1][1] + 10 - N[i])
dp[i][1] = min(dp[i - 1][0] + N[i] + 1, dp[i - 1][1] + 9 - N[i])
print(dp[-1][0])
| 1 | 71,112,253,157,598 | null | 219 | 219 |
n, m = map(int, input().split())
c = sorted([int(i) for i in input().split()])
dp = [[0 for j in range(n+1)] for i in range(m+1)]
dp[1] = [int(i) for i in range(n+1)]
for i in range(2, m+1):
for j in range(n+1):
if j - c[i-1] > -1:
dp[i][j] = min(dp[i-1][j], dp[i][j-c[i-1]]+1)
else:
dp[i][j] = dp[i-1][j]
print(dp[m][n])
|
import math
from collections import defaultdict
from itertools import accumulate
N=int(input())
data=defaultdict(int)
result=0
for i in range(2,int(math.sqrt(N))+1):
while N%i==0:
N//=i
data[i]+=1
if N!=1:
data[N]+=1
cumsum=list(accumulate(range(1,10**6*2)))
for value in data.values():
for i in range(10**6*2):
if value<cumsum[i]:
result+=i
break
if result==0:
if N!=1:
result=1
print(result)
| 0 | null | 8,592,038,927,758 | 28 | 136 |
while 1:
try:
a,b=map(int,raw_input().split())
print len("%d"%(a+b))
except:break
|
n=int(input())
x=n
c=1
while(x%360):
x+=n
x%=360
c+=1
print(c)
| 0 | null | 6,588,718,521,910 | 3 | 125 |
x = int(input())
a = [1, 0]
print(a[x])
|
N, M = map(int, input().split())
print(int(N * (N - 1) / 2 + M * (M - 1) / 2))
| 0 | null | 24,198,803,527,040 | 76 | 189 |
'''
l = input().split()
l = list(map(int, l))
a,b,c = l[0],l[1],l[2]
'''
a,b,c = map(int, input().split())
if a > b:
a,b = b,a
if b > c:
b,c = c,b
if a > b:
a,b = b,a
print(a,b,c)
|
time = int(input())
s = time % 60
h = time // 3600
m = (time - h * 3600) // 60
print(str(h) + ":" + str(m) + ":" + str(s))
| 0 | null | 364,153,283,340 | 40 | 37 |
n = int(input())
aas = list(map(int, input().split()))
arr = [0]*(10**5+1)
res = 0
for i in aas:
arr[i] += 1
res += i
q = int(input())
for i in range(q):
b,c = map(int, input().split())
res += (c-b)*arr[b]
print(res)
arr[c] += arr[b]
arr[b] = 0
|
#template
def inputlist(): return [int(j) for j in input().split()]
#template
from collections import Counter
N = int(input())
A = inputlist()
Q = int(input())
B = [0]*Q
C = [0]*Q
for i in range(Q):
B[i],C[i] = inputlist()
A_sum = sum(A)
dic = Counter(A)
for i in range(Q):
A_sum += (C[i]-B[i])*dic[B[i]]
print(A_sum)
dic[C[i]] += dic[B[i]]
dic[B[i]] = 0
| 1 | 12,133,885,609,818 | null | 122 | 122 |
k,n=map(int,input().split())
a=[int(i) for i in input().split()]
saitanhiku=a[2]-a[1]
for i in range(n-1):
if a[i+1]-a[i]>=saitanhiku:
saitanhiku=a[i+1]-a[i]
if (k-a[n-1])+a[0]>=saitanhiku:
saitanhiku=k-a[n-1]+a[0]
print(k-saitanhiku)
|
import sys
read = sys.stdin.read
#readlines = sys.stdin.readlines
from collections import defaultdict
def main():
k = int(input())
if k % 2 == 0:
print(-1)
sys.exit()
rems = defaultdict(int)
n = 7 % k
next_digit = 70 % k
r = 1
while True:
if n == 0:
print(r)
sys.exit()
elif rems[n]:
print(-1)
sys.exit()
else:
rems[n] = 1
n += next_digit
n = n % k
next_digit = (next_digit * 10) % k
r += 1
if __name__ == '__main__':
main()
| 0 | null | 24,587,415,923,852 | 186 | 97 |
h,a = map(int,input().split())
h -= 1
print(1 + h // a)
|
s, t = input().split()
ans = '{}{}'.format(t, s)
print(ans)
| 0 | null | 89,662,709,014,240 | 225 | 248 |
N=int(input())
A=list(map(int,input().split()))
mlt=0
for a in A:
mlt^=a
for i in range(N):
print(mlt^A[i],end=" ")
|
import sys
# import re
# import math
# import collections
# import decimal
# import bisect
# import itertools
# import fractions
# import functools
# import copy
# import heapq
# import decimal
# import statistics
# import queue
sys.setrecursionlimit(10000001)
INF = 10 ** 10
MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
mat = [[0 for _ in range(10)] for _ in range(10)]
for i in range(1, n + 1):
s = str(i)
ss = int(s[0])
st = int(s[-1])
mat[ss][st] += 1
ans=0
for i in range(1,10):
for j in range(1,10):
ans += mat[i][j]*mat[j][i]
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 49,828,109,060,960 | 123 | 234 |
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)
|
import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
import heapq
import decimal
# import statistics
import queue
import numpy as np
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
a = []
b = []
for _ in range(n):
ai, bi = ns()
a.append(ai)
b.append(bi)
a.sort()
b.sort()
if n % 2:
ans = b[n // 2] - a[n // 2] + 1
else:
ans = b[n // 2] + b[n // 2 - 1] - (a[n // 2] + a[n // 2 - 1]) + 1
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 56,392,525,647,952 | 242 | 137 |
N, K = map(int, input().split())
d = list()
have = list()
for i in range(K):
d.append(int(input()))
holders = list(map(int, input().split()))
for holder in holders:
if holder not in have:
have.append(holder)
print(N - len(have))
|
def resolve():
N, K = list(map(int, input().split()))
snacks = [0 for _ in range(N)]
for i in range(K):
d = int(input())
A = list(map(int, input().split()))
for a in A:
snacks[a-1] += 1
cnt = 0
for s in snacks:
if s == 0:
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve()
| 1 | 24,611,223,918,038 | null | 154 | 154 |
def bubblesort(N, A):
"""Do BubbleSort"""
m = 0
flag = True
while(flag):
flag = False
for i in range(N-1, 0, -1):
if (A[i-1] > A[i]):
tmp = A[i-1]
A[i-1] = A[i]
m += 1
A[i] = tmp
flag = True
b = list(map(str, A))
print(" ".join(b))
print(m)
A = []
N = int(input())
s = input()
A = list(map(int, s.split()))
bubblesort(N, A)
|
# import itertools
# import math
import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
N = int(input())
# S = input()
# n, *a = map(int, open(0))
# X, K, D = map(int, input().split())
# A = list(map(int, input().split()))
# C = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
C = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
a = C.count("R")
b = C[:a].count("R")
print(a - b)
| 0 | null | 3,168,339,341,200 | 14 | 98 |
n = int(input())
a = list(map(int, input().split()))
l = [0] * n
for i in range(n - 1):
if a[i] > 0:
l[a[i] - 1] += 1
for i in range(n):
print(l[i])
|
# -*- coding: utf-8 -*-
def judge(m, f, r):
if m==-1 or f==-1: return "F"
ttl = m + f
if ttl >= 80: return "A"
elif ttl >= 65: return "B"
elif ttl >= 50: return "C"
elif ttl >= 30:
return "C" if r>=50 else "D"
else: return "F"
if __name__ == "__main__":
while True:
m, f, r = map(int, raw_input().split())
if m==-1 and f==-1 and r==-1: break
print judge(m, f, r)
| 0 | null | 16,790,804,424,810 | 169 | 57 |
N = int(input())
S = [input() for _ in range(N)]
dic = {}
for i in range(N):
if S[i] not in dic.keys():
dic[S[i]] = 1
else:
dic[S[i]] += 1
maxI = max(dic.values())
ans = []
for keys in dic.keys():
if dic[keys] == maxI:
ans.append(keys)
ans.sort()
for i in ans:
print(i)
|
n = int(input())
S = ['']*n
T = []
for i in range(n):
S[i] = input()
S.sort()
if n == 1:
print(S[0])
exit()
cnt = 1
mxcnt = 1
for i in range(n-1):
if S[i] == S[i+1]:
cnt += 1
else:
cnt = 1
mxcnt = max(mxcnt,cnt)
cnt = 1
for i in range(n-1):
if S[i] == S[i+1]:
cnt += 1
else:
cnt = 1
if cnt == mxcnt:
T.append(S[i])
if mxcnt == 1:
T.append(S[-1])
for t in T:
print(t)
| 1 | 69,909,124,413,826 | null | 218 | 218 |
import math
a,b,C=list(map(int,input().split()))
C_radian=math.radians(C)
S=a*b*math.sin(C_radian)/2
L=a+b+(a**2+b**2-2*a*b*math.cos(C_radian))**0.5
h=b*math.sin(C_radian)
print(S)
print(L)
print(h)
|
import sys
from bisect import bisect_left, bisect_right
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *L = map(int, read().split())
L.sort()
ans = 0
for i in range(N):
a = L[i]
for j in range(i + 1, N):
b = L[j]
left = bisect_left(L, b, lo=j + 1)
right = bisect_left(L, a + b, lo=j + 1)
ans += right - left
print(ans)
return
if __name__ == '__main__':
main()
| 0 | null | 85,735,251,481,490 | 30 | 294 |
x=list(map(int, input().split()))
t=0
if x[0]<4:
t=t+((4-x[0])*100000)
if x[1]<4:
t=t+((4-x[1])*100000)
if x[0]==1 and x[1]==1:
t=t+400000
print(t)
|
a,b=map(int, input().split())
if 1<=a*b and a*b<=81 and a<10 and b<10:
print(a*b)
else:
print(-1)
| 0 | null | 149,325,232,626,038 | 275 | 286 |
n = input()
s = 100000
for i in range(n):
s = s * 1.05
if s % 1000 != 0:
s = ((s // 1000) + 1) * 1000
print "%d" % s
|
score = []
# 提出用の入力
while True:
m, f, r = map(int, input().split())
if m == -1 and f == -1 and r == -1:
break
score.append((m, f, r))
# # 動作確認用の入力
# with open('input_itp1_7_a_1.txt', mode='r', encoding='utf8') as input:
# while True:
# m, f, r = map(int, next(input).split())
# if m == -1 and f == -1 and r == -1:
# break
# score.append((m, f, r))
# print(score)
for i in range(len(score)):
sum = score[i][0] + score[i][1]
if score[i][0] == -1 or score[i][1] == -1 or sum < 30:
print('F')
elif sum >= 80:
print('A')
elif sum >= 65:
print('B')
elif sum >= 50:
print('C')
elif sum >= 30:
if score[i][2] >= 50:
print('C')
else:
print('D')
| 0 | null | 611,549,415,360 | 6 | 57 |
n=int(input())
a=list(map(int,input().split()))
ans=1
d={}
ch=0
mod=10**9+7
for i in range(n):
if a[i]==0:
if 0 not in d:
d[0]=1
ans*=3
else:
if d[0]==1:
d[0]=2
ans*=2
elif d[0]==2:
d[0]=3
else:
ch+=1
break
else:
if a[i] not in d:
d[a[i]]=1
if a[i]-1 not in d:
ch+=1
break
else:
ans*=d[a[i]-1]
else:
if d[a[i]]==1:
d[a[i]]=2
if a[i]-1 not in d:
ch+=1
break
else:
if d[a[i]-1]>=2:
ans*=d[a[i]-1]-1
else:
ch+=1
break
elif d[a[i]]==2:
d[a[i]]=3
if a[i]-1 not in d:
ch+=1
break
else:
if d[a[i]-1]>=3:
ans*=1
else:
ch+=1
break
else:
ch+=1
break
ans=(ans%mod)
if ch==0:
print(ans)
else:
print(0)
|
first_string = input()
second_string = input()
count = 0
for x, y in zip(first_string, range(len(first_string))):
if(second_string[y] != x):
count += 1
print(count)
| 0 | null | 70,525,384,072,374 | 268 | 116 |
#!/usr/bin/env python
from fractions import gcd
def main():
A, B = map(int, input().split())
print(A * B // gcd(A, B))
if __name__ == '__main__':
main()
|
a,b=list(map(int,input().split()))
from fractions import gcd
res=a*b/gcd(a,b)
print(int(res))
| 1 | 113,255,059,353,700 | null | 256 | 256 |
def checkBingo(A,c):
for i in range(3):
for j in range(3):
if A[i][j]==c:
A[i][j]=0
for i in range(3):
if max(A[i])==0 :
return 1
for i in range(3):
if A[0][i]==0 and A[1][i]==0 and A[2][i]==0:
return 1
if A[0][0]==0 and A[1][1]==0 and A[2][2]==0:
return 1
if A[0][2]==0 and A[1][1]==0 and A[2][0]==0:
return 1
return 0
A=[]
for i in range(3):
A.append( list(map(int,input().split()) ))
# print(A, min(A[0]),min(A[1]),min(A[2]))
n = int(input())
res=0
for i in range(n):
b = (int(input()))
# print(A)
res += checkBingo(A,b)
if res :
print("Yes")
else:
print("No")
|
# ABC_173_C_H_and_V.py
H,W,K=list(map(int, input().split()))
A=[list(input()) for _ in range(H)]
# print(A)
# bitDP2回ぶん回せば行けるのでは？
# bitが1は残す方で
ans=0
for i in range(1,2**H):
for j in range(1,2**W):
resx=[]
resy=[]
ct=0
for k in range(H):
if (i>>k)&1:
resx.append(k)
for l in range(W):
if (j>>l)&1:
resy.append(l)
# print(resx,resy)
B=[[A[k][l] for l in resy] for k in resx]
for k in range(len(resx)):
ct+=B[k].count('#')
# print(ct)
if ct==K:
ans+=1
print(ans)
| 0 | null | 34,512,634,438,880 | 207 | 110 |
# -*- coding:utf-8 -*-
def chess(H,W,m):
c = ''
count = 0
if m % 2 == 0:
for i in range(H):
if count % 2 == 0:
c += '#'
else:
c += '.'
count += 1
print(c)
if m % 2 == 1:
for i in range(H):
if count % 2 == 0:
c += '.'
else:
c += '#'
count += 1
print(c)
data = []
while True:
try:
di = input()
if di == '0 0':
break
data.append(di)
except:
break
for i in range(len(data)):
x = data[i]
W,H = map(int,x.split())
for l in range(W):
chess(H,W,l)
print('')
|
y,x = [int(x) for x in input().split()]
even = "#." * 151
odd = ".#" * 151
while(x > 0 or y > 0):
for i in range(y):
if(i % 2 == 0):
print(even[:x])
else:
print(odd[:x])
print()
y,x = [int(x) for x in input().split()]
| 1 | 869,841,296,700 | null | 51 | 51 |
a, b, m = map(int, input().strip().split())
as_ = list(map(int, input().strip().split()))
bs = list(map(int, input().strip().split()))
xyc = [list(map(int, input().strip().split())) for _ in range(m)]
min_no_discount = min(as_) + min(bs)
min_discount = 1e20
for x, y, c in xyc:
min_discount = min(min_discount, as_[x - 1] + bs[y - 1] - c)
print(min(min_discount, min_no_discount))
|
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
result = min(a) + min(b)
for _ in range(M):
x, y, c = map(int, input().split())
discount = a[x-1] + b[y-1] - c
result = min(result, discount)
print(result)
| 1 | 54,043,229,585,840 | null | 200 | 200 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
S, T = readline().split()
A, B = map(int, readline().split())
U = readline().strip()
if S == U:
print(A - 1, B)
else:
print(A, B - 1)
return
if __name__ == '__main__':
main()
|
# coding:utf-8
# Round-robin scheduling
def main():
n, q = map(int, input().split())
process = []
finished = []
counter = 0
for _ in range(n):
name, time = input().split()
process.append((name, int(time)))
while len(process) > 0:
name, time = process.pop(0)
temp_q = q
while True:
if time <= 0:
finished.append((name, counter))
break
# q????????§??????????¶????????????£???????????????
# time?????´??°??????process???????°?????§????
if temp_q <= 0:
process.append((name, time))
break
time -= 1
temp_q -= 1
counter += 1
for name, time in finished:
print(name, time)
if __name__ == "__main__":
main()
| 0 | null | 35,821,030,912,360 | 220 | 19 |
# ????????°??¶???????????? s ???????????????????????????????¨????????????£?¶????????????????????????????????????§???????????? p ??????????????????????????????????????°??????
# ????????°??¶????????????s????¨??????\?????????????????????
s = list(input())
# ??????????±??????????p????¨??????\?????????????????????
p = list(input())
# ?????????s??????????????????????????????????????????s?????????s?????????
s = s + s
# print(s)
# ???????????????????????????????????????????????°
flag = 0
for i in range(len(s) // 2):
if s[i] == p[0]:
for j in range(len(p)):
if s[i + j] != p[j]:
break
if j == len(p) - 1:
flag = 1
if flag == 1:
print("Yes")
else:
print("No")
|
sentence = input().lower()
ans = input().lower()
doublesentence = sentence + sentence
print("Yes" if ans in doublesentence else "No")
| 1 | 1,745,254,039,720 | null | 64 | 64 |
import math
h,w,k = map(int,input().split())
s = [str(input()) for i in range(h)]
ans = h * w
if h == 1:
print(math.ceil("1".count(s[0])/k))
exit()
for i in range(2 ** (h-1)):
ss = str(format(i,"b").zfill(h-1))
cnt = 0
zero = 0
key = 1
for j in range(len(ss)):
if ss[j] == "0":
zero += 1
now = [0 for i in range(zero+1)]
for j in range(w):
next = []
num = 0
for n in range(h):
if s[n][j] == "1":
num += 1
if num > k:
key = 0
if n < h-1 and ss[n] == "0":
next.append(num)
num = 0
next.append(num)
keykey = 1
for n in range(zero+1):
if keykey:
if now[n] + next[n] > k:
now = next
cnt += 1
keykey = 0
else:
now[n] += next[n]
if key:ans = min(ans,cnt+zero)
print(ans)
|
h, w, k = map(int, input().split())
s = [input() for _ in range(h)]
INF = 10 ** 20
ans = INF
for div in range(1 << (h - 1)):
id = []
g = 0
for i in range(h):
id.append(g)
if div >> i & 1:
g += 1
g += 1
c = [[0 for _ in range(w)] for _ in range(g)]
for i in range(h):
for j in range(w):
c[id[i]][j] += (s[i][j] == "1")
tmp_ans = g - 1
now = [0] * g
def add(j):
for i in range(g):
now[i] += c[i][j]
if now[i] > k:
return False
return True
for j in range(w):
if not add(j):
tmp_ans += 1
now = [0] * g
if not add(j):
tmp_ans = INF
break
# impossible = 0
# for j in range(w):
# if impossible:
# tmp_ans = INF
# break
# for i in range(g):
# if c[i][j] > k:
# impossible = 1
# break
# now[i] += c[i][j]
# if now[i] > k:
# now = [c[gi][j] for gi in range(g)]
# tmp_ans += 1
# continue
ans = min(ans, tmp_ans)
print(ans)
| 1 | 48,430,854,480,260 | null | 193 | 193 |
X,Y = map(int,input().split())
ans='No'
for i in range(0,X+1):
#print(i)
if i * 2 + (X - i) * 4 == Y and X>=i:
ans = 'Yes'
break
print(ans)
|
X, Y= map(int, input().strip().split())
if Y%2==0 and 2*X<=Y and Y<=4*X:print('Yes')
else:print('No')
| 1 | 13,722,392,806,368 | null | 127 | 127 |
scores = []
while True:
score = list(map(int, input().split()))
if score[0] == -1 and score[1] == -1 and score[2] == -1:
break
else:
scores.append(score)
for i in scores:
mid_exam = i[0]
final_exam = i[1]
re_exam = i[2]
total = i[0] + i[1]
if mid_exam == -1 or final_exam == -1:
print("F")
elif total >= 80:
print("A")
elif total in range(65, 80):
print("B")
elif total in range(50, 65):
print("C")
elif 30 <= total < 50:
if re_exam >= 50:
print("C")
else:
print("D")
elif total < 30:
print("F")
|
while 1:
m,f,r=map(int,raw_input().split())
if m==f==r==-1 :break
ans=''
if m==-1 or f==-1 :ans= 'F'
else :
mp=m+f
if mp>=80:ans='A'
elif mp>=65:ans='B'
elif mp>=50 or (mp>=30 and r>=50):ans='C'
elif mp>=30:ans='D'
else :ans='F'
print ans
| 1 | 1,243,485,129,030 | null | 57 | 57 |
import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
X,Y=MI()
N3=X+Y
if N3%3!=0:
print(0)
exit()
N=N3//3
a=0
b=0
for i in range(N+1):
if 2*i + (N-i) == X:
a=i
b=N-i
break
if a==0 and b==0:
print(0)
exit()
fact=[1,1]
factinv=[1,1]
inv=[0,1]
for i in range(2, N + 5):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
ans=fact[N]*factinv[a]*factinv[b]
print(ans%mod)
main()
|
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
class com:
def __init__(self,max, mod = 1000000007):
self.fac = [0] * max
self.inv = [0] * max
self.finv = [0] * max
self.mod = mod
self.fac[0] = self.fac[1] = 1
self.finv[0] = self.finv[1] = 1
self.inv[1] = 1
for i in range(2,max):
self.fac[i] = self.fac[i-1] * i % mod
self.inv[i] = mod - self.inv[mod%i] * (mod//i) % mod
self.finv[i] = self.finv[i-1] * self.inv[i] % mod
def com(self, n, k):
if n < k: return 0
if n < 0 or k < 0: return 0
return self.fac[n] * (self.finv[k] * self.finv[n - k] % self.mod) % self.mod
def main():
x,y = mi()
if (x+y) % 3 != 0:
print(0)
return
step = (x+y)//3
if x < step or y < step:
print(0)
return
c = com(step+1)
ans = c.com(step, x - step)
print(ans)
main()
| 1 | 149,854,627,814,240 | null | 281 | 281 |
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = input()
k = int(K)
print(A[k-1])
|
dataList = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
input_k = input('')
k_index = int(input_k)
print(dataList[k_index - 1])
| 1 | 49,983,716,297,762 | null | 195 | 195 |
# coding: utf-8
while True:
a = input()
if a == '0':
exit()
else:
print(sum(list(map(int, a))))
|
#coding:utf-8
while True:
l = [int(x) for x in input()]
if len(l) and l[0]==0:
break
print(sum(l))
| 1 | 1,582,041,543,488 | null | 62 | 62 |
class diceClass:
def __init__(self, valuelist):
self.valuelist = valuelist
self.t = valuelist[0]
self.b = valuelist[5]
self.n = valuelist[4]
self.s = valuelist[1]
self.e = valuelist[2]
self.w = valuelist[3]
def throw(self, direction):
# N,S,W,E
if direction == 'N':
self.t, self.s, self.b, self.n = self.s, self.b, self.n, self.t
elif direction == 'S':
self.t, self.s, self.b, self.n = self.n, self.t, self.s, self.b
elif direction == 'W':
self.t, self.e, self.b, self.w = self.e, self.b, self.w, self.t
elif direction == 'E':
self.t, self.e, self.b, self.w = self.w, self.t, self.e, self.b
arrinput = list(map(int, input().split()))
dirinput = input()
dice = diceClass(arrinput)
for s in dirinput:
dice.throw(s)
print(dice.t)
|
s = input()
l = 0
r = len(s)-1
c = 0
while l <= r:
if s[l] != s[r]:
c += 1
l += 1
r -=1
print(c)
| 0 | null | 59,959,002,518,996 | 33 | 261 |
def isprime(n):
if n == 2:
return True
if n % 2 == 0:
return False
i = 3
while i * i <= n:
if n % i == 0:
return False
i += 2
return True
result = 0
for i in range(int(input())):
result += isprime(int(input()))
print(result)
|
n = int(input())
ans = 0
for x in (int(input()) for _ in range(n)):
flg = True
for y in range(2, int(x**0.5+1)):
if x % y == 0:
flg = False
break
if flg:
ans += 1
print(ans)
| 1 | 10,122,451,852 | null | 12 | 12 |
from collections import deque
import sys
sys.setrecursionlimit(10**9)
N = int(input())
to = [[] for _ in range(N)]
order = []
for _ in range(N - 1):
a, b = list(map(lambda x:int(x) - 1, input().split()))
to[a].append(b)
to[b].append(a)
order.append(b)
def solve():
dist = [-1] * N
# 頂点iに向かう辺をiとする
color = [0] * N
dist[0] = 0
color[0] = 0
que = deque([0])
while que:
v = que.popleft()
used_color = [color[v]]
next_color = 1
for nv in to[v]:
if dist[nv] == -1:
dist[nv] = dist[v] + 1
while next_color in used_color:
next_color += 1
color[nv] = next_color
used_color.append(next_color)
que.append(nv)
print(len(set(color[1:])))
for i in range(N - 1):
print(color[order[i]])
if __name__ == "__main__":
solve()
|
import sys
sys.setrecursionlimit(500000)
N = int(input())
#道を双方向に記録する。
g = [[] for _ in range(N)]
for i in range(N-1): #木の辺の数はN-1
#iが辺のID
a,b = map(int,input().split())
a -= 1; b -= 1 #ここで引いて頂点を0スタートにしないとオーバーフロー
g[a].append((b,i))
g[b].append((a,i))
#これが答え。
ans = [-1 for _ in range(N-1)]
#vという頂点からpという親にcolorという色で繋がっている。
def dfs(v, color, p):
k = 1 #色の初期値
for i in range(len(g[v])): #vから繋がっている頂点をtoとして探す
TO = g[v][i][0]
ID = g[v][i][1]
if TO == p: #親は一つでそれ以外は子。親の時だけ無視すればよい。
continue
if k == color: #親から繋がっている色と被ったらダメ。
k += 1
ans[ID] = k
k += 1 #ここで足す1をしないとこのfor loopの中の辺で色が被る。
dfs(TO,ans[ID],v)
dfs(0,0,-1) #根を0として、仮想親の-1から仮想色0で繋がっている。
print(max(ans))
for i in ans:
print(i)
| 1 | 136,630,227,700,128 | null | 272 | 272 |
N = list(map(int, input().strip().split()))
state=-1
if(N[0]>=1 and N[0] <=9 and N[1]>=1 and N[1] <=9):
state=N[0]*N[1]
print(state)
|
s = input()
x = s.replace('<>', '<|>').split('|')
def func(t):
c1 = t.count('>')
c2 = len(t) - c1
return list(reversed(range(1, c1 + 1))) + list(range(c2 + 1))
a = func(x[0])
for i in range(1, len(x)):
ai = func(x[i])
a[-1] = max(a[-1], ai[0])
a.extend(ai[1:])
# print(a)
ans = sum(a)
print(ans)
| 0 | null | 157,224,688,333,312 | 286 | 285 |
import numpy as np
N = int(input())
x = []
y = []
xy1 = []
xy2 = []
for i in range(N):
a, b = (int(t) for t in input().split())
x.append(a)
y.append(b)
xy1.append(a + b)
xy2.append(a - b)
max1 = max(xy1) - min(xy1)
max2 = max(xy2) - min(xy2)
print(max((max1, max2)))
|
n,m=map(int,input().split())
c=list(map(int,input().split()))
c.sort(reverse=True)
#print(c)
dp=[0]
for i in range(1,n+1):
mini=float("inf")
for num in c:
if i-num>=0:
mini=min(mini,dp[i-num]+1)
dp.append(mini)
#print(dp)
print(dp[-1])
| 0 | null | 1,794,812,494,420 | 80 | 28 |
s=input()
if s=="ABC": print("ARC")
else : print("ABC")
|
N, A, B = map(int, input().split())
if (B-A) % 2 == 0: print((B-A)//2)
else: print(min((A-1+B-1+1)//2, (N-A+N-B+1)//2))
| 0 | null | 66,827,220,136,480 | 153 | 253 |
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_4_C&lang=jp
#??????
if __name__ == "__main__":
n_line = int(input())
l = set([])
for i in range(n_line):
input_line = input().split()
if input_line[0] == "insert":
l.add(input_line[1])
else:
if input_line[1] in l:
print("yes")
else:
print("no")
|
n = int(input())
mydict = {}
answer_list = []
for i in range(n) :
query, wd = input().split()
if query == "insert" :
mydict[wd] = 1
else :
if wd in mydict.keys() : answer_list.append("yes")
else : answer_list.append("no")
for i in answer_list :
print(i)
| 1 | 76,481,590,390 | null | 23 | 23 |
n,t = map(int, input().split())
Task=[]
for i in range(n):
nm,le= map(str, input().split())
Task.append([nm,le])
T=0
while n >0:
k = Task.pop(0)
k[1]=int(k[1])
if k[1] > t:
k[1]=k[1]-t
T=T+t
Task.append(k)
n = len(Task)
else:
T=T+k[1]
k[1]=T
print(' '.join(map(str, k)))
n = len(Task)
|
n = input()
x = list(n)
length = len(x)
if x[length-1] == "3":
print("bon")
elif x[length-1] == "0" or x[length-1] == "1" or x[length-1] == "6" or x[length-1] =="8":
print("pon")
else:
print("hon")
| 0 | null | 9,746,393,432,638 | 19 | 142 |
s = list(input())
q = int(input())
rvs = []
i = 0
j = 0
p = []
order = []
for i in range(q):
order.append(input().split())
if order[i][0] == "replace":
p = []
p = list(order[i][3])
for j in range(int(order[i][1]), int(order[i][2]) + 1):
s[j] = p[j - int(order[i][1])]
elif order[i][0] == "reverse":
ss = "".join(s[int(order[i][1]):int(order[i][2]) + 1])
rvs = list(ss)
rvs.reverse()
for j in range(int(order[i][1]), int(order[i][2]) + 1):
s[j] = rvs[j - int(order[i][1])]
# temp = s[int(order[i][1])]
# s[int(order[i][1])] = s[int(order[i][2])]
# s[int(order[i][2])] = temp
elif order[i][0] == "print":
ss = "".join(s)
print("%s" % ss[int(order[i][1]):int(order[i][2]) + 1])
|
from collections import deque
n=int(input())
edge=[[] for _ in range(n+1)]
for i in range(n):
v,k,*u=map(int,input().split())
edge[v]=u
p=[-1]*(n+1)
p[1]=0
q=deque([])
q.append(1)
v=[1]*(n+1)
v[1]=0
while q:
now=q.popleft()
for i in edge[now]:
if v[i]:
q.append(i)
p[i]=p[now]+1
v[i]=0
for i in range(1,n+1):
print(i,p[i])
| 0 | null | 1,025,983,727,188 | 68 | 9 |
n,m = map(int, input().split())
a = [[] for x in range(0, n)]
b = [0 for x in range(0, m)]
for x in range(0, n):
a[x] = list(map(int, input().split()))
for x in range(0, m):
b[x] = int(input())
for i in range(0, n):
c = 0
for j in range(0, m):
c += a[i][j] * b[j]
print(c)
|
n, m = map(int, input().split())
mat = []
for i in range(n):
mat.append(list(map(int, input().split())))
vec = []
for i in range(m):
vec.append(int(input()))
for i in range(n):
e = 0
for j in range(m):
e += mat[i][j] * vec[j]
print(e)
| 1 | 1,139,247,206,120 | null | 56 | 56 |
N,K=map(int,input().split())
A=list(map(int,input().split()))
imos=[0 for i in range(N+1)]
for t in range(K):
for i in range(N):
l=max(0,i-A[i])
r=min(N,i+A[i]+1)
imos[l]+=1
imos[r]-=1
for i in range(0,N):
imos[i+1]+=imos[i]
A[i]=imos[i]
imos=[0 for i in range(N+1)]
if len(set(A))==1 and (N in set(A)):
break
for i in range(N):
A[i]=str(A[i])
ans=" ".join(A)
print(ans)
|
N, K = map(int, input().split())
A = [int(x) for x in input().split()]
K = min(K, 41)
# imos
for _ in range(K):
B = [0 for _ in range(N)]
for i in range(N):
l = max(0, i-A[i])
r = min(N-1, i+A[i])
B[l] += 1
if r+1 < N:
B[r+1] -= 1
for i in range(1, N):
B[i] += B[i-1]
A = B
print(*A)
| 1 | 15,475,736,056,836 | null | 132 | 132 |
from bisect import bisect_left, bisect, insort
def main():
n = int(input())
s = list(input())
q = int(input())
_is = {chr(i):[] for i in range(ord("a"), ord("a")+27)}
for i, si in enumerate(s):
_is[si].append(i)
for _ in range(q):
t, i, c = input().split()
i = int(i)-1
if t == "1":
if s[i] != c:
index = bisect_left(_is[s[i]], i)
del _is[s[i]][index]
insort(_is[c], i)
s[i] = c
else:
c = int(c) - 1
cnt = 0
for _isi in _is.values():
if _isi:
is_in = bisect(_isi, c)-bisect_left(_isi, i)
if is_in:
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
|
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
R = 2**(N.bit_length())
st = [0] * (R*2)
def update(i,s):
x = 2 ** (ord(s) - ord('a'))
i += R-1
st[i] = x
while i > 0:
i = (i-1) // 2
st[i] = st[i*2+1] | st[i*2+2]
def query(l,r):
l += R-1
r += R-2
ret = 0
while l+1 < r:
if l % 2 == 0:
ret |= st[l]
if r % 2 == 1:
ret |= st[r]
r -= 1
l = l // 2
r = (r-1) // 2
if l == r:
ret |= st[l]
else:
ret |= st[l] | st[r]
return ret
for i,s in enumerate(sys.stdin.readline().rstrip()):
update(i+1,s)
Q = NI()
for _ in range(Q):
c,a,b = sys.stdin.readline().split()
if c == '1':
update(int(a),b)
else:
ret = query(int(a),int(b)+1)
cnt = 0
b = 1
for i in range(26):
cnt += (b & ret) > 0
b <<= 1
print(cnt)
if __name__ == '__main__':
main()
| 1 | 62,944,376,842,610 | null | 210 | 210 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.