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
|
|---|---|---|---|---|---|---|
def main():
a = int(input())
b = int(input())
print(6 - a - b)
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
N = int(input())
A = [0 for i in range(N)]
B = [0 for i in range(N)]
for i in range(N):
a,b = LI()
A[i] = a
B[i] = b
A.sort()
B.sort()
if N % 2 == 1:
min_mid = A[(N - 1) // 2]
else:
min_mid = (A[N //2 - 1] + A[N//2]) / 2
if N % 2 == 1:
max_mid = B[(N - 1) // 2]
else:
max_mid = (B[N //2 - 1] + B[N//2]) / 2
if N % 2 == 0:
print(int((max_mid - min_mid) / 0.5 + 1))
else:
print(math.ceil(max_mid) - math.floor(min_mid) + 1)
| 0 | null | 64,072,480,473,540 | 254 | 137 |
N = int(input())
A = list(map(int, input().split()))
ans = 1000
for i in range(N - 1):
a = A[i]
if a < A[i + 1]:
units = ans // a
ans = (ans - units * a) + units * A[i + 1]
# print(i, ans)
print(ans)
|
# import sys
# input = sys.stdin.readline
import itertools
import collections
# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
n, m = input_list()
rooms = []
for _ in range(m):
rooms.append(input_list())
prev = [0]*n
to_list = [[] for i in range(n)]
for a, b in rooms:
to_list[a-1].append(b-1)
to_list[b-1].append(a-1)
next_q = collections.deque()
flags = [-1] * n
flags[0] = 999
next_q.append(0)
while next_q:
cur = next_q.popleft()
for room in to_list[cur]:
if flags[room] == -1:
flags[room] = cur
next_q.append(room)
print('Yes')
for i in range(1, n):
print(flags[i]+1)
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| 0 | null | 13,967,046,614,042 | 103 | 145 |
A, B, C = map(int,input().split())
if A == B and B != C:
print('Yes')
elif C == B and C != A:
print('Yes')
elif A == C and C != B:
print('Yes')
else:
print('No')
|
from copy import deepcopy
import numpy as np
H, W, K = map(int, input().split())
matrix = []
for i in range(H):
matrix.append(input())
matrix_int = np.ones((H, W), dtype=np.uint8)
# 1 == 黒、 0 == 白
for row in range(H):
for column in range(W):
if matrix[row][column] == ".":
matrix_int[row, column] = 0
count = 0
for row_options in range(2**H):
for col_options in range(2**W):
tmp_matrix_int = deepcopy(matrix_int)
tmp_row_options = row_options
tmp_col_options = col_options
for row in range(H):
mod = tmp_row_options % 2
if mod == 0:
tmp_matrix_int[row,:] = 0
tmp_row_options = tmp_row_options // 2
for col in range(W):
mod = tmp_col_options % 2
if mod == 0:
tmp_matrix_int[:,col] = 0
tmp_col_options = tmp_col_options // 2
# print(tmp_matrix_int.sum())
if tmp_matrix_int.sum() == K:
count += 1
print(count)
| 0 | null | 38,305,288,465,220 | 216 | 110 |
n = int(input())
h = [[[0 for i in range(10)] for j in range(3)] for k in range(4)]
for _ in range(n):
b, f, r, v = [int(e) for e in input().split()]
h[b-1][f-1][r-1] += v
for i, b in enumerate(h):
if i != 0:
print('#'*20)
for f in b:
print(' ', end='')
print(*f)
|
print(~-int(input())//2)
| 0 | null | 77,119,497,789,932 | 55 | 283 |
def f():
N = int(input())
UP = []
DOWN = []
for _ in range(N):
S = input()
c = 0
minC = 0
for s in S:
if s == '(':
c += 1
else:
c -= 1
minC = min(minC, c)
if c >= 0:
UP.append((minC, c))
else:
DOWN.append((c - minC, c))
c = 0
for up in sorted(UP, reverse=True):
if c + up[0] < 0:
return False
c += up[1]
for down in sorted(DOWN, reverse=True):
if c + down[1] - down[0] < 0:
return False
c += down[1]
if c != 0:
return False
return True
if f():
print('Yes')
else:
print('No')
|
# ()の問題は折れ線で捉えると良い
N = int(input())
ls = [] # 増減が正のもの(0を含む)
rs = [] # 増減が負のもの
tot = 0
for i in range(N):
s = input()
h = 0
b = 0
for c in s:
if c == "(":
h += 1
else:
h -= 1
b = min(b, h)
if h >= 0:
# 折れ線に対して上っていく奴ら
ls.append([b, h])
else:
# 折れ線に対して下っていく奴ら
# 右から(hから見るので、最下点は-hする)
rs.append([b-h, -h])
tot += h
ls.sort(key = lambda x:x[0], reverse=True)
rs.sort(key = lambda x:x[0], reverse=True)
def check(s):
h = 0
for p in s:
if h+p[0] < 0:
return False
h += p[1]
return True
if check(ls) and check(rs) and tot == 0:
print("Yes")
else:
print("No")
| 1 | 23,606,671,963,578 | null | 152 | 152 |
print("".join(reversed(input().split())))
|
# coding: utf-8
x=int(input())
i=1
while x!=0:
print("Case "+str(i)+": "+str(x))
x=int(input())
i+=1
| 0 | null | 51,565,688,353,440 | 248 | 42 |
#import math
import collections
n, m = map(int, input().split( ))
lis = [[] for _ in range(n+1)]
for _ in range(m):
a,b = map(int, input().split( ))
lis[a].append(b)
lis[b].append(a)
#print(lis)
ans = [0]*(n+1)
q = collections.deque()
q.append(1)
count = [0]*(n+1)
#1の時は動かない
count[1] = 1
while len(q) != 0:
v = q.popleft()
# print(lis[v], count)
#まずは1につながっている部屋を探索その後順に探索
for u in lis[v]:
if count[u] == 0:
count[u] = 1
ans[u] = v
q.append(u)
print('Yes')
for i in range(2,n+1):
print(ans[i])
|
# -*-coding:utf-8
import fileinput
import math
def main():
offiHouse = [[[0 for i3 in range(10)] for i2 in range(3)] for i1 in range(4)] #y, x, z
n = int(input())
for i in range(n):
a, b, c, d = map(int, input().split())
offiHouse[a-1][b-1][c-1] += d
for i in range(4):
for j in range(3):
for k in range(10):
print('', offiHouse[i][j][k], end='')
print()
if(i != 3):
print('#' * 20)
if __name__ == '__main__':
main()
| 0 | null | 10,753,141,900,970 | 145 | 55 |
#
import sys
input=sys.stdin.readline
def main():
N,M=map(int,input().split())
if N>=2 and M>=2:
print((N*(N-1))//2+(M*(M-1)//2))
elif N>=2:
print((N*(N-1))//2)
elif M>=2:
print((M*(M-1)//2))
else:
print(0)
if __name__=="__main__":
main()
|
def selectionSort(nums,n):
k=0
for i in range(n):
minj=i
for j in range(i,n):
if nums[j]<nums[minj]:
minj=j
if nums[i]!=nums[minj]:
nums[i],nums[minj]=nums[minj],nums[i]
#print(nums)
k+=1
return nums,k
n=int(input())
nums=list(map(int,input().split()))
nums,k=selectionSort(nums,n)
print(*nums)
print(k)
| 0 | null | 22,709,841,349,106 | 189 | 15 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, t = map(int, input().split())
AB = sorted([list(map(int, input().split())) for _ in range(n)], key=lambda x: x[0])
res = 0
dp = [[0] * (t + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
a, b = AB[i - 1]
for j in range(1, t + 1):
if j - a >= 0:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - a] + b)
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j])
now = dp[i - 1][t - 1] + b
res = max(res, now)
print(res)
if __name__ == '__main__':
resolve()
|
N, T = map(int, input().split())
dishes = sorted([tuple(map(int,input().split())) for i in range(N)])
dp = [[0] * 3100 for _ in range(3100)]
ans = 0
for i in range(1, N + 1):
for j in range(1, T):
#dpをもとにした最大値の更新
dp[i][j] = dp[i-1][j]
ans = max(ans, dp[i][j] + dishes[i-1][1]) #最後に、最も時間のかかるものを食べて、大きい場合は最大値（ans）を更新
# dpの更新
if j - dishes[i-1][0] >= 0: #最後に食べる品が持ち時間より長いばあいはNG
dp[i][j] = max(dp[i][j], dp[i-1][j-dishes[i-1][0]] + dishes[i-1][1]) #ラストオーダーまでにj-dishes[i-1][0]の時間があるので
print(ans)
| 1 | 152,282,935,890,602 | null | 282 | 282 |
#!usr/bin/env python3
import sys
import re
def main():
s = sys.stdin.readline() # haystack
p = sys.stdin.readline() # needle
s = s.strip('\n') * 2
p = p.strip('\n')
if len(re.findall((p), s)) > 0:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
i = list(map(int, input().split()))
o = i[0] - 2 * i[1]
if o <= 0:
o = 0
print(o)
| 0 | null | 84,125,738,172,950 | 64 | 291 |
n=int(input())
K=int(input())
m=len(str(n))
N=list(map(int,str(n)))
dp=[[[0,0]for j in range(K+1)]for i in range(m+1)]
dp[0][0][0]=1
for i in range(1,1+m):
for j in range(K+1):
for k in range(10):
if k==0:
if N[i-1]==k:
dp[i][j][0]+=dp[i-1][j][0]
elif N[i-1]>k:
dp[i][j][1]+=dp[i-1][j][0]
dp[i][j][1]+=dp[i-1][j][1]
else:
if j<K:
if N[i-1]==k:
dp[i][j+1][0]+=dp[i-1][j][0]
elif N[i-1]>k:
dp[i][j+1][1]+=dp[i-1][j][0]
dp[i][j+1][1]+=dp[i-1][j][1]
print(sum(dp[-1][K]))
|
n, k = map(int, input().split())
MOD = 10 ** 9 + 7
cnt = [0] * (k + 1)
for gcd in range(1, k + 1):
cnt[gcd] = pow(k // gcd, n, MOD)
for gcd in range(k, 0, -1):
for i in range(2, k // gcd + 1):
cnt[gcd] -= cnt[gcd * i]
ans = sum([num * c for num, c in enumerate(cnt)]) % MOD
print(ans)
| 0 | null | 56,572,497,186,828 | 224 | 176 |
n=int(raw_input().strip())
lst=[]
minval=0x3f3f3f3f
ans=-0x3f3f3f3f
for i in xrange(n):
val=int(raw_input().strip())
if(i>=1):
#print val,minval
ans=max(ans,val-minval)
minval = min(minval, val)
print ans
|
N = input()
R = [int(raw_input()) for _ in xrange(N)]
S = [0 for i in xrange(N)]
S[N-1] = R[N-1]
for i in xrange(N-2, -1, -1):
S[i] = max(R[i], S[i+1])
ans = float('-inf')
for i in xrange(N-1):
ans = max(ans, S[i+1]-R[i])
print ans
| 1 | 13,044,662,432 | null | 13 | 13 |
class UFTree:
def __init__(self, N):
self.nodes = [Node(i) for i in range(N)]
self.N = N
def find_max_child_num(self):
result = 0
for i in range(self.N):
result = max(result, self.nodes[i].child_num)
return result
class Node:
def __init__(self, ID):
self.ID = ID
self.parent = None
self.child_num = 0
self.rank = 1
def get_root(self):
if self.parent is None:
return self
return self.parent.get_root()
def concat(self, another):
sr = self.get_root()
ar = another.get_root()
# is in a same tree.
if sr.ID == ar.ID:
return
if sr.rank > ar.rank:
parent, child = sr, ar
else:
parent, child = ar, sr
parent.child_num += child.child_num + 1
parent.rank = max(parent.rank, child.rank + 1)
child.parent = parent
N, M = map(int, input().split())
tree = UFTree(N)
AB = []
for i in range(M):
l = list(map(int, input().split()))
AB.append(l)
for i in range(M):
a, b = AB[i][0], AB[i][1]
a -= 1;
b -= 1;
tree.nodes[a].concat(tree.nodes[b])
print(tree.find_max_child_num() + 1)
|
S = input()
T = 'R' if S[1] == 'B' else 'B'
print(S[0]+T+S[2])
| 0 | null | 14,072,912,301,632 | 84 | 153 |
S = input()
if S.isupper():
print('A')
else:
print('a')
|
def gcd(x, y):
'''??????????????????????????????
x>=y?????¨??????gcd(x, y)??¨gcd(y, x%y)?????????????????¨????????¨??????'''
if x < y:
x, y = y, x
while y > 0:
x, y = y, x % y
return x
def test():
'''??? input =
147 105
->
21'''
x, y = map(int, input().split())
result = gcd(x, y)
print(result)
if __name__ == '__main__':
test()
| 0 | null | 5,700,486,457,308 | 119 | 11 |
#coding:utf-8
import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
XLMIIS = lambda x: [LMIIS() for _ in range(x)]
YN = lambda c : print('Yes') if c else print('No')
MOD = 10**9+7
n,a,b = LMIIS()
def cmb(n,r):
if r == 0:
return 0
res = 1
r = min(r,n-r)
for i in range(n-r+1,n+1):
res *= i
res %= MOD
for i in range(1,r+1):
res *= pow(i,(MOD-2),MOD)
res %= MOD
return res
print((pow(2,n,MOD)-cmb(n,a)-cmb(n,b)-1)%MOD)
if __name__ == '__main__':
main()
|
MOD = 10**9 + 7
n, a, b = map(int, input().split())
def pow(x, n, MOD):
res = 1
while n:
if n & 1:
res *= x
res %= MOD
x *= x
x %= MOD
n >>= 1
return res
def fact(a, b, MOD):
res = 1
for i in range(a, b+1):
res *= i
res %= MOD
return res
def combi(n, k, MOD):
x = fact(n - k + 1, n, MOD)
y = fact(1, k, MOD)
return x * pow(y, MOD - 2, MOD) % MOD
def solve():
ans = pow(2, n, MOD) - 1 - combi(n, a, MOD) - combi(n, b, MOD)
print(ans % MOD)
#print(pow(2, MOD, MOD))
if __name__ == "__main__":
solve()
| 1 | 66,353,553,119,140 | null | 214 | 214 |
N,M=map(int ,input().split())
A=input().split()
s=0
for i in range(M):
s+=int(A[i])
ans=N-s
if ans>=0:
print(ans)
else:
print("-1")
|
import sys
s1 = str(input())
s2 = str(input())
ans = 0
for i in range(len(s1)):
if s1[i] != s2[i]:
ans += 1
print(ans)
| 0 | null | 21,108,212,467,712 | 168 | 116 |
H, A = [int(v) for v in input().rstrip().split()]
r = int(H / A)
if H != (r * A):
r += 1
print(r)
|
n, m = [int(i) for i in input().split()]
vec = []
for i in range(n):
vec.append([int(j) for j in input().split()])
c = []
for i in range(m):
c.append(int(input()))
for i in range(n):
sum = 0
for j in range(m):
sum += vec[i][j]*c[j]
print(sum)
| 0 | null | 38,977,577,226,760 | 225 | 56 |
N, K = map(int, input().split())
A = sorted(map(int, input().split()))
F = sorted(map(int, input().split()), reverse=True)
ng = -1
ok = 0
for i in range(N):
ok = max(A[i]*F[i], ok)
def is_ok(arg):
cnt = 0
for i in range(N):
cnt += max(A[i] - arg//F[i], 0)
return cnt <= K
def m_bisect(ng, ok):
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(m_bisect(ng, ok))
|
import numpy as np
def check_bingo(A):
for i in range(3):
if np.all(A[i] == -1) or np.all(A[:, i] == -1):
return 'Yes'
if np.all(A[list(range(3)), list(range(3))] == -1) \
or np.all(A[list(range(3)), list(range(3))[::-1]] == -1):
return 'Yes'
return 'No'
def main():
A = np.array([list(map(int, input().split())) for _ in range(3)])
n = int(input())
for i in range(n):
b = int(input())
A = np.where(A == b, -1, A)
ans = check_bingo(A)
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 112,718,937,144,352 | 290 | 207 |
#設定
import sys
input = sys.stdin.buffer.readline
#ライブラリインポート
from collections import defaultdict
con = 10 ** 9 + 7
#入力受け取り
def getlist():
return list(map(int, input().split()))
#処理内容
def main():
N = int(input())
ansL = [[] for i in range(10)]
ansL[0].append(["a", 1])
for i in range(N - 1):
n = len(ansL[i])
for j in range(n):
for k in range(ansL[i][j][1]):
ansL[i + 1].append([ansL[i][j][0] + chr(97 + k), ansL[i][j][1]])
ansL[i + 1].append([ansL[i][j][0] + chr(97 + ansL[i][j][1]), ansL[i][j][1] + 1])
n = len(ansL[N - 1])
for i in range(n):
print(ansL[N - 1][i][0])
if __name__ == '__main__':
main()
|
#
# panasonic2020b d
#
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """1"""
output = """a"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2"""
output = """aa
ab"""
self.assertIO(input, output)
def resolve():
global N
N = int(input())
T = []
func("a", "a", T)
for t in T:
print(t)
def func(mw, s, T):
if len(s) == N:
T.append(s)
return
for i in range(ord(mw)-ord("a")+2):
mw = max(mw, chr(ord("a")+i))
ns = s + chr(ord("a")+i)
func(mw, ns, T)
if __name__ == "__main__":
# unittest.main()
resolve()
| 1 | 52,375,708,559,360 | null | 198 | 198 |
import sys
for index, line in enumerate(sys.stdin):
value = int(line.strip())
if value == 0:
break
print("Case {0}: {1}".format(index+1, value))
|
a5=[]
while True:
x=int(input())
if x==0:
break
a5.append(x)
j = 0
for i in a5:
print("Case " + str(j+1)+": "+ str(i))
j=j+1
| 1 | 475,877,344,626 | null | 42 | 42 |
n,m = map(int,input().split())
s = list(input())
s.reverse()
for i in range(m):
s.append("1")
p = 0
ans = []
while p < n:
p += m
cnt = m
while s[p] == "1":
p -= 1
cnt -= 1
if cnt == 0:
print(-1)
exit()
ans.append(cnt)
ans.reverse()
print(*ans)
|
N,M=map(int,input().split())
A,c,dp,r=[0]*N,0,0,[]
for i, s in enumerate(reversed(input())):
if s=="1":c+=1;A[i]=c
else:c=0
while dp+M<=N-1:
t = M-A[dp+M]
if t>0: dp+=t
else:print(-1);exit()
r.append(t)
r.append(N-dp)
print(*reversed(r))
| 1 | 138,508,796,526,740 | null | 274 | 274 |
x = not(int(input()))
print(int(x))
|
print(int(not(int(input()))))
| 1 | 2,983,799,888,230 | null | 76 | 76 |
while True:
try:
a, b = map(int, input().rstrip().split())
print(len(str(a + b)))
except Exception:
break
|
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
import bisect
import heapq
import itertools
import math
import numpy as np
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
bunshi=1
bunbo=1
for i in range(r):
bunbo = bunbo*(i+1)%mod
bunshi = bunshi*(n-i)%mod
return (bunshi*pow(bunbo,mod-2,mod))%mod
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
n = I()
#graph[i]には頂点iと繋がっている頂点を格納する
graph = [[] for _ in range(n+1)]
prev_col = [0]*(n+1)
a_b = []
k=0
for i in range(n-1):
a,b = MI()
a_b.append(str(a)+" "+str(b))
graph[a].append(b)
graph[b].append(a)
#check[i] == -1ならば未探索
check = [-1]*(n+1)
check[0] = 0
check[1] = 0
for i in range(n+1):
k = max(len(graph[i]),k)
d = deque()
d.append(1)
ans = dict()
while d:
v = d.popleft()
check[v] = 1
cnt = 0
for i in graph[v]:
if check[i] != -1:
continue
cnt = cnt+1
if prev_col[v] == cnt:
cnt = cnt + 1
prev_col[i] = cnt
ans[str(min(i,v))+" "+str(max(i,v))]=cnt
d.append(i)
print(k)
for key in a_b:
print(ans[key])
| 0 | null | 67,837,480,653,118 | 3 | 272 |
def main():
x, y = map(int, input().split())
print('Yes' if 2*x <= y <= 4*x and y % 2 == 0 else 'No')
if __name__ == '__main__':
main()
|
from typing import List
def main():
n = int(input())
m = xyz(n)
for i in m:
print(i)
def f(x, y, z):
return x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x
def xyz(n: int) -> List[int]:
result = [0] * n
for x in range(1, 100):
for y in range(1, 100):
for z in range(1, 100):
m = f(x, y, z)
if m > n:
break
result[m - 1] += 1
return result
if __name__ == '__main__':
main()
| 0 | null | 10,748,648,051,750 | 127 | 106 |
y=100000
n = int(input())
for i in range(n):
y=y*1.05
if y%1000==0:
pass
else:
y=y//1000
y=y+1
y=y*1000
print(f"{y:.0f}")
|
import math
n = input()
a = 100000
for val in range(1,n+1):
a *= 1.05
A = math.ceil(a/1000) * 1000
a = A
print int(a)
| 1 | 1,241,323,132 | null | 6 | 6 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *A = map(int, read().split())
C = [0] * (N + 1)
C[0] = 3
ans = 1
for a in A:
ans = ans * C[a] % MOD
if ans == 0:
print(0)
return
C[a] -= 1
C[a + 1] += 1
print(ans)
return
if __name__ == '__main__':
main()
|
# https://atcoder.jp/contests/sumitrust2019/tasks/sumitb2019_e
n = int(input())
A = list(map(int, input().split()))
MOD = 1000000007
counts = [0, 0, 0]
result = 1
for i in range(n):
a = A[i]
# print(a, counts, result)
cnt = counts.count(a)
result *= cnt
result %= MOD
for j in range(len(counts)):
if counts[j] == a:
counts[j] += 1
break
print(result)
| 1 | 129,643,869,343,418 | null | 268 | 268 |
S = input()
if len(set(S)) == 1:
print('No')
else:
print('Yes')
|
s=input()
if s[0]==s[1] and s[1]==s[2] :print("No")
else: print("Yes")
| 1 | 54,882,924,181,100 | null | 201 | 201 |
s=[int(i) for i in input()]
n=len(s)
ans=0
f=0
for i in range(n-1,-1,-1):
j=s[i]+f
if j<5:
ans+=j
f=0
elif j>5:
ans+=10-j
f=1
elif i and s[i-1]>=5:
ans+=10-j
f=1
else:
ans+=j
f=0
print(ans+f)
|
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()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
N = [0] + list(map(int,SI()))
ans = 0
for i in range(len(N)-1,-1,-1):
if N[i] < 6 and not(N[i] == 5 and (i > 0 and N[i-1] >= 5)):
ans += N[i]
else:
ans += 10 - N[i]
N[i-1] += 1
print(ans)
if __name__ == '__main__':
main()
| 1 | 70,817,475,706,300 | null | 219 | 219 |
S = input()
N = len(S)
if S == S[::-1]:
if S[:(N-1)//2] == S [(N+1)//2:]:
print("Yes")
else:
print("No")
else:
print("No")
|
# SelectionSort(A)
#1 for i = 0 to A.length-1
#2 mini = i
#3 for j = i to A.length-1
#4 if A[j] < A[mini]
#5 mini = j
#6 swap A[i] and A[mini]
# リストの宣言
A = []
# 入力の最初の行に、数列の長さを表す整数 N が与えられます。
# 2 行目に、N 個の整数が空白区切りで与えられます。
LENGTH =int(input())
A = input().split()
# 変数
i = 0
CHANGE_COUNT = 0
while i <= LENGTH -1:
j = i + 1
mini = i
while j <= LENGTH -1:
if int(A[j]) < int(A[mini]) :
mini = j
j += 1
if mini != i:
tmp = A[i]
A[i] = A[mini]
A[mini] = tmp
CHANGE_COUNT += 1
i += 1
print(" ".join(map(str,A)))
print (CHANGE_COUNT)
| 0 | null | 22,996,422,280,800 | 190 | 15 |
n, x, m = [int(x) for x in input().split()]
A = [x]
while len(A) < n:
a = (A[-1] * A[-1]) % m
if a not in A:
A.append(a)
else:
i = A.index(a)
loop_len = len(A) - i
print(sum(A[:i]) + sum(A[i:]) * ((n - i) // loop_len) + sum(A[i:i + ((n - i) % loop_len)]))
break
else:
print(sum(A))
|
n, x, m = map(int, input().split())
ans = 0
prev_set = set()
prev_list = list()
ans_hist = list()
r = x
for i in range(n):
if i == 0:
pass
else:
r = (r * r) % m
if r == 0:
break
if r in prev_set:
index = prev_list.index(r)
period = i - index
count = (n - index) // period
rest = (n - index) % period
ans = sum(prev_list[:index])
ans += sum(prev_list[index:i]) * count
# ans += (ans - ans_hist[index - 1]) * (count - 1)
ans += sum(prev_list[index:index+rest])
# ans += (ans_hist[index + rest - 1] - ans_hist[index - 1])
break
else:
ans += r
prev_set.add(r)
prev_list.append(r)
ans_hist.append(ans)
print(ans)
| 1 | 2,813,959,809,090 | null | 75 | 75 |
from collections import deque
def getdistance(row,col,sw,h,w):
maze = deque([[row,col,0]])
marker = [[0]*w for _ in range(h)]
marker[row][col] = 1
while len(maze)!=0:
r, c, d = maze.popleft()
if r!=0:
if sw[r-1][c]!="#" and marker[r-1][c] != 1:
marker[r-1][c] = 1
maze.append([r-1,c,d+1])
if r!=h-1:
if sw[r+1][c]!="#" and marker[r+1][c] != 1:
marker[r+1][c] = 1
maze.append([r+1,c,d+1])
if c!=w-1:
if sw[r][c+1]!="#" and marker[r][c+1] != 1:
marker[r][c+1] = 1
maze.append([r,c+1,d+1])
if c!=0:
if sw[r][c-1]!="#" and marker[r][c-1] != 1:
marker[r][c-1] = 1
maze.append([r,c-1,d+1])
return d
h, w = map(int, input().split())
sw = [input() for _ in range(h)]
ans = 0
for row in range(h):
for col in range(w):
if sw[row][col]=="#":
continue
ans = max(ans,getdistance(row,col,sw,h,w))
print(ans)
|
while True:
x,y = map(int, input().split())
if not x and not y:
break
else:
if x > y:
print(y,x)
else:
print(x,y)
| 0 | null | 47,697,653,813,418 | 241 | 43 |
n=int(input())
cnt=0
a=1
while(a*a<n):
cnt+=1
cnt+=max((n-1)//a-a,0)*2
a+=1
print(cnt)
|
def func(N):
result = 0
for A in range(1,N):
result += (N-1)//A
return result
if __name__ == "__main__":
N = int(input())
print(func(N))
| 1 | 2,556,022,716,328 | null | 73 | 73 |
def main():
S = input()
N = len(S)
S1 = S[0:(N - 1) // 2]
S2 = S[(N + 3) // 2 - 1:]
if S == S[::-1] and S1 == S1[::-1] and S2 == S2[::-1]:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
# String Palindrome
def is_palindrome(s):
res = s == s[::-1]
return res
S = input()
N = len(S)
ans = ['No', 'Yes'][is_palindrome(S) & is_palindrome(S[:((N-1)//2)]) & is_palindrome(S[((N+1)//2):])]
print(ans)
| 1 | 46,140,094,166,060 | null | 190 | 190 |
import heapq
n,k = map(int,input().split())
a = [int(i) for i in input().split()]
low = 0
high = 10**9
if k == 0:
print(max(a))
exit()
while low+1 < high:
tmp = 0
mid = (low + high) //2
for i in range(n):
tmp += ((a[i]+mid-1) // mid)-1
if tmp <= k:
high = mid
else:
low = mid
print(high)
|
from collections import deque
def solve():
N, M = map(int, input().split())
to = [[] for _ in range(N)]
for _ in range(M):
a, b = map(int, input().split())
a, b = a - 1, b - 1
to[a].append(b)
to[b].append(a)
que = deque()
hint = [0] * N
seen = [False] * N
seen[0] = True
que.appendleft(0)
# BFS
while que:
v = que.popleft()
for nv in to[v]:
if seen[nv]:
continue
que.append(nv)
hint[nv] = v + 1
seen[nv] = True
print("Yes")
print(*hint[1:], sep='\n')
if __name__ == "__main__":
solve()
| 0 | null | 13,396,104,773,270 | 99 | 145 |
m,d=map(int,input().split())
n,e=map(int,input().split())
print(1 if m!=n else 0)
|
n = int(input())
s = input()
r = set([i+1 for i in range(n) if s[i] == "R"])
g = set([i+1 for i in range(n) if s[i] == "G"])
b = set([i+1 for i in range(n) if s[i] == "B"])
ans = len(r)*len(g)*len(b)
def check(s1, s2, s3):
t = 0
for i in range(1, n+1):
if not i in s1:
continue
for j in range(i+1, n+1):
if not j in s2:
continue
if (j+(j-i)) in s3:
t += 1
return t
ans -= check(r, g, b)
ans -= check(r, b, g)
ans -= check(g, b, r)
ans -= check(g, r, b)
ans -= check(b, r, g)
ans -= check(b, g, r)
print(ans)
| 0 | null | 80,275,307,199,048 | 264 | 175 |
from collections import defaultdict
N = int(input())
A = [int(i) for i in input().split()]
ans = 0
d = defaultdict(int)
cur = N
for a in A[::-1]:
ans += d[cur + a]
if cur - a > 0:
d[cur - a] += 1
cur -= 1
print(ans)
|
#!/usr/bin/python3
def find(id, V, d, dist):
i = id - 1
dist[i] = d
for v in V[i]:
if dist[v - 1] == -1 or dist[v - 1] > d + 1:
find(v, V, d + 1, dist)
n = int(input())
# [isFind, d, f]
A = [[False, 0, 0] for i in range(n)]
U = []
V = []
dist = [-1] * n
for i in range(n):
l = list(map(int, input().split()))
U.append(l[0])
V.append(l[2:])
find(1, V, 0, dist)
for u in U:
print(u, dist[u - 1])
| 0 | null | 13,147,861,410,584 | 157 | 9 |
n = int(input())
a, b = map(int, input().split())
for i in range(a, b+1):
if(i%n==0):
print('OK')
exit(0)
print('NG')
|
a=int(input())
b,c=input().split()
b=int(b)
c=int(c)
if b%a==0 or c%a==0:
print("OK")
else:
if int(b/a)==int(c/a):
print("NG")
else:
print("OK")
| 1 | 26,387,217,565,002 | null | 158 | 158 |
#create date: 2020-07-03 10:10
import sys
stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def main():
a, b, c, k = na()
if k <= a:
print(k)
elif k <= a + b:
print(a)
else:
print(a-(k-(a+b)))
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
a, b, c, k = map(int, input().split())
r = min(k, a)
k -= a
if k > 0:
k -= b
if k > 0:
r -= k
print(r)
if __name__ == '__main__':
main()
| 1 | 22,012,474,660,640 | null | 148 | 148 |
# Can't Wait for Holiday
S = input()
if S == 'SUN':
a = 0
elif S == 'MON':
a = 1
elif S == 'TUE':
a = 2
elif S == 'WED':
a = 3
elif S == 'THU':
a = 4
elif S == 'FRI':
a = 5
elif S == 'SAT':
a = 6
answer = 7 - a
print(answer)
|
ans = input()
if ans == "SUN": print(7)
if ans == "MON": print(6)
if ans == "TUE": print(5)
if ans == "WED": print(4)
if ans == "THU": print(3)
if ans == "FRI": print(2)
if ans == "SAT": print(1)
| 1 | 133,402,638,093,790 | null | 270 | 270 |
s=[input() for _ in range(int(input()))]
def c(b):return str(s.count(b))
x=' x '
n='\n'
a='AC'
w='WA'
t='TLE'
r='RE'
print(a+x+c(a)+n+w+x+c(w)+n+t+x+c(t)+n+r+x+c(r))
|
n=int(input())
l=['AC','WA','TLE','RE']
d=[0,0,0,0]
for i in range(n):
s=input()
if(s=='AC'):
d[0]+=1
elif(s=='WA'):
d[1]+=1
elif(s=='TLE'):
d[2]+=1
else:
d[3]+=1
for i in range(4):
print(l[i],'x',d[i])
| 1 | 8,697,445,234,930 | null | 109 | 109 |
from sys import exit
import math
import collections
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
s = input()
print(chr(ord(s)+1))
|
i = input()
i_l = i.split()
count = 0
for each in range(int(i_l[0]),int(i_l[1])+1):
if int(i_l[2]) % each == 0:
count += 1
else:
print(count)
| 0 | null | 46,331,651,645,412 | 239 | 44 |
s = list( raw_input( ) )
n = int( raw_input( ) )
for i in range( n ):
cmd = raw_input( ).split( " " )
a = int( cmd[1] )
b = int( cmd[2] ) + 1
if "print" == cmd[0]:
print( "".join( s[ a:b ] ) )
elif "reverse" == cmd[0]:
for i in reversed( s[ a:b ] ):
s[ a ] = i
a += 1
elif "replace" == cmd[0]:
for i in cmd[3]:
s[ a ] = i
a += 1
|
N,T = map(int,input().split())
X = []
for i in range(N):
a,b = map(int,input().split())
X.append((a,b))
X.sort()
#print(X)
A = [];B = []
for i in range(N):
A.append(X[i][0])
B.append(X[i][1])
dp = [[0 for _ in range(T)] for _ in range(N+1)]
#dp[i][j] i番目までの料理を頼んだ時j分後の最大値
ans = 0
for i in range(N):
time, aji = X[i]
for j in range(T):
if j-time >= 0:
dp[i+1][j] = max(dp[i][j-time] + aji,dp[i][j])
else:
dp[i+1][j] = dp[i][j]
if i < N-1:
last = max(B[i+1:])
else:
last = 0
#print(ans,last,dp[i+1][T-1])
ans = max(ans,dp[i+1][T-1]+last)
print(ans)
| 0 | null | 76,736,577,141,378 | 68 | 282 |
def A():
x = int(input())
if x >= 30:
print("Yes")
else:
print("No")
A()
|
n,k =map(int, input().split())
h = list(map(int, input().split()))
# n = int(input())
# s = [map(int, input()) for i in range(3)]
count = 0
for i in range (0,n):
if h[i] < k:
count+=1
print(n-count)
| 0 | null | 92,689,273,266,282 | 95 | 298 |
ret = []
while True:
n, x = map(int, raw_input().split())
num_arr = [i for i in range(1, n+1)]
if (n, x) == (0, 0):
break
cnt = 0
for i in range(n, 0, -1):
for j in range(i -1, 0, -1):
if 0 < x - i - j < j:
cnt += 1
ret += [cnt]
for i in ret:
print i
|
# 12-Structured_Program_II-How_many_ways.py
# ????????????????????°
# 1 ?????? n ?????§?????°?????????????????????????????§???????????°?????????????????????????¨???? x ??¨??????
# ????????????????????°????±???????????????°?????????????????????????????????
# ????????°???1 ?????? 5 ?????§?????°???????????????????????§????????????????¨???? 9 ??¨???????????????????????????
# 1 + 3 + 5 = 9
# 2 + 3 + 4 = 9
# ??????????????????????????????
# Input
# ?????°??????????????????????????\?????¨???????????????????????????
# ???????????????????????§??????????????§??????????????? n???x ??? 1 ???????????????????????????
# n???x ?????¨?????? 0 ?????¨?????\?????????????????¨????????????
# n ??? 3 ??\??? 100?????\?????¨????????????
# Output
# ????????????????????????????????????????????????????????°????????????????????????????????????
# Sample Input
# 5 9
# 0 0
# Sample Output
# 2
result = []
n=[]
x=[]
while 1:
temp = input().split()
if temp[0]=="0" and temp[1]=="0":
break;
else:
n.append( int( temp[0] ))
x.append( int( temp[1] ))
for i in range( len(n) ):
count =0
for n1 in range(1,n[i]+1-2):
for n2 in range(n1+1, n[i]+1-1):
for n3 in range(n2+1, n[i]+1):
sum = n1+n2+n3
if sum == x[i]:
count+=1
result.append(count)
for i in range( len(result) ):
print(result[i])
# if i == len(result)-1:
# print(result[i])
# else:
# print("{0} ".format(result[i]), end="")
| 1 | 1,298,056,537,440 | null | 58 | 58 |
import sys
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def roots(self):
return [i for i, x in enumerate(self.table) if x < 0]
def group_count(self):
return len(self.roots())
def main():
n, m = map(int, sys.stdin.buffer.readline().split())
U = UnionFind(n)
for i in sys.stdin.buffer.readlines():
a, b = map(lambda x: int(x) - 1, i.split())
U.union(a, b)
print(U.group_count() - 1)
if __name__ == "__main__":
main()
|
N, M, K = map(int, input().split())
class UnionFind:
def __init__(self, n):
self.ps = [-1] * (n + 1)
def find(self, x):
if self.ps[x] < 0:
return x
else:
self.ps[x] = self.find(self.ps[x])
return self.ps[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
if self.ps[x] > self.ps[y]:
x, y = y, x
self.ps[x] += self.ps[y]
self.ps[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
x = self.find(x)
return -self.ps[x]
uf = UnionFind(N)
friends = [0]*(N+1)
chain = [0]*(N+1)
for _ in range(M):
A, B = map(int, input().split())
friends[A] += 1
friends[B] += 1
uf.union(A, B)
for _ in range(K):
C, D = map(int, input().split())
if uf.same(C, D):
friends[C] += 1
friends[D] += 1
ans = []
for i in range(1, N+1):
ans.append(uf.size(i) - friends[i] - 1)
print(*ans)
| 0 | null | 31,866,568,274,528 | 70 | 209 |
n, m, l = [int(i) for i in input().split()]
A = []
B = []
C = []
for ni in range(n):
A.append([int(i) for i in input().split()])
for mi in range(m):
B.append([int(i) for i in input().split()])
for i in range(n):
C.append([])
for j in range(l):
C[i].append(0)
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
for li in range(n):
print(" ".join([str(s) for s in C[li]]))
|
n, m, L = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(m)]
c = [[sum(ak * bk for ak, bk in zip(ai,bj)) for bj in zip(*b)] for ai in a]
for ci in c:
print(*ci)
| 1 | 1,446,641,142,362 | null | 60 | 60 |
from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def main():
n = int(input())
# 一番大きいものは何か、それを保存してdfs
def dfs(cnt, s):
if cnt == n:
print(s)
return
biggest = 'a'
c = 0
while c < len(s):
if s[c] == biggest:
biggest = chr(ord(biggest)+1)
c += 1
else:
c += 1
for i in range(0,ord(biggest) - ord('a') + 1):
sc = chr(ord('a')+i)
s += sc
dfs(cnt + 1, s)
s = s[:-1]
dfs(0,"")
if __name__ == '__main__':
main()
|
# https://atcoder.jp/contests/panasonic2020/submissions/12881278
# D - String Equivalence
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(input())
def dfs(S, available):
if len(S) == n:
print("".join(S))
return
for i in range(available + 1):
S.append(chr(97 + i))
dfs(S, max(available, i + 1))
S.pop()
dfs([], 0)
if __name__ == '__main__':
resolve()
| 1 | 52,618,748,838,528 | null | 198 | 198 |
import math
a, b, C = map(int, raw_input().split())
S = a * b * math.sin(math.radians(C)) / 2
L = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(C))) + a + b
h = 2*S/a
print S
print L
print h
|
x = 1
L=[]
n= 0
s=0
while x is not 0:
x = int(input())
L.append(x)
N=1
L.remove(0)
for i in L:
while i >=N:
N=10*N
n =i%N
s+=(n/N*10)
i-=n
print (int(s))
s=0
N = 1
| 0 | null | 874,803,180,692 | 30 | 62 |
N, M = map(int, input().split())
A = input().split()
work_days = 0
for i in range(M):
work_days += int(A[i])
if work_days > N:
print(-1)
else:
print(N - work_days)
|
a = int(input())
b = a*a*a
c = a*a
print(a+b+c)
| 0 | null | 20,982,522,191,612 | 168 | 115 |
#coding:utf-8
#1_1_D 2015.3.6
second = int(input())
hour = second // 3600
minutes = (second // 60) % 60
second %= 60
print("%s:%s:%s" %(hour,minutes,second))
|
k=int(input())
e="ACL"
et=""
for i in range(k):
et+=e
print(et)
| 0 | null | 1,252,850,464,932 | 37 | 69 |
from collections import deque
n = int(input())
queue = deque([[1],[2],[3],[4],[5],[6],[7],[8],[9]]) # 初期化_ここでは正の一桁整数として'1'～'9'を設置
ptns = [] # パターン候補の器_初期化
while queue: # queueが空になるまでループ
tmp = queue.popleft() # パターンの候補を popleft
if len(ptns) < n: # ptnsの要素数が'n'個未満ならば append
ptns.append(tmp)
else:
break
# 以下、tmpに各々tmp[-1]-1、tmp[-1]、tmp[-1]+1をappendするための条件
if tmp[-1] != 0:
queue.append(tmp + [tmp[-1] -1])
queue.append(tmp + [tmp[-1]])
if tmp[-1] != 9:
queue.append(tmp + [tmp[-1] +1])
# リスト = map(str, リスト) ← intのリストからstrのmapオブジェクトへ変換
print(''.join(map(str, ptns[-1])))
|
n = int(input())
mod = 10 ** 9 + 7
start,zero,nine,ans = 1,0,0,0
for i in range(n):
ans = (ans * 10 + zero + nine) % mod
zero = (zero * 9 + start) % mod
nine = (nine * 9 + start) % mod
start = (start * 8) % mod
print(ans)
| 0 | null | 21,512,763,597,182 | 181 | 78 |
def main():
S = input()
def an_area(S):
ans = 0
stack_in = []
stack_out = []
for i,ch in enumerate(S):
if ch == '\\':
stack_in.append(i)
elif stack_in and ch == '/':
j = stack_in.pop()
cur = i - j
stack_out.append((j,i,cur))
ans += cur
return ans,stack_out
ans, l = an_area(S)
if ans == 0:
print(ans)
print(len(l))
return
l.sort()
pre_le, pre_ri = l[0][0], l[0][1]
pre_ar = 0
areas = []
for le,ri,ar in l:
if pre_le <= ri <= pre_ri:
pre_ar += ar
else:
areas.append(pre_ar)
pre_ar = ar
pre_le, pre_ri = le, ri
else:
areas.append(pre_ar)
print(ans)
print(len(areas),*areas)
if __name__ == '__main__':
main()
|
input()
numbers = input().split()
numbers.reverse()
print(" ".join(numbers))
| 0 | null | 514,211,491,970 | 21 | 53 |
while True:
d = input()
if d == '-':
break
h = int(input())
rotate = 0
for i in range(h):
rotate += int(input())
move = rotate % len(d)
print(d[move:] + d[:move])
|
while True:
C=input()
if C=="-":
break
else:
m=int(input())
for i in range(m):
h=int(input())
c=C[0 : h]
C=C[h : len(C) + 1]
C+=c
print(C)
| 1 | 1,938,251,539,520 | null | 66 | 66 |
h = int(input())
w = int(input())
n = int(input())
print(min(-(-n//h),-(-n//w)))
|
A = int (input ())
B = int (input ())
N = int (input ())
if A < B:
X = N//B
if N%B == 0:
print (X)
else:
print (X+1)
else:
X = N//A
if N%A == 0:
print (X)
else:
print (X+1)
| 1 | 89,043,920,784,530 | null | 236 | 236 |
a = input()
n = ord(a)
if ord('A') <= n <= ord('Z'):
print('A')
else:
print('a')
|
search = raw_input().upper()
sentence = []
while 1:
input_data = raw_input()
if input_data == 'END_OF_TEXT':
break
sentence += [s.upper() for s in input_data.split()]
ret = 0
for word in sentence:
ret += 1 if word == search else 0
print ret
| 0 | null | 6,563,184,396,098 | 119 | 65 |
N=int(input())
resurt=''
for i in range(1,10):
if N%i ==0 and N//i<=9:
result='Yes'
break
else:
result='No'
print(result)
|
def modpow(a, x, mod):
if x == 0:
return 1
elif x % 2 == 0:
return modpow((a * a) % mod, x // 2, mod)
else:
return (modpow((a * a) % mod, x // 2, mod) * a) % mod
N, M, K = map(int, input().split(' '))
max_K = 3 * 10 ** 5
mod = 998244353
inv = [0 for i in range(max_K + 1)]
inv[0] = 1
inv[1] = 1
for i in range(2, K + 1):
inv[i] = modpow(i, mod - 2, mod)
choose = [0 for i in range(K + 1)]
choose[0] = 1
for i in range(1, K + 1):
choose[i] = choose[i - 1] * (((N - i) * inv[i]) % mod)
choose[i] %= mod
ans = 0
for i in range(N - 1 - K, N):
ans += modpow((M - 1), i, mod) * choose[N - i - 1]
ans %= mod
print((ans * M) % mod)
| 0 | null | 91,554,042,864,032 | 287 | 151 |
N, M = map(int, input().split())
to = [[] for i in range(100010)]
for i in range(M):
a, b = map(int, input().split())
to[a].append(b)
to[b].append(a)
dist = [0] * (N+1)
q = [1]
dist[0] = -1
#print(to[:4])
dist = [0] * N
pre = [0] * N
while len(q) != 0:
a = q.pop(0)
for i in to[a]:
if dist[i-1] == 0:
dist[i-1] = dist[a-1] + 1
pre[i-1] = a
q.append(i)
#print(q)
print("Yes")
for i in range(1, N):
print(pre[i])
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
count = 0
l, r, d= [int(x) for x in readline().rstrip().split()]
#print(l,r,d)
for i in range(l,r+1):
if i % d == 0:
count += 1
print(count)
| 0 | null | 14,067,376,247,858 | 145 | 104 |
A, B, C = map(int, input().split())
K = int(input())
cnt = 0
while A>=B:
cnt+=1
B*=2
while B>=C:
cnt+=1
C*=2
print("Yes" if cnt<=K else "No")
|
suuretsu = [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]
number = int(input(''))
print(suuretsu[number - 1])
| 0 | null | 28,522,194,896,790 | 101 | 195 |
count = 0
def main():
input()
A = [int(x) for x in list(input().split())]
merge_sort(A, 0, len(A))
print(*A)
print(count)
def merge_sort(A, left, right):
if left+1 < right:
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
# リストの左側を作成
L = A[left:mid]
# リストの右側を作成
R = A[mid:right]
# 終端追加
L.append(float("inf"))
R.append(float("inf"))
i = 0
j = 0
for k in range(left, right):
count += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
if __name__ == '__main__':
main()
|
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)
elif b>c:
(b,c)=(c,b)
if b>c:
(b,c)=(c,b)
print(a,b,c)
| 0 | null | 256,539,581,408 | 26 | 40 |
def pre_combi1(n, p):
fact = [1]*(n+1) # fact[n] = (n! mod p)
factinv = [1]*(n+1) # factinv[n] = ((n!)^(-1) mod p)
inv = [0]*(n+1) # factinv 計算用
inv[1] = 1
# 前処理
for i in range(2, n + 1):
fact[i]= fact[i-1] * i % p
inv[i]= -inv[p % i] * (p // i) % p
factinv[i]= factinv[i-1] * inv[i] % p
return fact, factinv
def combi1(n, r, p, fact, factinv):
if r < 0 or n < r:
return 0
r = min(r, n-r)
return fact[n] * factinv[r] * factinv[n-r] % p
import sys
x,y=map(int,input().split())
if (x+y)%3 > 0:
print(0)
sys.exit()
n=(x+y)//3
r=x-n
f,inv=pre_combi1(n,1000000007)
print(combi1(n,r,1000000007,f,inv))
|
import sys
p=10**9+7
x,y=map(int,input().split())
if (x+y)%3!=0 or x>2*y or y>2*x:
print(0)
sys.exit()
a=(-x+2*y)//3
b=(2*x-y)//3
A=1
for i in range(1,a+1):
A=A*i
A=A%p
B=1
for i in range(1,b+1):
B=B*i
B=B%p
AB=1
for i in range(1,a+b+1):
AB=AB*i
AB=AB%p
C=(AB*pow(A,p-2,p)*pow(B,p-2,p))%p
print(C)
| 1 | 149,812,344,986,080 | null | 281 | 281 |
def resolve():
N, T = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(N)]
AB.sort()
dp = [[0] * (T + 1) for _ in range(N + 1)]
for i in range(N):
t, v = AB[i]
for j in range(T + 1):
if t + j <= T:
dp[i + 1][j + t] = max(dp[i + 1][j + t], dp[i][j] + v)
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
ans = 0
for i, (t, v) in enumerate(AB):
ans = max(ans, dp[i][T - 1] + v)
print(ans)
if __name__ == "__main__":
resolve()
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def main():
N, T = LI()
AB = []
for i in range(N):
_a, _b = LI()
AB.append((_a, _b))
AB = sorted(AB, key=lambda x: (x[0], x[1]))
a = [elem[0] for elem in AB]
b = [elem[1] for elem in AB]
dp = [[0 for _ in range(T + 3001)] for _ in range(N+1)]
for i in range(N):
for t in range(T):
dp[i+1][t+a[i]] = max(dp[i+1][t+a[i]], dp[i][t] + b[i])
dp[i+1][t] = max(dp[i+1][t], dp[i][t])
ans = 0
for i in range(N+1):
for j in range(T + 3001):
ans = max(dp[i][j], ans)
print(ans)
main()
| 1 | 151,197,165,430,248 | null | 282 | 282 |
n=int(input())
minv=int(input())
maxv=-float('inf')
for _ in range(n-1):
tmp=int(input())
maxv=max(maxv,tmp-minv)
minv=min(minv,tmp)
print(maxv)
|
n = int(raw_input())
minv = int(raw_input())
maxv = -1*10**9
for j in range( n-1 ):
num = int( raw_input( ) )
diff = num - minv
if maxv < diff:
maxv = diff
if num < minv:
minv = num
print maxv
| 1 | 13,038,601,140 | null | 13 | 13 |
N=input()
i=0
while i<len(N):
print("x" ,end='')
i+=1
|
S = input()
N = len(S)
ans = ["x" for i in range(N)]
print(*ans, sep="")
| 1 | 72,756,413,827,888 | null | 221 | 221 |
while 1:
n, x = map(int, raw_input().split())
if n == 0 and x == 0:
break
count = 0
for i in xrange(1, n-1):
for j in xrange(i+1, n):
for k in xrange(j+1, n+1):
if i+j+k > x:
break
if i+j+k == x:
count += 1
print count
|
def solution():
user_input = input()
user_input = user_input.split()
for i in range(len(user_input)):
if user_input[i] == '0':
print(i+1)
solution()
| 0 | null | 7,423,475,160,810 | 58 | 126 |
n = int(input())
s = input()
ans = s.count('R') * s.count('G') * s.count('B')
for i in range(n):
for j in range(i + 1, n):
if j * 2 - i >= n:
continue
if s[i] == s[j] or s[j] == s[2 * j - i] or s[i] == s[2 * j - i]:
continue
ans -= 1
print(ans)
|
n=int(input())
s='*'+input()
r=s.count('R')
g=s.count('G')
b=s.count('B')
cnt=0
for i in range(1,n+1):
for j in range(i,n+1):
k=2*j-i
if k>n:
continue
if s[i]!=s[j] and s[j]!=s[k] and s[k]!=s[i]:
cnt+=1
print(r*g*b-cnt)
| 1 | 36,244,050,243,336 | null | 175 | 175 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n = int(input())
for i in range(2,int(n**.5) + 1):
if n % i == 0:
tmp = n
while tmp % i==0:
tmp //= i
if (tmp-1) % i == 0:ans += 1
if n//i != i:
tmp = n;i = n//i
while tmp % i==0:
tmp //= i
if (tmp-1) % i == 0:ans += 1
for i in range(2,int((n-1)**.5 )+ 1):
if (n-1) % i == 0:
if (n-1) // i == i: ans += 1
else: ans += 2
# print(ans)
print(ans+1 + int(n != 2))
|
import math
a, b , n = map(int, input().split())
ans1 = (a*(b-1))//b
ans2 = (a*n)//b
print(min(ans1, ans2))
| 0 | null | 34,768,040,357,702 | 183 | 161 |
a = int(input())
count = 0
for i in range(a):
x,y = map(int,input().split(" "))
if x == y:
count += 1
else:
count = 0
if count == 3:
print('Yes')
exit()
print("No")
|
n = int(input())
s = 0
for i in range(n):
x,y = map(int,input().split())
if x == y:
s += 1
if s == 3:
print("Yes")
quit()
else:
s = 0
print("No")
| 1 | 2,497,460,887,170 | null | 72 | 72 |
x = raw_input()
print(str(int(x) ** 3))
|
dic = {'AC':0, 'WA':0, 'TLE':0, 'RE':0}
N = int(input())
for i in range(N):
dic[input()] += 1
for i in dic:
print(i, 'x', dic[i])
| 0 | null | 4,497,697,222,960 | 35 | 109 |
S, T = input().split()
A, B = list(map(int, input().split()))
U = input()
if S == U:
print("{} {}".format(A - 1, B))
else:
print("{} {}".format(A, B - 1))
|
N = int(input())
es = [[] for _ in range(N)]
connected = [0] * N
for i in range(N-1):
a,b = map(int, input().split())
a,b = a-1, b-1
connected[a] += 1
connected[b] += 1
es[a].append((b, i))
es[b].append((a, i))
ans = [0] * (N-1)
used = [False] * (N-1)
q = []
q.append((0, 0))
while q:
curr, pc = q.pop()
nxt_es_color = 1
for nxt, es_num in es[curr]:
if used[es_num]:
continue
if nxt_es_color == pc:
nxt_es_color += 1
ans[es_num] = nxt_es_color
used[es_num] = True
q.append((nxt, ans[es_num]))
nxt_es_color += 1
print(max(connected))
print(*ans, sep="\n")
| 0 | null | 104,102,841,717,380 | 220 | 272 |
while True:
a=map(int,raw_input().split())
if a==[0,0]:
break
if a[0]>a[1]:print(str(a[1])+" "+str(a[0]))
else: print(str(a[0])+" "+str(a[1]))
|
while True:
(x, y) = [int(i) for i in input().split()]
if x == y == 0:
break
if x < y:
print(x, y)
else:
print(y, x)
| 1 | 524,663,008,988 | null | 43 | 43 |
# -*- coding: utf-8 -*-
import sys
from collections import deque, defaultdict
from math import sqrt, factorial, gcd
# def input(): return sys.stdin.readline()[:-1] # warning not \n
# def input(): return sys.stdin.buffer.readline().strip() # warning bytes
# def input(): return sys.stdin.buffer.readline().decode('utf-8')
def solve():
n, k = [int(x) for x in input().split()]
R, S, P = [int(x) for x in input().split()]
s = input()
ans = 0
b = []
for i in range(n):
e = s[i]
if i < k or s[i] != s[i-k] or s[i-k] == b[i-k]:
if e == 'r':
ans += P
b.append('p')
elif e == 'p':
ans += S
b.append('s')
elif e == 's':
ans += R
b.append('r')
else:
b.append(e)
print(ans)
t = 1
# t = int(input())
for case in range(1,t+1):
ans = solve()
"""
R s
S p
P r
"""
|
from collections import deque
N, u, v = map(int, input().split())
u -= 1
v -= 1
edge = [[] for _ in range(N)]
for _ in range(N - 1):
A, B = map(int, input().split())
edge[A - 1].append(B - 1)
edge[B - 1].append(A - 1)
INF = 10 ** 6
lenA = [INF] * N
q = deque()
q.append((v, 0))
lenA[v] = 0
while len(q) > 0:
p, step = q.popleft()
for np in edge[p]:
if lenA[np] == INF:
lenA[np] = step + 1
q.append((np, step + 1))
lenT = [INF] * N
q = deque()
q.append((u, 0))
lenT[u] = 0
ans = 0
while len(q) > 0:
p, step = q.popleft()
if len(edge[p]) == 1:
ans = max(ans, step + (lenA[p] - step) - 1)
for np in edge[p]:
if lenT[np] == INF and lenA[np] > step + 1:
lenT[np] = step + 1
q.append((np, step + 1))
print(ans)
| 0 | null | 111,795,672,197,690 | 251 | 259 |
N,K=map(int,input().split())
P=list(map(lambda x: (int(x)+1)/2,input().split()))
s=tmp=sum(P[:K])
for i in range(K,N):
tmp=tmp-P[i-K]+P[i]
s=max(s,tmp)
print(s)
|
def main():
n, k = map(int, input().split())
p_lst = list(map(int, input().split()))
lst = []
for i in range(n):
lst.append((p_lst[i] + 1) / 2)
tmp_sum = sum(lst[:k])
maximum = tmp_sum
for i in range(n - k):
tmp_sum -= lst[i]
tmp_sum += lst[i + k]
maximum = max(maximum, tmp_sum)
print(maximum)
if __name__ == '__main__':
main()
| 1 | 74,817,674,103,422 | null | 223 | 223 |
import math
def solve():
a,b,h,m=map(int,input().split())
sita=math.pi*2*((h+m/60)/12-m/60)
c=math.sqrt(a*a+b*b-2*a*b*math.cos(sita))
return c
print(solve())
|
##### ABC 160
K,N = map(int, input().split())
A = list(map(int,input().split()))
dist = []
for i in range(N-1):
dist.append(A[i+1]-A[i])
dist.append(K-A[-1]+A[0])
dist.sort()
ans = 0
for i in range(N-1):
ans += dist[i]
print(ans)
| 0 | null | 31,763,201,234,050 | 144 | 186 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(read())
print((N + 1) // 2)
|
readline = open(0).readline
N, M = map(int, readline().split())
A = [list(map(int, readline().split())) for i in range(N)]
B = [int(readline()) for i in range(M)]
print(*map((lambda Ai: sum(a*b for a, b in zip(Ai, B))), A), sep='\n')
| 0 | null | 30,264,600,222,308 | 206 | 56 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#inf = 10**17
mod = 10**9 + 7
def ncr(n, r, mod):
r = min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n+1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
n = input().rstrip()
k = int(input())
ln = len(n)
if ln < k:
print(0)
exit()
res = 0
if k == 1:
if ln >= 2:
res += ncr(ln-1, 1, mod) * 9
res += int(n[0])
if k == 2:
if ln >= 3:
res += ncr(ln-1, 2, mod) * (9**k)
res += ncr(ln-1, 1, mod) * 9 * (int(n[0])-1)
for i in range(1, ln):
if n[i] != '0':
if i == ln-1:
res += int(n[i])
else:
res += ncr(ln-i-1, 1, mod) * 9
res += int(n[i])
break
if k == 3:
if ln >= 4:
res += ncr(ln-1, 3, mod) * (9**k)
res += ncr(ln-1, 2, mod) * 81 * (int(n[0])-1)
for i in range(1, ln-1):
if n[i] != '0':
if ln-i-1 >= 2:
res += ncr(ln-i-1, 2, mod) * 81
res += ncr(ln-i-1, 1, mod) * 9 * (int(n[i])-1)
for j in range(i+1, ln):
if n[j] != '0':
if j != ln-1:
res += ncr(ln-j-1, 1, mod) * 9
res += int(n[j])
break
break
print(res)
if __name__ == '__main__':
main()
|
l=input().split()
n=int(l[0])
m=int(l[1])
#receive vecter a(n*m)
i=0
A=[]
while i<n:
a=input().split()
for p in a:
A.append(int(p))
i+=1
#receive vecter b(m*1)
I=0
B=[]
while I<m:
b=int(input())
B.append(b)
I+=1
#Ci=ai1b1+ai2b2+...+aimbm
#C[i]=a[m*(i)+1]*b[1]+a[m*(i)+2]*b[2]+...a[m*(i)+m]*b[m]
q=0
C=[]
while q<n:
Q=0
cq=0
while Q<m:
cq+=A[m*q+Q]*B[Q]
Q+=1
C.append(cq)
q+=1
for x in C:
print(x)
| 0 | null | 38,297,379,087,836 | 224 | 56 |
N = int(input())
S = sorted([input() for x in range(N)])
word = [S[0]]+[""]*(N-1) #単語のリスト
kaisuu = [0]*N #単語の出た回数のリスト
k = 0 #今wordリストのどこを使っているか
for p in range(N): #wordとkaisuuのリスト作成
if word[k] != S[p]:
k += 1
word[k] = S[p]
kaisuu[k] += 1
else:
kaisuu[k] += 1
m = max(kaisuu) #m:出た回数が最大のもの
ansnum = [] #出た回数が最大のもののwordリストでの位置
for q in range(N):
if kaisuu[q] == m:
ansnum += [q]
for r in range(len(ansnum)):
print(word[ansnum[r]])
|
import sys
from io import StringIO
import unittest
import os
# union find木
# 参考：https://note.nkmk.me/python-union-find/
class UnionFind:
def __init__(self, n):
"""
コンストラクタ
:要素数 n:
"""
self.n = n
# 添字x: 値yとすると・・
# root以外の場合： 要素xは集合yに所属する。
# rootの場合 ： 集合xの要素数はy個である。(負数で保持する)
self.parents = [-1] * n
def getroot(self, x):
"""
所属する集合(ルートの番号)を取得する。
:調査する要素 x:
"""
# 値が負数 = ルートに到達したので、ルート木の番号を返す。
if self.parents[x] < 0:
return x
else:
# 値が正数 = ルートに到達していない場合、さらに親の情報を確認する。
# 下の行は経路圧縮の処理。
self.parents[x] = self.getroot(self.parents[x])
return self.parents[x]
def union(self, x, y):
"""
2つの要素が所属する集合をを同じ集合に結合する。
:結合する要素(1つ目) x:
:結合する要素(2つ目) y:
"""
# 既に同じ集合に存在するなら何もせず終了。
x = self.getroot(x)
y = self.getroot(y)
if x == y:
return
# 集合を結合する。
# ※ここ、「要素数の大きい集合に、少ない集合を結合」しているが、こうすることで以後の「処理量を削減」するテクニックである。
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
"""
指定した集合に属する要素数を取得する。
:調査する集合 x:
"""
# 添え字[root]には、要素数が負数で格納されている。そのため、取得する際は-反転する。
return -self.parents[self.getroot(x)]
def is_same(self, x, y):
return self.getroot(x) == self.getroot(y)
def members(self, x):
root = self.getroot(x)
return [i for i in range(self.n) if self.getroot(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
# 実装を行う関数
def resolve():
# 数値取得サンプル
# 1行N項目 x, y = map(int, input().split())
# N行N項目 x = [list(map(int, input().split())) for i in range(n)]
n, m, k = map(int, input().split())
friends = [list(map(int, input().split())) for i in range(m)]
blocks = [list(map(int, input().split())) for i in range(k)]
# uf 作成(要素数を+1しているのは添え字と人番号を合わせるため)
uf = UnionFind(n + 1)
# 除外リスト作成(これは、本問題特有の処理)
# 添字x: 値yとすると・・ 要素xの友達候補を数えるとき、y(list)に該当する人は除外する。(要素数を+1しているのは添え字と人番号を合わせるため)
omits = [[] for i in range(n + 1)]
# UnionFindにて集合を明確にする。
for friend in friends:
uf.union(friend[0], friend[1])
# 除外リストを更新(これは、本問題特有の処理)
omits[friend[0]].append(friend[1])
omits[friend[1]].append(friend[0])
# ブロックリストの情報を除外リストに加える(これは、本問題特有の処理)
for block in blocks:
# 同じ集合に属するウ場合のみ、リストに追加
if uf.is_same(block[0], block[1]):
omits[block[0]].append(block[1])
omits[block[1]].append(block[0])
# 友達候補数を出力して終了(人は1始まりなので1からループを行う
# ans = []
# for i in range(1, n + 1):
# 友達候補 = 集合数 - 除外リスト(自分の友人数 + 自分がブロックしている人数) - 1(集合に含まれる自分自身を除く)
# ans.append(uf.size(i) - len(omits[i]) - 1)
# print(" ".join(ans))
# ans = [str(uf.size(i) - len(omits[i]) - 1) for i in range(1, n + 1)]
ans = [uf.size(i) - len(omits[i]) - 1 for i in range(1, n + 1)]
print(*ans)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """4 4 1
2 1
1 3
3 2
3 4
4 1"""
output = """0 1 0 1"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """5 10 0
1 2
1 3
1 4
1 5
3 2
2 4
2 5
4 3
5 3
4 5"""
output = """0 0 0 0 0"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """10 9 3
10 1
6 7
8 2
2 5
8 4
7 3
10 9
6 4
5 8
2 6
7 5
3 1"""
output = """1 3 5 4 3 3 3 3 1 0"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def tes_t_1original_1(self):
test_input = """データ"""
output = """データ"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| 0 | null | 66,140,901,948,680 | 218 | 209 |
def GSD(x, y):
while True:
x0 = max(x, y)
y0 = min(x, y)
if x0 % y0 == 0:
return y0
x = x0 % y0
y = y0
x, y = map(int, input().split(' '))
print(GSD(x, y))
|
from bisect import bisect_left
n = int(input())
L = list(map(int, input().split()))
L.sort()
cnt = 0
for a in range(n-2):
for b in range(a+1, n-1):
cnt += bisect_left(L,L[a]+L[b])-(b+1)
print(cnt)
| 0 | null | 85,916,099,365,530 | 11 | 294 |
n=int(input())
dp=[0]*(n+1)
dp[0]=1
dp[1]=1
def rec(x):
if dp[x]>0:
return dp[x]
res=rec(x-1)+rec(x-2)
dp[x]=res
return dp[x]
print(rec(n))
|
import heapq
def main():
N, M = list(map(int, input().split(' ')))
S = input()
# 最短手数のdpテーブルを作る
T = S[::-1] # ゴールから逆順にたどる（最後に逆にする）
dp = [-1] * (N + 1)
que = [0] * M
for i, t in enumerate(T):
if i == 0:
dp[0] = 0
continue
if len(que) == 0:
print(-1)
return
index = heapq.heappop(que)
if t == '1':
continue
dp[i] = 1 + dp[index]
while len(que) < M:
heapq.heappush(que, i)
dp.reverse()
# 細切れに進んでいく
path = list()
target = dp[0] - 1
cnt = 0
for i in range(N + 1):
if dp[i] != target:
cnt += 1
else:
path.append(cnt)
cnt = 1
target -= 1
print(' '.join(map(str, path)))
if __name__ == '__main__':
main()
| 0 | null | 69,787,884,399,534 | 7 | 274 |
n = int(input())
a = list(map(int, input().split()))
if n % 2 == 0 and n >= 4:
dp = [[0, 0] for i in range(n)]
dp[0][0] = a[0]
dp[1][1] = a[1]
dp[2][0] = a[0] + a[2]
for i in range(3, n):
dp[i][0] = dp[i - 2][0] + a[i]
dp[i][1] = max(dp[i - 3][0], dp[i - 2][1]) + a[i]
print(max(dp[n - 2][0], dp[n - 1][1]))
elif n % 2 != 0 and n >= 5:
dp = [[0, 0, 0] for i in range(n)]
dp[0][0] = a[0]
dp[1][1] = a[1]
dp[2][0] = a[0] + a[2]
dp[2][2] = a[2]
dp[3][1] = a[1] + a[3]
dp[3][2] = a[0] + a[3]
for i in range(3, n):
dp[i][0] = dp[i - 2][0] + a[i]
dp[i][1] = max(dp[i - 3][0], dp[i - 2][1]) + a[i]
dp[i][2] = max(dp[i - 4][0], dp[i - 3][1], dp[i - 2][2]) + a[i]
print(max(dp[n - 3][0], dp[n - 2][1], dp[n - 1][2]))
elif n == 2:
print(max(a[0], a[1]))
else:
print(max(a[0], a[1], a[2]))
|
from collections import defaultdict
INF = float("inf")
N, *A = map(int, open(0).read().split())
I = defaultdict(lambda: -INF)
O = defaultdict(lambda: -INF)
O[(0, 0)] = 0
for i, a in enumerate(A, 1):
j = (i - 1) // 2
for n in [j, j + 1]:
I[(i, n)] = a + O[(i - 1, n - 1)]
O[(i, n)] = max(O[(i - 1, n)], I[(i - 1, n)])
print(max(I[(N, N // 2)], O[(N, N // 2)]))
| 1 | 37,269,926,577,952 | null | 177 | 177 |
S = input()
list = []
for i in S:
list.append(i)
if list[2]==list[3] and list[4]==list[5]:
print("Yes")
else:
print("No")
|
import math
def resolve():
import sys
input = sys.stdin.readline
row1 = [int(x) for x in input().rstrip().split(" ")]
h = row1[0]
w = row1[1]
if h == 1 or w == 1:
print(1)
return
ans = (h-(h%2))*(w-(w%2))/2
ans += (h%2)*(w-(w%2))/2
ans += (w%2)*(h-(h%2))/2
ans += (w%2)*(h%2)
print(int(ans))
if __name__ == "__main__":
resolve()
| 0 | null | 46,507,914,494,430 | 184 | 196 |
from collections import deque
def scan(que, ps, way):
Li = 0
pp = ps
while len(que) > 0:
if way==0:
p = que.popleft()
else:
p = que.pop()
if p < ps:
Li += ps - p
else:
break
pp = p
return Li
if __name__=='__main__':
D = input()
que = deque()
p = 0
for c in D:
que.append(p)
if c == "\\" : p += -1
elif c == "/" : p += 1
que.append(p)
Ll = []
Lr = []
ls = que.popleft()
if len(que) > 0: rs = que.pop()
while len(que) > 0:
while len(que) > 0:
if que[0] < ls:
break
else:
ls = que.popleft()
while len(que) > 0:
if que[-1] < rs:
break
else:
rs = que.pop()
if len(que) > 0:
if ls < rs: Ll.append(scan(que,ls,0))
else : Lr.insert(0,scan(que,rs,1))
L = Ll + Lr
if len(L) > 0:
print(sum(L))
print(len(L), *L)
else:
print(0)
print(0)
|
from collections import deque
input = input()
stack = deque()
area = deque()
for i, v in enumerate(input):
if v == "\\":
stack.append(i)
elif v == "/" and stack:
j = stack.pop()
ans = i - j
while area and j<area[-1][0]:
ans += area.pop()[1]
area.append([j, ans])
B = [len(area)]
A = [i[1] for i in area]
print(sum(A))
B.extend(A)
print(*B)
| 1 | 55,503,605,570 | null | 21 | 21 |
s=input()
print(sum(s[i]!=s[-1-i]for i in range(len(s)//2)))
|
from collections import deque
n = int(input())
queue = deque([[1],[2],[3],[4],[5],[6],[7],[8],[9]]) # 初期化_ここでは正の一桁整数として'1'～'9'を設置
ptns = [] # パターン候補の器_初期化
while queue: # queueが空になるまでループ
tmp = queue.popleft() # パターンの候補を popleft
if len(ptns) < n: # ptnsの要素数が'n'個未満ならば append
ptns.append(tmp)
else:
break
# 以下、tmpに各々tmp[-1]-1、tmp[-1]、tmp[-1]+1をappendするための条件
if tmp[-1] != 0:
queue.append(tmp + [tmp[-1] -1])
queue.append(tmp + [tmp[-1]])
if tmp[-1] != 9:
queue.append(tmp + [tmp[-1] +1])
# リスト = map(str, リスト) ← intのリストからstrのmapオブジェクトへ変換
print(''.join(map(str, ptns[-1])))
| 0 | null | 79,692,742,411,930 | 261 | 181 |
s=input()
l=set(s)
if(len(l)==1):
print("No")
else:
print("Yes")
|
def e_yutori():
# 参考: https://drken1215.hatenablog.com/entry/2020/04/05/163400
N, K, C = [int(i) for i in input().split()]
S = input()
def sub_solver(string):
"""string が表す労働日時に対して、労働数が最大になるように働いたとき、
i 日目には何回働いているかのリストを返す"""
n = len(string)
current, last = 0, -C - 1 # 最初に 'o' があっても動作するように設定
ret = [0] * (n + 1)
for i in range(n):
if i - last > C and string[i] == 'o':
current += 1
last = i
ret[i + 1] = current
return ret
left = sub_solver(S)
right = sub_solver(S[::-1])
ans = []
for i in range(N):
if S[i] == 'x':
continue
if left[i] + right[N - i - 1] < K:
ans.append(i + 1)
return '\n'.join(map(str, ans))
print(e_yutori())
| 0 | null | 47,797,997,925,090 | 201 | 182 |
xin = []
while True:
x = raw_input()
if x == '0':
break
xin += [x]
for i in xin:
print sum(map(int , list(i)))
|
while True:
s = sum([int(i) for i in list(input())])
if s:
print(s)
else:
break
| 1 | 1,554,847,521,870 | null | 62 | 62 |
N,K = map(int,input().split())
A = list(map(int,input().split()))
def f(n):
now = 0
for i in range(N):
now += (A[i]-1)//x
if now <= K:
return True
else:
return False
l = 0; r = 10**10
while r-l > 1:
x = (l+r)//2
if f(x):
r = x
else:
l = x
print(r)
|
N = int(input())
L = list(map(int, input().split()))
L.sort(reverse=True)
ans = 0
for i in range(N-2):
for j in range(i+1, N-1):
ok = i
ng = N
while ng - ok > 1:
mid = (ok + ng) // 2
if L[mid] > L[i] - L[j]:
ok = mid
else:
ng = mid
if ok > j:
ans += ok - j
print(ans)
| 0 | null | 89,176,986,071,238 | 99 | 294 |
import sys
def gcd(m, n):
if n != 0:
return gcd(n, m % n)
else:
return m
for line in sys.stdin.readlines():
m, n = map(int, line.split())
g = gcd(m, n)
l = m * n // g # LCM
print(g, l)
|
import sys;print"\n".join("%d %d"%(lambda x:(x[2],x[0]/x[2]*x[1]))((lambda f,x:(x[0],x[1],f(f,x[0],x[1])))(lambda f,a,b:a%b==0 and b or f(f,b,a%b),map(int,s.split(' '))))for s in sys.stdin)
| 1 | 594,062,912 | null | 5 | 5 |
a = raw_input()
while a!='0':
s = 0
for i in range(len(a)):
s += int(a[i])
print s
a = raw_input()
|
x = input()
while 1:
sum_x = 0
if x == "0":
break
for c in x:
sum_x += int(c)
print(sum_x)
x = input()
| 1 | 1,592,513,929,518 | null | 62 | 62 |
X,Y = map(int,input().split())
result = 'No'
for x in range(X+1):
if (2*x + 4*(X-x)) == Y:
result = 'Yes'
break
print(result)
|
X, Y= input().split()
IX = int(X)
IY = int(Y)
C = 2
T = 4
i = 0
while i <= IX:
if ((C*i) + (T*(IX-i))) == IY:
print('Yes')
break
elif i == IX:
print('No')
break
else:
i = i + 1
| 1 | 13,837,564,855,580 | null | 127 | 127 |
data = input().split()
W=int(data[0])
H=int(data[1])
x=int(data[2])
y=int(data[3])
r=int(data[4])
if (0 <= x - r <= W) and (0 <= x + r <= W):
if (0 <= y - r <= H) and (0 <= y + r <= H):
print("Yes")
else:
print("No")
else:
print("No")
|
# -*- coding: utf-8 -*-
list = map(int, raw_input().split())
W = list[0]
H = list[1]
x = list[2]
y = list[3]
r = list[4]
if (x-r) >= 0 and (y-r) >= 0 and (x+r) <= W and (y+r) <= H:
print "Yes"
else:
print "No"
| 1 | 452,515,667,618 | null | 41 | 41 |
while True:
h, w = [int(i) for i in input().split(' ')]
if h ==0 and w ==0:
break
for i in range(h):
row = ''
for j in range(w):
if i == 0 or i == h - 1:
row = row + '#'
else:
if j == 0 or j == w -1:
row = row + '#'
else:
row = row + '.'
print(row)
print('')
|
# コッホ曲線 Koch curve
import math
class Point():
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return str(self.x) + " " + str(self.y)
def Koch(p1, p2, n):
if n == 0:
print(p1)
else:
s = Point(p1.x * 2 / 3 + p2.x * 1 / 3, p1.y * 2 / 3 + p2.y * 1 / 3)
u = Point(p1.x / 2 + p2.x / 2 + p1.y * r3 / 6 - p2.y * r3 / 6, p1.y / 2 + p2.y / 2 + p2.x * r3 / 6 - p1.x * r3 / 6)
t = Point(p1.x * 1 / 3 + p2.x * 2 / 3, p1.y * 1 / 3 + p2.y * 2 / 3)
Koch(p1, s, n - 1)
Koch(s, u, n - 1)
Koch(u, t, n - 1)
Koch(t, p2, n - 1)
r3 = math.sqrt(3)
start = Point(0, 0)
goal = Point(100, 0)
n = int(input())
Koch(start, goal, n)
print(goal)
| 0 | null | 484,465,474,348 | 50 | 27 |
#!/usr/bin/env python3
import sys
DEBUG = False
class SegmentTree:
# Use 1-based index internally
def __init__(self, n, merge_func, fillval=sys.maxsize):
self.n = 1
while self.n < n:
self.n *= 2
self.nodes = [fillval] * (self.n * 2 - 1 + 1) # +1 for 1-based index
self.merge_func = merge_func
self.fillval = fillval
def update(self, idx, val):
idx += 1 # for 1-based index
nodes = self.nodes
mergef = self.merge_func
idx += self.n - 1
nodes[idx] = val
while idx > 1: # > 1 for 1-based index
idx >>= 1 # parent(idx) = idx >> 1 for 1-based index segment tree
nodes[idx] = mergef(nodes[idx << 1], nodes[(idx << 1) + 1]) # child(idx) = idx << 1 and idx << 1 + 1
def query(self, l, r):
l += 1; r += 1 # for 1-based index
l += self.n - 1
r += self.n - 1
acc = self.fillval
while l < r:
if l & 1:
acc = self.merge_func(acc, self.nodes[l])
l += 1
if r & 1:
acc = self.merge_func(acc, self.nodes[r - 1])
r -= 1
l >>= 1
r >>= 1
return acc
def read(t = str):
return t(sys.stdin.readline().rstrip())
def read_list(t = str, sep = " "):
return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]
def dprint(*args, **kwargs):
if DEBUG:
print(*args, **kwargs)
return
def main():
read()
s = read()
a_ord = ord("a")
bit_offsets = {chr(c_ord): c_ord - a_ord for c_ord in range(ord("a"), ord("z") + 1)}
apps = SegmentTree(len(s), lambda x, y: x | y, 0)
i = 0
for c in s:
apps.update(i, 1 << bit_offsets[c])
i += 1
nr_q = read(int)
for i in range(0, nr_q):
q = read_list()
if q[0] == "1":
_, i, c = q # i_q in the question starts from 1, not 0
apps.update(int(i) - 1, 1 << bit_offsets[c])
else:
_, l, r = q # l_q and r_q in the question start from 1, not 0
print(bin(apps.query(int(l) - 1, int(r) - 1 + 1)).count("1")) # query in the question includes both edges
if __name__ == "__main__":
main()
|
import math
x1, y1, x2, y2 = map(float, input().split())
line = (x2 - x1) ** 2 + (y2 - y1) ** 2
line = math.sqrt(line)
print(line)
| 0 | null | 31,399,328,238,102 | 210 | 29 |
n=int(input())
a=list(map(int,input().split()))
b=[i&1 for i in a[::2]]
print(sum(b))
|
N=int(input())
a=[int(x) for x in input().split()]
count=0
for i in range(len(a)):
if (i+1)%2==1 and a[i]%2==1:
count=count+1
print(count)
| 1 | 7,723,530,593,060 | null | 105 | 105 |
N,K = map(int, input().split())
L = [0]*N
R = [0]*N
DP = [0]*(N+10)
DP[0] = 1
SDP = [0]*(N+10)
SDP[1] = 1
MOD=998244353
for i in range(K):
L[i],R[i] = map(int, input().split())
for i in range(1,N):
for j in range(K):
l = max(0,i-R[j])
r = max(0,i-L[j]+1)
DP[i] += SDP[r] - SDP[l]
SDP[i+1] = (SDP[i] + DP[i])%MOD
print(DP[N-1]%MOD)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 998244353
n, k = map(int, input().split())
s = list()
for i in range(k):
s.append(tuple(map(int, input().split())))
dp = [0] + [0] * n
diff = [0] + [0] * n
dp[1] = 1
for i in range(1, n):
for j, k in s:
if i + j > n:
continue
diff[i + j] += dp[i]
if i + k + 1 > n:
continue
diff[i + k + 1] -= dp[i]
dp[i] = (dp[i - 1] + diff[i]) % MOD
dp[i + 1] = (dp[i] + diff[i + 1]) % MOD
print(dp[n])
| 1 | 2,664,186,604,238 | null | 74 | 74 |
def fib(n):
def iter(a, b, cnt):
if cnt == 0:
return a
return iter(b, a+b, cnt-1)
return iter(1, 1, n)
if __name__ == '__main__':
n = int(input())
print(fib(n))
|
n = int(input())
fib = [1,1]
if n>=2:
for i in range(2,n+1):
fib.append(fib[i-1]+fib[i-2])
print(fib[n])
| 1 | 1,659,265,982 | null | 7 | 7 |
N = int(input())
a = list(map(int, input().split()))
cnt = 0
i = 1
while i <= N:
if a[i-1] % 2 == 1:
cnt += 1
i += 2
print(cnt)
|
_, *a = map(int, open(0).read().split())
print(sum(b%2 for b in a[::2]))
| 1 | 7,854,225,351,012 | null | 105 | 105 |
def Warshall_Floyd(dist,n,restoration=False):
next_point = [[j for j in range(n)] for _ in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
if dist[j][k] > dist[j][i] + dist[i][k]:
next_point[j][k] = next_point[j][i]
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k])
if restoration:
return dist,next_point
else:
return dist
n,m,l = map(int,input().split())
inf = 10**18
dist = [[inf for i in range(n)] for j in range(n)]
for i in range(n):
dist[i][i] = 0
for i in range(m):
a,b,c = map(int,input().split())
a -= 1
b -= 1
if c <= l:
dist[a][b] = c
dist[b][a] = c
dist = Warshall_Floyd(dist,n)
route = [[inf for i in range(n)] for j in range(n)]
for i in range(n):
for j in range(n):
if i == j:
route[i][j] = 0
elif dist[i][j] <= l:
route[i][j] = 1
route = Warshall_Floyd(route,n)
q = int(input())
for i in range(q):
s,t = map(int,input().split())
s -= 1
t -= 1
print(route[s][t]-1 if route[s][t] < inf else -1)
|
hp, attack = map(int, input().split())
print(hp // attack if hp % attack == 0 else hp // attack + 1)
| 0 | null | 125,646,192,313,990 | 295 | 225 |
number = int(input())
ans = 0
i: int
for i in range(1, number + 1):
if i % 3 == 0 or i % 5 == 0:
continue
ans += i
print(ans)
|
n = int(input())
sum = (1 + n) * n // 2
sho_3 = n // 3
sho_5 = n // 5
sho_15 = n // 15
s_3 = (sho_3 * 3 + 3) * sho_3 // 2
s_5 = (sho_5 * 5 + 5) * sho_5 // 2
s_15 = (sho_15 * 15 + 15) * sho_15 // 2
print(sum - s_3 - s_5 + s_15)
| 1 | 35,101,341,613,800 | null | 173 | 173 |
s = input()
t = input()
cnt = 0
for i in range(len(s)):
if s[i]!=t[i]:
cnt+=1
if cnt>0:
print("No")
else:
print("Yes")
|
S = input()
T = input()
if(S == T[0:-1] and len(S) + 1 == len(T)):
print("Yes")
else:
print("No")
| 1 | 21,303,446,515,130 | null | 147 | 147 |
import math
n = int(raw_input())
x = map(int, raw_input().split())
y = map(int, raw_input().split())
for i in range(3):
sum = 0
for j in range(n):
sum += (math.fabs(x[j] - y[j]))**(i+1)
#print("sum = {:}".format(sum))
ans = sum ** (1.0/(i+1))
print("{:.6f}".format(ans))
ans = 0
for i in range(n):
if math.fabs(x[i] - y[i]) > ans:
ans = math.fabs(x[i] - y[i])
print("{:.6f}".format(ans))
|
N,M = map(int, input().split())
S = input()
cnt = 0
for s in S:
if s == "0":
cnt = 0
else:
cnt += 1
if cnt >= M:
print(-1)
exit()
"""
辞書順最小
・より少ない回数でゴール
・同じ回数なら、低い数字ほど左にくる
N歩先がゴール → 出目の合計がNになったらOK
iマス目を踏むとゲームオーバー → 途中で出目の合計がiになるとアウト
ただ、辞書順が厄介
N=4, 00000があったとして、M=3の場合、3->1より1->3の方が辞書順で若い。なので、スタート地点から貪欲に進めるだけ進む、は条件を満たさない。
→ ゴールからスタートに帰る。移動方法は貪欲にする。
"""
ans = []
rS = S[::-1]
l = 0
r = 1
while l < N:
r = l + 1
stoppable = l
while r - l <= M and r <= N:
if rS[r] == "0":
stoppable = r
r += 1
ans.append(stoppable - l)
l = stoppable
print(*ans[::-1])
| 0 | null | 69,636,762,404,480 | 32 | 274 |
import statistics
def main():
n = int(input())
a = [0 for _ in range(n)]
b = [0 for _ in range(n)]
for i in range(n):
a[i], b[i] = map(int, input().split())
amed = statistics.median(a)
bmed = statistics.median(b)
if n % 2:
print(int(bmed - amed + 1))
else:
print(int((bmed - amed) * 2 + 1))
if __name__ == '__main__':
main()
|
from decimal import Decimal
a, b = input().split()
a = Decimal(a)
b = Decimal(b)
print(int(a*b))
| 0 | null | 16,854,282,928,384 | 137 | 135 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.