code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
from sys import stdin
def ip():
return stdin.readline().rstrip()
d,t,s=map(int,ip().split())
if d<=t*s:
print('Yes')
else:
print('No') | d, t, s = map(int, input().split())
print('Yes' if t*s >= d else 'No') | 1 | 3,503,324,356,010 | null | 81 | 81 |
# coding:UTF-8
import sys
def resultSur97(x):
return x % (1000000000 + 7)
if __name__ == '__main__':
# ------ 入力 ------#
# 1行入力
n = int(input()) # 数字
# a = input() # 文字列
# aList = list(map(int, input().split())) # スペース区切り連続数字
# aList = input().split() # スペース区切り連続文字列
# aList = [int(c) for c in input()] # 数字→単数字リスト変換
# 定数行入力
x = n
# aList = [int(input()) for _ in range(x)] # 数字
# aList = [input() for _ in range(x)] # 文字
aList = [list(map(int, input().split())) for _ in range(x)] # スペース区切り連続数字(行列)
# aList = [input().split() for _ in range(x)] # スペース区切り連続文字
# aList = [[int(c) for c in input()] for _ in range(x)] # 数字→単数字リスト変換(行列)
# スペース区切り連続 数字、文字列複合
# aList = []
# for _ in range(x):
# aa, bb = input().split()
# a.append((int(aa), bb))
# ------ 処理 ------#
zmin = aList[0][0] + aList[0][1]
zmax = aList[0][0] + aList[0][1]
wmin = aList[0][0] - aList[0][1]
wmax = aList[0][0] - aList[0][1]
for i in range(len(aList)):
x = aList[i][0]
y = aList[i][1]
z = x + y
w = x - y
if z < zmin:
zmin = z
if z > zmax:
zmax = z
if w < wmin:
wmin = w
if w > wmax:
wmax = w
disMax = max(zmax-zmin, wmax-wmin)
# ------ 出力 ------#
print("{}".format(disMax))
# if flg == 0:
# print("YES")
# else:
# print("NO")
| N = int(input())
S = input()
if N%2==0:
if S[:int(N/2)] == S[int(N/2):]:
print('Yes')
else:
print('No')
else:
print('No') | 0 | null | 75,519,521,600,092 | 80 | 279 |
n, m = map(int, input().split())
c = list(map(int, input().split()))
# dp[i][j] = i 番目までを使用して総和がj になる組み合わせ
INF = 5 * 10 ** 4
dp = [[INF] * (n + 1) for _ in range(m + 1)]
dp[0][0] = 0
for i in range(1, m + 1):
for j in range(n + 1):
if j >= c[i - 1]:
dp[i][j] = min(
dp[i - 1][j], dp[i - 1][j - c[i - 1]] + 1, dp[i][j - c[i - 1]] + 1
)# dp[i - 1][j - c[i - 1]] だと、複数回 コインを使う場合に対応していない
else:
dp[i][j] = dp[i - 1][j]
print(dp[m][n])
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
class Edge:
def __init__(self, to, id):
self.to = to
self.id = id
N = int(input())
graph = {}
ans = [0] * (N-1)
def dfs(v, c=-1, p=-1):
global graph, ans
k = 1
for edge in graph[v]:
nv = edge.to
if nv == p:continue
if k == c:k += 1
ans[edge.id] = k
dfs(nv, k, v)
k += 1
def main():
global N, graph, ans
for i in range(N):
graph[i] = set()
for i in range(N-1):
a, b = map(int, input().split())
graph[a-1].add(Edge(b-1, i))
graph[b-1].add(Edge(a-1, i))
color_count = 0
for i in range(N):
color_count = max(color_count, len(graph[i]))
dfs(0, 0, -1)
print(color_count)
for x in ans:
print(x)
if __name__ == "__main__":
main() | 0 | null | 67,891,544,145,152 | 28 | 272 |
import copy
N = int(input())
bscs = [(int(c[-1]), c) for c in input().split(" ")]
sscs = copy.copy(bscs)
for i in range(N):
j = N - 1
while j > i:
if bscs[j][0] < bscs[j - 1][0]:
tmp = bscs[j]
bscs[j] = bscs[j - 1]
bscs[j - 1] = tmp
j -= 1
print(" ".join([c[1] for c in bscs]))
print("Stable")
for i in range(N):
minj = i
for j in range(i, N):
if sscs[j][0] < sscs[minj][0]:
minj = j
tmp = sscs[i]
sscs[i] = sscs[minj]
sscs[minj] = tmp
print(" ".join([c[1] for c in sscs]))
print("Stable" if bscs == sscs else "Not stable") | def bubbleSort(A):
N = len(A)
for i in range(N):
for j in range(N - 1, i, -1):
if A[j][1] < A[j - 1][1]:
A[j], A[j - 1] = A[j - 1], A[j]
return A
def selectionSort(A):
N = len(A)
for i in range(N):
min_i = i
for j in range(i, N):
if A[j][1] < A[min_i][1]:
min_i = j
if min_i != i:
A[i], A[min_i] = A[min_i], A[i]
return A
def is_stable(A, B):
for i in range(len(B) - 1):
if B[i][1] == B[i + 1][1]:
if A.index(B[i]) > A.index(B[i + 1]):
return False
return True
N = int(input())
A = list(input().split())
B = bubbleSort(A[:])
print(*B)
if is_stable(A, B):
print('Stable')
else:
print('Not stable')
S = selectionSort(A[:])
print(*S)
if is_stable(A, S):
print('Stable')
else:
print('Not stable') | 1 | 24,211,246,528 | null | 16 | 16 |
N = int(input())
A = list(map(int, input().split()))
dp = [0]*N
cum = A[0]
for i in range(N):
if i == 0:
dp[i] = 0
continue
if i == 1:
dp[i] = max(A[0],A[1])
continue
if i%2==0: #奇数の時
cum += A[i]
dp[i] = max(dp[i-1],dp[i-2]+A[i])
if i%2==1: #偶数の時
dp[i] = max(dp[i-2]+A[i],cum)
ans = dp[-1]
print(ans)
#print(*ans, sep='\n') | N = int(input())
A = [0]+list(map(int, input().split(" ")))
dp_list = [{0, 0}, {0: 0, 1: A[1]}, {0: 0, 1: A[1] if A[1] > A[2] else A[2]}]
for i in range(3, N+1):
b = (i-1)//2
f = (i+1)//2
dp_list.append({})
for j in range(b, f+1):
if j in dp_list[i-1]:
dp_list[i][j] = dp_list[i-2][j-1]+A[i] if dp_list[i -
2][j-1]+A[i] > dp_list[i-1][j] else dp_list[i-1][j]
else:
dp_list[i][j] = dp_list[i-2][j-1]+A[i]
print(dp_list[-1][N//2]) | 1 | 37,460,166,604,348 | null | 177 | 177 |
# input
N = int(input())
# 約数
def getDivs(n):
divs = [n]
for i in range(2, n):
if i * i > n:
break
if n % i == 0:
divs.append(i)
if i != n//i:
divs.append(n//i)
return divs
# process
if N == 2:
print(1)
else:
pf1 = getDivs(N)
pf2 = getDivs(N-1)
cnt = len(pf2)
for x in pf1:
n = N
while n%x == 0:
n //= x
n %= x
if n == 1:
cnt += 1
# print(pf1)
# print(pf2)
print(cnt)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from copy import deepcopy
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
n = int(readline())
ans = len(make_divisors(n - 1))
for check in make_divisors(n):
if check == 1:
continue
nn = deepcopy(n)
while nn % check == 0:
nn //= check
if nn % check == 1:
ans += 1
print(ans - 1)
| 1 | 41,238,593,867,580 | null | 183 | 183 |
import math
def print_list(a):
out = ''
for ai in a:
out += str(ai) + ' '
else:
out = out[:-1]
print(out)
def insertion_sort(a, n, g):
cnt = 0
for i in range(g, n):
v = a[i]
j = i - g
while j >= 0 and a[j] > v:
a[j + g] = a[j]
j = j - g
cnt += 1
a[j + g] = v
return cnt
def shell_sort(a, n):
cnt = 0
m = 0
g = []
h = 1
while True:
if h > n:
break
m += 1
g.append(h)
h = 3 * h + 1
g.reverse()
for i in range(m):
cnt += insertion_sort(a, n, g[i])
print(m)
print_list(g)
print(cnt)
for i in a:
print(i)
n = int(input())
a = [0] * n
for i in range(n):
a[i] = int(input())
shell_sort(a, n)
|
def InsertionSort(A, n, g):
cnt = 0
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j -= g
cnt += 1
A[j + g] = v
return cnt
def ShellSort(A, n):
total_cnt = 0
G = [1]
span = 4
while span < len(A):
G.append(span)
span = span * 3 + 1
G.reverse()
m = len(G)
for i in range(m):
total_cnt += InsertionSort(A, n, G[i])
return m, G, total_cnt
n = int(input())
A = []
for i in range(n):
A.append(int(input()))
m, G, cnt = ShellSort(A, n)
print(m)
print(*G)
print(cnt)
for a in A:
print(a) | 1 | 29,855,787,680 | null | 17 | 17 |
N = int(input())
"""
愚直にやると、Kを2～Nの範囲で全部調べて数え上げる。N <= 10**12 なので間に合わない。
たとえば N=100だと、
[2, 3, 4, 9, 10, 11, 33, 99, 100]
が条件を満たす数字になる。
割り算を行わないとき、明らかに N % K = 1 になる
これは、「NをKで割ったら、１あまる」であるから、「N-1をKでわったら割り切れる」ともいえる。
なので、割り算が起こらないものは、N-1の約数。
割り算が起こるやつは、割れるだけ割った後、余りを調べればよい。
"""
def solve(n):
i = 1
ret = set()
while i * i <= n:
if n % i == 0:
ret.add(i)
ret.add(n // i)
i += 1
return ret
div_N_sub_1 = solve(N-1)
div_N = solve(N)
ans = len(div_N_sub_1) - 1
for i in div_N:
if i == 1:
continue
tmp = N
while tmp % i == 0:
tmp //= i
if tmp % i == 1:
ans += 1
print(ans) | 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)
| 1 | 41,392,176,031,732 | null | 183 | 183 |
n = int(input())
s = input()
if n % 2 != 0:
print('No')
exit()
if s[:n//2] == s[n//2:n]:
print('Yes')
else:
print('No')
| N = int(input())
A = str(input())
if (N % 2 == 0):
if (A[:N//2] == A[N//2:]):
print("Yes")
else:
print("No")
else:
print("No")
| 1 | 147,167,916,933,818 | null | 279 | 279 |
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
n = input().rstrip()
k = int(input())
ln = len(n)
# dp[i][j]:左からi桁まで見たとき0でない桁がj個ある場合の数
dp1 = [[0]*(k+1) for _ in range(ln+1)]
dp2 = [[0]*(k+1) for _ in range(ln+1)]
dp2[0][0] = 1
cnt = 0
for i in range(ln):
if n[i] != '0':
if cnt < k:
cnt += 1
dp2[i+1][cnt] = 1
else:
dp2[i+1][cnt] = dp2[i][cnt]
for i in range(ln):
dp1[i+1][0] = 1
for j in range(1, k+1):
dp1[i+1][j] += dp1[i][j] + dp1[i][j-1] * 9
if n[i] != '0':
dp1[i+1][j] += dp2[i][j-1] * (int(n[i])-1)
if j < k:
dp1[i+1][j] += dp2[i][j]
print(dp1[-1][k] + dp2[-1][k])
if __name__ == '__main__':
main() | import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n = int(ipt())
way = [[] for i in range(n+1)]
for i in range(n-1):
a,b = map(int,ipt().split())
way[a].append((b,i))
way[b].append((a,i))
q = queue.Queue()
q.put((1,-1,-1)) #nowplace,pastplace,hen
col = [-1]*(n-1)
while not q.empty():
np,pp,hen = q.get()
nc = 1
for i,wn in way[np]:
if i == pp:
continue
if nc == hen:
nc += 1
col[wn] = nc
q.put((i,np,nc))
nc += 1
print(max(col))
for i in col:
print(i)
return
if __name__ == '__main__':
main()
| 0 | null | 106,279,492,141,536 | 224 | 272 |
def sel_sort(A, N):
''' 選択ソート '''
count = 0
for n in range(N):
minm = n
for m in range(n, N):
if A[m] < A[minm]:
minm = m
if minm != n:
A[n], A[minm] = A[minm], A[n]
count += 1
return (A, count)
if __name__ == '__main__':
N = int(input())
A = list(map(int, input().split(' ')))
ans = sel_sort(A, N)
print(' '.join([str(x) for x in ans[0]]))
print(ans[1])
| import math
k=int(input())
ans=0
for a in range(1,k+1):
for b in range(1,k+1):
tmp=math.gcd(a,b)
for c in range(1,k+1):
ans+=math.gcd(tmp,c)
print(ans) | 0 | null | 17,843,128,588,682 | 15 | 174 |
def main():
S = str(input())
s = ''
for i in range(len(S)):
s = s + 'x'
print(s)
main() | a = len(input())
print("x"*a) | 1 | 73,344,279,931,128 | null | 221 | 221 |
import math
import copy
def prime_factorize(n):
a = [n]
for i in range(2, math.floor(n ** 0.5) + 1):
if n % i == 0:
a.append(i)
if n // i != i:
a.append(n // i)
return a
N = int(input())
prime_n = prime_factorize(N)
prime_n_1 = prime_factorize(N - 1)
ans = 0
for i in prime_n:
n = copy.deepcopy(N)
while (n % i) == 0:
n = n // i
if (n % i) == 1:
ans += 1
ans += len(prime_n_1)
if N > 2:
print(ans)
else:
print(1) | #!/usr/bin/env python3
import sys
import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter # itemgetter(1), itemgetter('key')
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
n = ii()
# naive, O(nlgn)
# cnt = 0
# for k in range(2, n + 1):
# tmp = n
# if tmp % k == 1:
# cnt += 1
# elif tmp % k == 0:
# while tmp >= k and tmp % k == 0:
# tmp //= k
# if tmp % k == 1:
# cnt += 1
# print(cnt)
class Eratos:
def __init__(self, num):
assert(num >= 1)
self.table_max = num
# self.table[i] は i が素数かどうかを示す (bool)
self.table = [False if i == 0 or i == 1 else True for i in range(num+1)]
for i in range(2, int(math.sqrt(num)) + 1):
if self.table[i]:
for j in range(i ** 2, num + 1, i): # i**2 からスタートすることで定数倍高速化できる
self.table[j] = False
# self.table_max 以下の素数を列挙したリスト
self.prime_numbers = [2] if self.table_max >= 2 else []
for i in range(3, self.table_max + 1, 2):
if self.table[i]:
self.prime_numbers.append(i)
def is_prime(self, num):
"""
>>> e = Eratos(100)
>>> [i for i in range(1, 101) if e.is_prime(i)]
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
"""
assert(num >= 1)
if num > self.table_max:
raise ValueError('Eratos.is_prime(): exceed table_max({}). got {}'.format(self.table_max, num))
return self.table[num]
def prime_factorize(self, num):
"""
>>> e = Eratos(10000)
>>> e.prime_factorize(6552)
{2: 3, 3: 2, 7: 1, 13: 1}
"""
assert(num >= 1)
if int(math.sqrt(num)) > self.table_max:
raise ValueError('Eratos.prime_factorize(): exceed prime table size. got {}'.format(num))
factorized_dict = dict() # 素因数分解の結果を記録する辞書
candidate_prime_numbers = [i for i in range(2, int(math.sqrt(num)) + 1) if self.is_prime(i)]
# n について、√n 以下の素数で割り続けると最後には 1 or 素数となる
# 背理法を考えれば自明 (残された数が √n より上の素数の積であると仮定。これは自明に n を超えるため矛盾)
for p in candidate_prime_numbers:
# これ以上調査は無意味
if num == 1:
break
while num % p == 0:
num //= p
try:
factorized_dict[p]
except KeyError:
factorized_dict[p] = 0
finally:
factorized_dict[p] += 1
if num != 1:
factorized_dict[num] = 1
return factorized_dict
eratos = Eratos(int(math.sqrt(n)))
d_1 = eratos.prime_factorize(n - 1)
# n = k + 1, 2k + 1, 3k + 1, ...
cnt = 0
tmp = 1
for _, v in d_1.items():
tmp *= (v + 1)
tmp -= 1
cnt += tmp
d_2 = eratos.prime_factorize(n)
# 全約数 x (除: 1) について (n // x) ≡ 1 (mod x) なら cnt += 1とすればいいのでは
# 約数の個数は高々 2√n 個なので間に合いそう？
L = [range(v + 1) for _, v in d_2.items()]
power_list = list(product(*L))
prime_list = list(d_2.keys())
for elm in power_list:
# elm は具体的な各素数の指数を指定したリストである
div = 1
for i in range(len(prime_list)):
div *= pow(prime_list[i], elm[i])
# print(f"div: {div}")
if div != 1:
assert(n % div == 0)
copy_n = n
while copy_n % div == 0:
copy_n //= div
if copy_n % div == 1:
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| 1 | 41,327,109,563,274 | null | 183 | 183 |
i = 1
n = int(input())
while i <= n:
x = i
if x % 3 == 0:
print('' , i , end = '')
else:
while x:
if x % 10 == 3:
print('' , i , end = '')
break
x = int(x / 10)
i = i + 1
print('') | import itertools as itr
def call(n):
def devided_3(x):
return x % 3 == 0
def has_3(x):
return '3' in str(x)
data = filter(lambda x: devided_3(x) or has_3(x), range(1, n+1))
[print(' {0}'.format(i), end='') for i in data]
print()
if __name__ == '__main__':
n = int(input())
call(n) | 1 | 921,746,274,296 | null | 52 | 52 |
n = int(input())
l = list(sorted(map(int, input().split())))
x = 0
if n >= 3:
for k in range(n - 2):
for j in range(k + 1):
for i in range(j + 1):
if l[i] < l[j + 1] < l[k + 2] and l[i] + l[j + 1] > l[k + 2]:
x += 1
print(x) | n = int(input())
arr = list(map(int, input().split()))
answer = 0
for idx1 in range(0, len(arr) - 2):
for idx2 in range(idx1+1, len(arr) - 1):
for idx3 in range(idx2+1, len(arr)):
if arr[idx1] == arr[idx2] or arr[idx1] == arr[idx3] or arr[idx2] == arr[idx3]:
continue
if arr[idx1] + arr[idx2] > arr[idx3] and arr[idx1] + arr[idx3] > arr[idx2] and arr[idx2] + arr[idx3] > arr[idx1]:
answer += 1
print(answer) | 1 | 5,077,668,984,532 | null | 91 | 91 |
n, m, l = map(int, input().split())
A = []
B = []
C = [[] for i in range(n)]
for i in range(n):
tmp_row = list(map(int, input().split()))
A.append(tmp_row)
for i in range(m):
tmp_row = list(map(int, input().split()))
B.append(tmp_row)
for i in range(n):
for bj in zip(*B):
c = sum(aik * bjk for aik, bjk in zip(A[i], bj))
C[i].append(c)
for i in C:
print(*i) | import re
s = input()
if re.sub(r'hi', '', s) == '':
print('Yes')
else:
print('No')
| 0 | null | 27,418,050,729,920 | 60 | 199 |
# -*- coding: utf-8 -*-
def main():
A, B, C, K = map(int, input().split())
ans = 0
if K <= A:
ans = K
else:
if K <= A + B:
ans = A
else:
ans = A + (-1 * (K - A - B))
print(ans)
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 | 21,919,298,465,150 | null | 148 | 148 |
a, b, c, d = map(int, input().split())
for i in range(max(a, b, c, d)):
if b >= c:
print('Yes')
exit()
else:
c -= b
if a <= d:
print('No')
exit()
else:
a -= d
continue | def main():
a, b, c, d = map(int, input().split())
if c % b == 0:
e = c // b
else:
e = c // b + 1
if a % d == 0:
f = a // d
else:
f = a // d + 1
if e > f:
ans = "No"
else:
ans = "Yes"
print(ans)
if __name__ == "__main__":
main()
| 1 | 29,701,825,251,040 | null | 164 | 164 |
a = 1
b = 1
op = ''
i = 0
while op!='?':
a,op,b = [i for i in input().split()]
a = int(a)
b = int(b)
if op!='?':
if op=='+':
print(a+b)
elif op=='-':
print(a-b)
elif op=='*':
print(a*b)
elif op=='/':
print(a//b) | while 1 :
a, op, b= raw_input().split()
c = int(a)
d = int(b)
if op == '?': break
elif op == '+': print c + d
elif op == '-': print c - d
elif op == '*': print c * d
elif op == '/': print c / d | 1 | 678,169,951,042 | null | 47 | 47 |
m1, d1 = map(int, input().split())
m2, d2 = map(int, input().split())
print(1 if m2 == m1 % 12 + 1 and d2 == 1 else 0) | m1,d1 = map(int,input().split())
m2,d2 = map(int,input().split())
print(1 if m1!=m2 else 0)
| 1 | 124,024,309,058,482 | null | 264 | 264 |
L=int(input())
print(pow(L/3,3)) | n = int(input())
a = n/3
print(a**3) | 1 | 47,013,508,114,880 | null | 191 | 191 |
M1,D1 = map(int,input().split())
M2,D2 = map(int,input().split())
if M1<M2:print(1)
else:print(0) | a,b=map(int,input().split())
c,d=map(int,input().split())
print(c-a) | 1 | 123,873,967,105,122 | null | 264 | 264 |
while 1:
e=map(int,raw_input().split())
m=e[0]
f=e[1]
r=e[2]
if m==f==r==-1:
break
elif m==-1 or f==-1 or m+f<30:
print "F"
elif m+f<50 and r<50:
print "D"
elif m+f<65:
print "C"
elif m+f<80:
print "B"
else:
print "A" | lis = [ ]
for i in range ( 10 ):
lis.append ( int ( input ( ) ) )
lis.sort ( )
for i in range ( 3 ):
print ( lis.pop ( ) ) | 0 | null | 601,864,466,152 | 57 | 2 |
a, b ,c = [int(i) for i in input().split()]
total = 0
for d in range(a, b + 1):
if c % d == 0:
total += 1
print(total) | A = int(input())
B = int(input())
print(6//(A*B)) | 0 | null | 55,549,586,368,704 | 44 | 254 |
n = int(input())
tp = hp = 0
while n:
t, h = input().split()
if t > h:
tp += 3
elif t < h:
hp += 3
else:
tp += 1
hp += 1
n -= 1
print(tp, hp) | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
N, M = map(int, readline().split())
AC = [False] * N
cnt = [0] * N
for _ in range(M):
p, s = input().split()
p = int(p)
p -= 1
if s == "AC":
AC[p] = True
else:
if not AC[p]:
cnt[p] += 1
ans_a = 0
ans_p = 0
for i in range(N):
if AC[i]:
ans_a += 1
ans_p += cnt[i]
print(ans_a, ans_p)
if __name__ == '__main__':
main()
| 0 | null | 47,517,547,037,632 | 67 | 240 |
x = input()
print "%d" % (x ** 3) | import math
N = int(input())
N_ = int(math.sqrt(N)) + 1
min_distance = N - 1
for i in range(1, N_):
p, r = divmod(N, i)
if r == 0:
if 1 <= p <= N:
distance = (i-1) + (p-1)
min_distance = min(min_distance, distance)
else:
continue
print(min_distance)
| 0 | null | 81,312,096,228,090 | 35 | 288 |
a, b = map(int, input().split())
if a <= 9 and b <= 9:
print(a * b)
else:
print("-1") | import sys
def solve():
input = sys.stdin.readline
R, C, K = map(int, input().split())
item = [[0 for _ in range(C)] for r in range(R)]
for _ in range(K):
r, c, k = map(int, input().split())
item[r-1][c-1] = k
DP = [[[-1 for _ in range(C)] for r in range(R)] for i in range(4)]
DP[0][0][0] = 0
for r in range(R):
for c in range(C):
for i in range(4):
if DP[i][r][c] > -1:
if r + 1 < R:
DP[0][r+1][c] = max(DP[0][r+1][c], DP[i][r][c])
if c + 1 < C:
DP[i][r][c+1] = max(DP[i][r][c+1], DP[i][r][c])
if i < 3 and item[r][c] > 0:
if r + 1 < R: DP[0][r+1][c] = max(DP[0][r+1][c], DP[i][r][c] + item[r][c])
if c + 1 < C: DP[i+1][r][c+1] = max(DP[i+1][r][c+1], DP[i][r][c] + item[r][c])
ans = DP[3][R-1][C-1]
for i in range(3): ans = max(ans, DP[i][R-1][C-1] + item[R-1][C-1])
print(ans)
return 0
if __name__ == "__main__":
solve()
| 0 | null | 81,605,878,645,280 | 286 | 94 |
print('win' if sum(map(int, input().split())) < 22 else 'bust') | v = sum(map(int,list(input().split())))
if(v > 21):
print('bust')
else:
print('win')
| 1 | 118,912,075,271,040 | null | 260 | 260 |
S=input()
if S[-1]=='s':
Ans=S+'es'
else:
Ans=S+'s'
print(Ans) | S = input()
if S[-1] == 's':
print(S,'es',sep='')
else:
print(S,'s',sep='')
| 1 | 2,348,817,090,070 | null | 71 | 71 |
n = int(input())
xy = [map(int, input().split()) for _ in range(n)]
x, y = [list(i) for i in zip(*xy)]
count = 0
buf = 0
for xi, yi in zip(x, y):
if xi == yi:
buf += 1
else:
if buf > count:
count = buf
buf = 0
if buf > count:
count = buf
if count >= 3:
print('Yes')
else:
print('No') | lst = list(input())
tmp = 0
ans = 0
for i in lst:
if i == "R":
tmp = tmp + 1
ans = max(ans, tmp)
else:
tmp = 0
print(ans) | 0 | null | 3,677,605,811,780 | 72 | 90 |
a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())
if v <= w:
print("NO")
else:
dis = abs(b-a)
sp = abs(v-w)
if 0 < dis/sp <= t:
print("YES")
else:
print("NO")
| N=int(input())
A=list(map(int,input().split()))
t=[0]*N
for idx,i in enumerate(A):
t[i-1]=idx+1
print(*t) | 0 | null | 97,645,464,389,372 | 131 | 299 |
N = int(input())
S = str(input())
print(S.count("ABC")) | a = int(input())
b = input()
print(b.count("ABC")) | 1 | 99,501,676,363,460 | null | 245 | 245 |
from collections import deque
def matrix(n):
for _ in range(n):
adj = list(map(int, input().split()))
i = adj[0]
v = adj[2:]
for j in v:
mat[i - 1][j - 1] = 1
def bfs(v):
d[v] = 1
dist[v] = 0
dq.append(v)
while dq:
v = dq.popleft()
for n, i in enumerate(mat[v]):
if i == 1 and not d[n]:
d[n] = 1
dist[n] = dist[v] + 1
dq.append(n)
n = int(input())
mat = [[0] * n for _ in range(n)]
d, dist = [0] * n, [-1] * n
dq = deque()
matrix(n)
bfs(0)
for i, v in enumerate(dist):
print(i + 1, v) | import math
N, M = map(int, input().split())
if N%2 == 1:
a = 1
b = N
for i in range(M):
print(a,b)
a += 1
b -= 1
else:
m = N//2 - 1
a = N//4
b = a + 1
c = N//2 + N//4
d = c + 2
for i in range(M):
if i%2 == 0:
print(a,b)
a -= 1
b += 1
else:
print(c,d)
c -= 1
d += 1 | 0 | null | 14,446,612,906,866 | 9 | 162 |
n,t = map(int,input().split())
a = [list(map(int,input().split())) for i in range(n)]
a.sort()
DP = [[0 for i in range(t+3001)] for j in range(n+1)]
for i in range(1,n+1):
for j in range(1,t+3001):
if j-a[i-1][0] >= 0:
DP[i][j] = max(DP[i-1][j],DP[i-1][j-a[i-1][0]]+a[i-1][1])
else:
DP[i][j] = DP[i-1][j]
ans = 0
for i in range(n):
ans = max(ans,DP[i][t-1]+a[i][1])
print(ans) | s = input()
day = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
num = [7, 6, 5, 4, 3, 2, 1]
dic = dict(zip(day, num))
print(dic[s])
| 0 | null | 142,548,270,235,840 | 282 | 270 |
n,m=map(int,input().split())
s=input()[::-1]
if "1"*m in s:
print(-1)
exit(0)
ans=[]
cur=0
while cur<len(s):
for j in range(m,0,-1):
if cur+j>=len(s):
continue
if s[cur+j]=="0":
cur=cur+j
ans.append(j)
break
if cur==len(s)-1:
break
ans=ans[::-1]
print(*ans) | # -*- coding: utf-8 -*-
# 08-Computation-Simple_Calculator.py
# ?¨???????
# ???????????´??° a, b ??¨?????????????????? op ?????????????????§???a op b ????¨??????????????????°?????????????????????????????????
# ????????????????????? op ??????"+"(???)???"-"(???)???"*"(???)???"/"(???)???????????¨?????????????????§????????????????????´??????????°???°?????\??????????????¨????????????????¨????????????¨????????????
# Input
# ??\???????????°????????????????????????????§???????????????????????????????????????????????????¢????????\????????¨????????§??????
# a op b
# op ??? '?' ?????¨??? ??\?????????????????????????????????????????±???????????????????????£????????????????????????
# Output
# ?????????????????????????????????????¨??????????????????????????????????????????????
# Constraints
# 0 ??? a, b ??? 20000
# 0 ?????????????????????????????????????????¨?????????????????????
# Sample Input
# 1 + 2
# 56 - 18
# 13 * 2
# 100 / 10
# 27 + 81
# 0 ? 0
# Sample Output
# 3
# 38
# 26
# 10
# 108
import sys
output = []
while 1:
a,op,b = input().split()
a= int(a)
b= int(b)
if op=="+":
output.append(a+b)
elif op =="-":
output.append(a-b)
elif op =="*":
output.append(a*b)
elif op =="/":
output.append( int(a/b) )
elif op =="?":
break;
else:
sys.exit()
for i in range( len(output)):
print(output[i]) | 0 | null | 69,771,228,898,212 | 274 | 47 |
from itertools import permutations
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
M = []
for i in range(N):
M.append(i+1)
p, q = 0, 0
for i, n in enumerate(list(permutations(M))):
if n == P:
p = i
if n == Q:
q = i
print(abs(p - q)) | n = int(input())
n = n % 10
if n == 3:
print('bon')
elif n == 0 or n == 1 or n == 6 or n == 8:
print('pon')
else:
print('hon')
| 0 | null | 59,602,621,028,380 | 246 | 142 |
while True:
t = input()
if t.find("?") > 0:
break
print(int(eval(t))) | n=int(input())
import math
move_min=1+n-2
for i in range(2,int(math.sqrt(n)+1)):
if n%i==0:
move_min=min(move_min,i+n//i-2)
print(move_min) | 0 | null | 81,230,830,915,432 | 47 | 288 |
N, M = map(int, input().split())
ans = [-1 for _ in range(N)]
if N ==1:
ans = 0
clis = []
for _ in range(M):
s, c = map(int, input().split())
clis.append(c)
if len(set(clis)) == 1:
print(clis[0])
exit()
elif len(set(clis)) == 0:
print(0)
exit()
else:
print(-1)
exit()
else:
for _ in range(M):
s, c = map(int, input().split())
if s == 1 and c == 0:
print(-1)
exit()
if ans[s-1] == c or ans[s-1] == -1:
ans[s-1] = c
else:
print(-1)
exit()
ans[0] = max(1, ans[0])
answer = ''
for k in range(N):
if ans[k] == -1:
answer += '0'
else:
answer += str(ans[k])
print(answer)
| #coding:utf-8
#????????¢?????????
def draw_square(h, w):
for i in range(h):
a = ""
for j in range(w):
a += "#"
print a
while 1:
HW = raw_input().split()
H = int(HW[0])
W = int(HW[1])
if H == 0 and W == 0:
break
draw_square(H, W)
print "" | 0 | null | 30,959,277,916,754 | 208 | 49 |
import sys
sys.setrecursionlimit(1000000)
def II(): return int(input())
def MI(): return map(int, input().split())
N=II()
edge=[[] for i in range(N)]
a=[0]*N
b=[0]*N
for i in range(N-1):
a[i],b[i]=MI()
a[i]-=1
b[i]-=1
edge[a[i]].append(b[i])
edge[b[i]].append(a[i])
k=0
color_dict={}
def dfs(to,fm=-1,ban_color=-1):
global k
color=1
for nxt in edge[to]:
if nxt==fm:
continue
if color==ban_color:
color+=1
color_dict[(to,nxt)]=color
dfs(nxt,to,color)
color+=1
k=max(k,color-1)
dfs(0)
print(k)
for i in range(N-1):
print(color_dict[(a[i],b[i])]) | from collections import deque
N=int(input())
G=[[] for _ in [0]*(N+1)]
for i in range(1,N):
a,b=map(int,input().split())
G[a].append((b,i))
G[b].append((a,i))
root,res=0,0
for i in range(1,N+1):
tmp=len(G[i])
if tmp>res:
res=tmp
root=i
q=deque()
q.append((root,0))
color=[0]*N
D=[N+10]*(N+1)
D[root]=0
while q:
p,c=q.popleft()
nc=1
while G[p]:
np,ni=G[p].pop()
if D[np]>D[p]:
D[np]=D[p]+1
if nc==c:
nc+=1
color[ni]=nc
q.append((np,nc))
nc+=1
print(res,*color[1:],sep='\n') | 1 | 136,050,342,930,212 | null | 272 | 272 |
for i in range(1, 10):
for j in range(1, 10):
fmt = format("{0}x{1}={2}")
g = fmt.format(i, j, i*j)
print(g) | for i in range(1, 10):
for ii in range(1, 10):
print('{}x{}={}'.format(i, ii, i*ii)) | 1 | 404,740 | null | 1 | 1 |
from collections import defaultdict
def main():
n, x, y = map(int, input().split())
ans = defaultdict(int)
for i in range(1, n + 1):
for j in range(i + 1, n + 1):
l = min(abs(i - j), abs(i - x) + abs(y - j) + 1, abs(i - y) + abs(x - j) + 1)
ans[l] += 1
[print(ans[i]) for i in range(1, n)]
if __name__ == '__main__':
main()
| A=list(map(int,input().split()))
print(A[0]*A[1]) | 0 | null | 29,924,686,491,350 | 187 | 133 |
n = int(input())
rate = 600
rank = 8
while True:
if n < rate:
print(rank)
break
rate += 200
rank -= 1
| import sys
import re
import math
import collections
import decimal
import bisect
import itertools
import copy
# import heapq
# from collections import deque
# import decimal
# sys.setrecursionlimit(100001)
INF = sys.maxsize
# 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():
s = list(input())
k = ni()
if len(set(s))==1:
print((len(s)*k)//2)
exit(0)
def changer(sss):
ts = sss.copy()
cnt = 0
for i in range(1, len(ts)):
if ts[i] == ts[i - 1]:
ts[i] = "@"
cnt += 1
return cnt
print(changer(s) + (k - 1) * (changer(s + s) - changer(s)))
if __name__ == '__main__':
main()
| 0 | null | 91,074,891,328,380 | 100 | 296 |
N = int(input())
M = [""] * N
T = [0] * N
for i in range(N):
m, t = input().split(" ")
M[i] = m
T[i] = int(t)
X = input()
id = M.index(X)
s = sum(T[id+1:])
print(s) | import sys
import re
import queue
import collections
import math
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []
def gcd_list(numbers):
return reduce(gcd, numbers)
def main():
N = i_input()
A = i_list()
d = dict()
max_A = max(A)
count_list = []
MAXN = 10**6+10
sieve = [i for i in range(MAXN+1)]
p = 2
while p*p <= MAXN:
if sieve[p] == p:
for q in range(2*p,MAXN+1,p):
if sieve[q] == q:
sieve[q] = p
p += 1
for i in range(0,max(A)):
count_list.append(0)
for a in A:
tmp = set()
while a > 1:
tmp.add(sieve[a])
a //= sieve[a]
for p in tmp:
count_list[p-1] += 1
if (max(count_list)<=1):
print("pairwise coprime")
elif(gcd_list(A)==1):
print("setwise coprime")
else:
print("not coprime")
return
if __name__ == '__main__':
main() | 0 | null | 50,611,468,338,690 | 243 | 85 |
k=int(input())
if k==1:
print('ACL')
elif k==2:
print('ACLACL')
elif k==3:
print('ACLACLACL')
elif k==4:
print('ACLACLACLACL')
elif k==5:
print('ACLACLACLACLACL') | a = int(input())
if a == 1:
print("ACL")
elif a == 2:
print("ACLACL")
elif a == 3:
print("ACLACLACL")
elif a == 4:
print("ACLACLACLACL")
else:
print("ACLACLACLACLACL") | 1 | 2,204,949,605,892 | null | 69 | 69 |
x, y = map(int,input().split())
print((max(4-x, 0) + max(4-y, 0) + 4*max(3-x-y, 0)) * 100000) | x,y=map(int,input().split())
a=[300000,200000,100000]
b=[0]*300
a=a+b
add=0
if x*y==1:
add=400000
print(a[x-1]+a[y-1]+add)
| 1 | 140,629,229,745,002 | null | 275 | 275 |
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
N=I()
P=LI()
Q=LI()
import itertools
cnt=0
p=0
q=0
for ite in itertools.permutations(range(1,N+1)):
if P==list(ite):
p=cnt
if Q==list(ite):
q=cnt
cnt+=1
print(abs(p-q))
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, X, M = map(int, readline().split())
n = 1
P = 1
while n < N:
n *= 2
P += 1
pos = [[0] * M for _ in range(P)]
value = [[0] * M for _ in range(P)]
for r in range(M):
pos[0][r] = r * r % M
value[0][r] = r
for p in range(P - 1):
for r in range(M):
pos[p + 1][r] = pos[p][pos[p][r]]
value[p + 1][r] = value[p][r] + value[p][pos[p][r]]
ans = 0
cur = X % M
for p in range(P):
if N & (1 << p):
ans += value[p][cur]
cur = pos[p][cur]
print(ans)
return
if __name__ == '__main__':
main()
| 0 | null | 51,836,201,515,410 | 246 | 75 |
import sys
h, w = map(int, input().split())
s = [list(x.rstrip()) for x in sys.stdin.readlines()]
dp = [[10**6]*w for _ in range(h)]
if s[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
for j in range(h):
for i in range(w):
for k in range(2):
nx, ny = i + (k + 1)%2, j + k%2
if nx >= w or ny >= h:
continue
else:
add = 0
if s[ny][nx] == "#" and s[j][i] == ".":
add = 1
dp[ny][nx] = min(dp[ny][nx], dp[j][i] + add)
print(dp[h-1][w-1]) | h,w=map(int,input().split())
grid=[[1 if s=='#' else 0 for s in list(input())] for i in range(h)]
#print(grid)
maxi=10**5
from collections import deque
visited=[[maxi]*w for _ in range(h)]
def bfs(s):
q=deque()
q.append(s)
visited[s[0]][s[1]]=grid[s[0]][s[1]]
for r in range(h):
for c in range(w):
if r>=1:
visited[r][c]=min(visited[r][c],visited[r-1][c]+grid[r][c])
if grid[r-1][c]==1:
visited[r][c]=min(visited[r][c],visited[r-1][c])
if c>=1:
visited[r][c]=min(visited[r][c],visited[r][c-1]+grid[r][c])
if grid[r][c-1]==1:
visited[r][c]=min(visited[r][c],visited[r][c-1])
bfs([0,0])
print(visited[-1][-1]) | 1 | 49,290,353,568,178 | null | 194 | 194 |
import sys
input = sys.stdin.readline
def main():
N = int(input())
S = set([input().rstrip() for _ in range(N)])
print(len(S))
if __name__ == '__main__':
main()
| n = int(input())
print(len(set([input() for i in range(n)]))) | 1 | 30,329,233,162,592 | null | 165 | 165 |
import math
x = int(input())
x_pow = round(math.pow(x, 1/5))
ok = 0
for a in range(-300,300):
for b in range(-300,300):
if a**5 - b**5 == x:
print(a,b)
ok = 1
exit() | import sys
# import time
input = lambda: sys.stdin.readline().rstrip()
r, c, k = map(int, input().split())
# dp = [[[0] * 3 for _ in range(c + 5)] for _ in range(r + 5)]
pt = [[0 for _ in range(c + 5)] for _ in range(r + 5)]
for i in range(k):
r1, c1, v = map(int, input().split())
# dp[r1][c1][0] = v
pt[r1][c1] = v
# start = time.time()
a = 0
def solve():
memo = [[0] * 4 for _ in range(c + 1)]
prev = [[0] * 4 for _ in range(c + 1)]
for i in range(1, r + 1):
memo, prev = prev, memo
for j in range(1, c + 1):
V = pt[i][j]
memo[j][0] = max(prev[j][3], memo[j - 1][0])
memo[j][1] = max(memo[j][0] + V, memo[j - 1][1])
memo[j][2] = max(memo[j][1], memo[j - 1][1] + V, memo[j - 1][2])
memo[j][3] = max(memo[j][2], memo[j - 1][2] + V, memo[j - 1][3])
# dp[i][j][0] = max(dp[i - 1][j][2] + V, dp[i][j - 1][0])
# dp[i][j][1] = max(dp[i][j - 1][0] + V, dp[i][j - 1][1],
# dp[i][j][0])
# dp[i][j][2] = max(dp[i][j - 1][1] + V, dp[i][j - 1][2],
# dp[i][j][1])
# process_time = time.time() - start
# print(process_time)
# print(dp[r][c][2])
return memo[-1][3]
if __name__ == '__main__':
print(solve())
| 0 | null | 15,527,370,454,352 | 156 | 94 |
n = int(input())
ls = []
rs = []
for _ in range(n):
x, y = map(int, input().split())
ls.append(x)
rs.append(y)
ls = sorted(ls)
rs = sorted(rs)
if n % 2 == 1:
print(rs[len(rs)//2] - ls[len(ls)//2] + 1)
else:
a = (rs[len(rs)//2-1] * 10 + rs[len(rs)//2] * 10) // 2
b = (ls[len(ls)//2-1] * 10 + ls[len(ls)//2] * 10) // 2
print((a - b) // 5 + 1) | import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp
INF = inf
MOD = 1000000007
n = int(input())
A = [[int(i) for i in input().split()]for j in range(n)] # nは行数
tmp = 0
res = 0
x = np.median(np.array(A), axis=0)
if n % 2 == 0:
res = int((x[1] - x[0]) * 2 + 1)
else:
res = int(x[1] - x[0] + 1)
print(res)
| 1 | 17,335,406,261,642 | null | 137 | 137 |
N,K = map(int,input().split())
A = list(map(int,input().split()))
for i in range(N-K):
if A[i]<A[i+K]:
print("Yes")
elif A[i]>=A[i+K]:
print("No") | import sys
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
a = a1 * t1 + a2 * t2
b = b1 * t1 + b2 * t2
ha = a1 * t1
hb = b1 * t1
if a == b or ha == hb:
print ("infinity")
sys.exit(0)
if a > b:
a, b = b, a
ha, hb = hb, ha
gap = b - a
hgap = ha - hb
if hgap < 0:
print (0)
sys.exit(0)
ans = 2 * (hgap // gap) + (1 if hgap % gap > 0 else 0)
print (ans)
| 0 | null | 69,078,995,544,832 | 102 | 269 |
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) | word=input().lower()
how_in=0
while True:
letters=input()
if letters=='END_OF_TEXT':
break
for i in letters.lower().split():
if i==word:
how_in+=1
print(how_in) | 0 | null | 31,869,617,887,170 | 209 | 65 |
INF = 10**10
def merge(ary, left, mid, right):
lry = ary[left:mid]
rry = ary[mid:right]
lry.append(INF)
rry.append(INF)
i = 0
j = 0
for k in range(left, right):
if lry[i] <= rry[j]:
ary[k] = lry[i]
i += 1
else:
ary[k] = rry[j]
j += 1
return right - left
def merge_sort(ary, left, right):
cnt = 0
if left + 1 < right:
mid = (left + right) // 2
cnt += merge_sort(ary, left, mid)
cnt += merge_sort(ary, mid, right)
cnt += merge(ary, left, mid, right)
return cnt
if __name__ == '__main__':
n = int(input())
ary = [int(_) for _ in input().split()]
cnt = merge_sort(ary, 0, n)
print(*ary)
print(cnt)
| from __future__ import division, print_function
from sys import stdin
n = int(stdin.readline())
result = [0, 0]
for _ in range(n):
taro, hanako = stdin.readline().split()
if taro > hanako:
result[0] += 3
elif taro < hanako:
result[1] += 3
else:
result[0] += 1
result[1] += 1
print(*result) | 0 | null | 1,038,949,377,578 | 26 | 67 |
n=input()
s=[[1 for i in range(13)] for j in range(4)]
for i in range(n):
a,b=map(str,raw_input().split())
b=int(b)
if a=='S':s[0][b-1]=0
elif a=='H':s[1][b-1]=0
elif a=='C':s[2][b-1]=0
else:s[3][b-1]=0
for i in range(4):
for j in range(13):
if s[i][j]:
if i==0:print'S',j+1
if i==1:print'H',j+1
if i==2:print'C',j+1
if i==3:print'D',j+1 | from math import floor
X = int(input())
deposit, year = 100, 0
while deposit < X:
deposit += deposit // 100
year += 1
print(year) | 0 | null | 13,967,760,163,232 | 54 | 159 |
def main():
N, X, Y = (int(i) for i in input().split())
cnt = [0]*N
for i in range(1, N+1):
for j in range(i+1, N+1):
d = min(abs(i-j), abs(i-X)+1+abs(j-Y), abs(i-X)+abs(X-Y)+abs(j-Y))
cnt[d] += 1
for d in cnt[1:]:
print(d)
if __name__ == '__main__':
main()
| import collections
N = int(input())
S = [input() for _ in range(N)]
c = collections.Counter(S)
max_num = max(c.values())
l = []
for item in c.items():
k = item[0]
v = item[1]
if v == max_num:
l.append(k)
l.sort()
for li in l:
print(li)
| 0 | null | 57,147,959,718,400 | 187 | 218 |
S = input().rstrip() + "#"
s0 = S[0]
A, cnt = [], 1
for s in S[1:]:
if s==s0: cnt+=1
else: A.append(cnt); cnt=1
s0 = s
res, st = 0, 0
if S[0]==">":
res += A[0]*(A[0]+1)//2
st=1
for i in range(st,len(A),2):
if i+1==len(A): res += A[i]*(A[i]+1)//2; break
p, q = A[i], A[i+1]
if p < q:
res += q*(q+1)//2 + p*(p-1)//2
else:
res += q*(q-1)//2 + p*(p+1)//2
print(res)
| N = int(input())
G = [[0] * N for _ in range(N)]
time = 0
times = [{'s': 0, 'f': 0} for _ in range(N)]
for _ in range(N):
u, n, *K = map(int, input().split())
for k in K:
G[u - 1][k - 1] = 1
def dfs(u):
global time
time += 1
times[u]['s'] = time
for i in range(N):
if G[u][i] == 1 and times[i]['s'] == 0:
dfs(i)
else:
time += 1
times[u]['f'] = time
for i in range(N):
if times[i]['s'] == 0:
dfs(i)
for i, time in enumerate(times):
print(i + 1, *time.values())
| 0 | null | 78,393,404,549,570 | 285 | 8 |
N, K = map(int, input().split())
L = [0] * K
R = [0] * K
for i in range(0, K):
L[i], R[i] = map(int, input().split())
moves = [0] * N
moves[0] = 1
rui_wa = [0] * N
rui_wa[0] = 1
for i in range(1, N):
for j in range(0, K):
l = max(i - L[j], 0)
r = max(i - R[j], 0)
if i - L[j] < 0:
continue
moves[i] += (rui_wa[l] - rui_wa[r - 1]) % 998244353
rui_wa[i] = (moves[i] + rui_wa[i - 1]) % 998244353
print(moves[N - 1] % 998244353)
| N=int(input())
S=list(map(str,input()))
ans=1
for i in range(N-1):
if S[i]!=S[i+1]:
ans+=1
print(ans) | 0 | null | 86,383,484,704,868 | 74 | 293 |
n = int(input())
a = list(map(int, input().split()))
x = "APPROVED"
for i in range(n):
if a[i] == (2 * int(a[i] / 2)):
if a[i] != (3 * int(a[i] / 3)):
if a[i] != (5 * int(a[i] / 5)):
x = "DENIED"
print(str(x)) | input()
A=list(map(int,input().split()))
print("APPROVED" if all(a&1 or a%3==0 or a%5==0 for a in A) else "DENIED") | 1 | 69,082,465,612,502 | null | 217 | 217 |
H,W=map(int,input().split())
if (H==1)|(W==1):
print(1)
elif (H%2==1)&(W%2==1):
print(int((H*W+1)/2))
else:
print(int(H*W/2)) | a,b = map(str,input().split())
As = a * int(b)
Bs = b * int(a)
if As<Bs:
print(As)
else:
print(Bs) | 0 | null | 67,512,778,749,992 | 196 | 232 |
n=int(input())
if n%2==1:
print("0")
exit()
count=0
for i in range(1,30):
count+=n//(2*5**i)
print(count) | n = int(input())
if n%2!=0:
print(0)
else:
cnt = 0
n = n//2
while n>0:
cnt = cnt + (n//5)
n = n//5
print(cnt) | 1 | 115,858,389,693,692 | null | 258 | 258 |
x,y=map(int,input().split())
print(('No','Yes')[2*x<=y<=4*x and -~y%2]) | import heapq
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
L = []
ans = 0
heapq.heappush(L, -A[0])
for i in range(1, N):
max = heapq.heappop(L)
max *= -1
ans += max
heapq.heappush(L, -A[i])
heapq.heappush(L, -A[i])
print(ans)
| 0 | null | 11,441,680,936,154 | 127 | 111 |
A, B, C, K = map(int, input().split())
# 1:A枚, 0:B枚, -1:C枚, K枚を選ぶ
A = min(A, K)
B = min(K - A, B)
C = min(K - A - B, C)
assert A + B + C >= K
#print(A, B, C)
print(A - C) | A,B = input().split()
import decimal as d
d.getcontext().rounding = d.ROUND_DOWN
ans = round(d.Decimal(A)*d.Decimal(B),0)
print(ans)
| 0 | null | 19,308,095,745,742 | 148 | 135 |
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
DP = [0] * (10 ** 6 + 1)
A.sort()
Sum = 0
d = defaultdict(int)
for key in A:
d[key] += 1
for i in range(N):
if DP[A[i]] == 0:
for j in range(1, 10 ** 6):
if A[i] * j <= 10 ** 6:
DP[A[i] * j] = 1
else:
break
if d[A[i]] == 1:
Sum += 1
print(Sum)
| data = raw_input().split()
#figure = [chr(i) for i in range(ord('0'), ord('9')+1)]
stack = []
for i in range(len(data)):
if data[i] == "+":
stack[-2] = stack[-2] + stack[-1]
del stack[-1]
#print stack
elif data[i] == "-":
stack[-2] = stack[-2] - stack[-1]
del stack[-1]
#print stack
elif data[i] == "*":
stack[-2] = stack[-2] * stack[-1]
del stack[-1]
#print stack
else:
stack.append(int(data[i]))
#print stack
print stack[0] | 0 | null | 7,186,016,691,140 | 129 | 18 |
t, h = 0, 0
for i in range(int(input())):
tc, hc= input().split()
if tc > hc:
t += 3
elif tc < hc:
h += 3
else:
t += 1
h += 1
print('%d %d' % (t, h)) | N=int(input())
Taro=0
Hanako=0
for i in range(N):
T,H=map(str,input().split())
if T<H:
Hanako+=3
elif H<T:
Taro+=3
else:
Hanako+=1
Taro+=1
print(Taro,Hanako)
| 1 | 1,971,372,432,832 | null | 67 | 67 |
a, b = list(map(int, input().split()))
print("{0} {1} {2}".format(a//b, a%b, format(a / b, '.5f'))) | import sys
data = sys.stdin.readline().strip().split(' ')
a = int(data[0])
b = int(data[1])
print('%d %d %.5f' % (a // b, a % b, a / b)) | 1 | 596,563,233,056 | null | 45 | 45 |
N, u, v = map(int, input().split())
tree = [[] for i in range(N + 1)]
for _ in range(N - 1):
a, b = map(int, input().split())
tree[a].append(b)
tree[b].append(a)
def dfs(node):
sta = [node]
dis = [-1] * (N + 1)
dis[node] = 0
while sta:
no = sta.pop()
tempD = dis[no] + 1
for tempN in tree[no]:
if dis[tempN] < 0:
dis[tempN] = tempD
sta.append(tempN)
else:
return dis
disU = dfs(u)
disV = dfs(v)
ans = 0
for u_, v_ in zip(disU[1:], disV[1:]):
if u_ < v_:
ans = max(ans, v_)
else:
print(ans - 1) | ma = lambda :map(int,input().split())
n,u,v = ma()
u,v = u-1,v-1
tree = [[] for i in range(n)]
import collections
for i in range(n-1):
a,b = ma()
tree[a-1].append(b-1)
tree[b-1].append(a-1)
que = collections.deque([(v,0)])
vis = [False]*n
dist_v = [0]*n
while que:
now,c = que.popleft()
vis[now] = True
dist_v[now] = c
for node in tree[now]:
if not vis[node]:
que.append((node,c+1))
que = collections.deque([(u,0)])
vis = [False]*n
dist_u = [0]*n
while que:
now,c = que.popleft()
vis[now] = True
dist_u[now] = c
for node in tree[now]:
if not vis[node]:
que.append((node,c+1))
ans = 0
for i in range(n):
if dist_u[i] < dist_v[i]:
ans = max(ans,dist_v[i])
print(ans-1)
| 1 | 117,668,840,619,510 | null | 259 | 259 |
from math import gcd
N = int(input())
A = list(map(int, input().split()))
prime = list(range(max(A) + 1))
for i in range(2, len(prime)):
if prime[i] != i:
continue
for j in range(i, len(prime), i):
if prime[j] != j:
continue
prime[j] = i
used = set()
pc = True
for a in A:
used_this = set()
while a != 1:
div = prime[a]
if div in used:
pc = False
break
used_this.add(div)
a //= div
used.update(used_this)
if pc:
print('pairwise coprime')
exit()
buf = A[0]
for a in A[1:]:
buf = gcd(buf, a)
if buf == 1:
print('setwise coprime')
else:
print('not coprime') | x = int(input())
money = 100
count = 0
while money < x:
money = (money * 101) // 100
count += 1
print(count) | 0 | null | 15,611,097,059,480 | 85 | 159 |
def gcd(n, m):
if m == 0:
return n
return gcd(m, n % m)
N = int(input())
A = list(map(int,input().split()))
mod = 10**9+7
kbs = A[0]
for i in range(1,N):
kbs = kbs*A[i]//gcd(kbs,A[i])
kbs %= mod
ans = 0
for i in range(N):
ans += pow(A[i],mod-2,mod)
ans %= mod
print(kbs*ans%mod) | N = int(input())
A = list(map(int, input().split()))
mod = 10**9 + 7
a = max(A)
prime_num = [2]
sgn = [0 for _ in range(max(int(a**0.5)+1, 4))]
sgn[2] = 1
for k in range(3, len(sgn), 2):
if sgn[k] == 0:
prime_num.append(k)
for j in range(k, a+1, k**2):
sgn[k] = 1
baisu = []
count = [0 for _ in range(a+1)]
for k in range(N):
b = 0 + A[k]
for p in prime_num:
if p**2 <= b:
if b%p == 0:
if count[p] == 0:
baisu.append(p)
c = 0
while b % p == 0:
b //= p
c += 1
if c > count[p]:
count[p] = c
else:
break
if b != 1:
if count[b] == 0:
count[b] = 1
baisu.append(b)
product = 1
for item in baisu:
product *= pow(item, count[item], mod)
product %= mod
b = mod-2
blis = []
c = 0
while b >0:
if b & 1 == 1:
blis.append(c)
c += 1
b >>= 1
def modinv(a):
if a == 1:
return 1
else:
res = 1
li = []
for _ in range(c):
li.append(a%mod)
a = a*a%mod
for item in blis:
res = res *li[item] %mod
return res
ans = 0
for k in range(N):
ans += product*modinv(A[k])
ans %= mod
print(ans)
| 1 | 88,056,221,852,950 | null | 235 | 235 |
bit=[0 for i in xrange(200)]
n=int(raw_input().strip())
class dig:
def __init__(self,val,id):
self.val=val
self.id=id
def __gt__(self,other):
return self.val<other.val
def sum(i):
s=0
i=int(i)
while i>0:
s+=bit[i]
i-=i&(-i)
return s
def add(i,x):
i=int(i)
while i<=n:
bit[i]+=x
i+=i&-i
def sort2(lst):
lens=len(lst)
sm=0
for i in xrange(lens):
for j in xrange(i+1,lens):
if lst[i]>lst[j]:
sm+=1
return sm
lst=map(int,raw_input().strip().split())
vals=[]
lens=len(lst)
for i in xrange(lens):
vals.append(dig(lst[i],i+1))
vals.sort()
ans=0
for i in vals:
#print i.val,i.id
ans+=sum(i.id)
add(i.id,1)
ans=sort2(lst)
lst.sort()
print " ".join(str(pp) for pp in lst)
print ans
| N = int(input())
if(N % 2 == 0):
print(0.5000000000)
else:
M = (N+1)/2
print(M/N) | 0 | null | 88,229,628,441,760 | 14 | 297 |
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
*a, = map(int, input().split())
s = [0]*(n+1)
for i in range(len(a)):
s[i+1] = s[i] + a[i]
for i in range(len(s)):
s[i] = (s[i] - i)%k
from collections import defaultdict
cnt = defaultdict(int)
left = 0
right = k-1
if right > n:
right = n
for i in range(right+1):
cnt[s[i]] += 1
ans = 0
while left < right:
ans += cnt[s[left]]-1
if right == n:
cnt[s[left]] -= 1
left += 1
else:
cnt[s[left]] -= 1
left += 1
right += 1
cnt[s[right]] += 1
print(ans)
| def shaku(K,lists):
ans=0
SUMS=0
index=0
for l in range(len(lists)):
while index < l or index< len(lists) and SUMS +lists[index] < K:
SUMS += lists[index]
index+= 1
ans += index-l
SUMS -= lists[l]
return ans
n,k=map(int,input().split())
lists=list(map(int,input().split()))
uselist=[0 for i in range(n+1)]
for i in range(n):
uselist[i+1]=(uselist[i]+lists[i])
anslist=[0 for i in range(n+1)]
for j in range(1,n+1):
anslist[j]=(uselist[j]-j)%k
dic={}
for i in range(n+1):
if anslist[i] in dic.keys():
dic[anslist[i]].append(i+1)
else:
dic[anslist[i]]=[1+i]
#answerに答えを格納することにする
answer=0
for lis in dic.values():
sublis=[lis[0]]
for a in range(1,len(lis)):
sublis.append(lis[a]-lis[a-1])
P=shaku(k,sublis)
for some in lis:
if some<k:
answer-=1
answer+=P
print(answer) | 1 | 137,584,989,197,978 | null | 273 | 273 |
import math
n,k=map(int,input().split())
A=list(map(int,input().split()))
low=1
high=max(A)
while low!=high:
mid=(low+high)//2
s=0
for i in range(n):
s+=math.ceil(A[i]/mid)-1
if s>k:
low=mid+1
else:
high=mid
print(low) | n = int(input())
S = list(map(int, input().split()))
c = 0
def merge(left, mid, right):
global c
L = S[left:mid] + [float('inf')]
R = S[mid:right] + [float('inf')]
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
c += right - left
def merge_sort(left, right):
if left + 1 < right:
mid = (left + right) // 2
merge_sort(left, mid)
merge_sort(mid, right)
merge(left, mid, right)
merge_sort(0, n)
print(*S)
print(c)
| 0 | null | 3,348,036,358,784 | 99 | 26 |
N = int(input())
A = [int(_) for _ in input().split()]
A.sort(reverse=True)
ans = 0
for i in range(N-1):
ans += A[(i+1) // 2]
print(ans)
| def resolve():
X, Y, Z = list(map(int, input().split()))
print(Z, X, Y)
if '__main__' == __name__:
resolve() | 0 | null | 23,513,266,020,060 | 111 | 178 |
n, q = list(map(int, input().split()))
que = []
for i in range(n):
p, t = input().split()
que.append([p, int(t)])
total = 0
while True:
if q >= que[0][1]:
total += que[0][1]
print(que[0][0], total)
que.pop(0)
else:
total += q
que[0][1] -= q
que.append(que[0])
que.pop(0)
if len(que) == 0:
break
| f = list(input())
s = []
for i, v in enumerate(f):
if v == '\\':
s.append([v, i])
elif v == '/' and len(s) > 0:
n = s.pop()
if n[0] == '\\':
t = i-n[1]
s.append(['.', t])
elif len(s) > 0:
j = len(s)-1
n1 = n[1]
while j >= 0 and s[j][0] == '.':
#print(n1, s[j][1])
n1 += s[j][1]
j -= 1
if j >= 0:
m = s[j]
# print(m)
n1 += i-m[1]
s = s[:j]
s.append(['.', n1])
else:
# print("err")
s.append(n)
else:
s.append(n)
#print(v, s, i)
a = [v[1] for v in s if v[0] == '.']
print(sum(a))
a.insert(0, len(a))
print(" ".join([str(v) for v in a]))
| 0 | null | 51,566,897,920 | 19 | 21 |
n = int(input())
s = input()
if n % 2 == 1:
print('No')
exit()
mid= int(len(s)/2)
if s[:mid] == s[mid:]:
print('Yes')
else:
print('No')
| #
# author sidratul Muntaher
# date: Aug 19 2020
#
n = int(input())
from math import pi
print(pi* (n*2))
| 0 | null | 89,104,448,415,100 | 279 | 167 |
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():
A, B, K = map(int, readline().split())
if K < A:
print(A - K, B)
elif K < A + B:
print(0, A + B - K)
else:
print(0, 0)
return
if __name__ == '__main__':
main()
| while True:
m, f, r = map(int, raw_input().split())
if (m+f+r) == -3:
break
if (m * f) < 0:
print "F"
elif (m + f) >= 80:
print 'A'
elif 65 <= (m + f) < 80:
print 'B'
elif 50 <= (m + f) < 65:
print 'C'
elif 30 <= (m + f) < 50:
if r < 50:
print 'D'
else:
print 'C'
elif (m + f) < 30:
print 'F' | 0 | null | 52,793,582,945,900 | 249 | 57 |
def a169(a, b):
return a*b
def main():
a, b = map(int, input().split())
print(a169(a, b))
if __name__ == '__main__':
main() | A, B = map(int, input().split())
R = A * B
print(R)
| 1 | 15,718,582,273,312 | null | 133 | 133 |
from math import ceil
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort(reverse=True)
F.sort()
wk = 0
for i in range(N):
wk += A[i] * F[i]
#print(wk)
def is_ok(arg):
# 条件を満たすかどうか？問題ごとに定義
cnt = 0
for i in range(N):
a,f = A[i], F[i]
if a*f <= arg:
continue
else:
#(a-k) * f <= arg
# a - arg/f <= k
cnt += ceil(a-arg/f)
return cnt <= K
def meguru_bisect(ng, ok):
'''
初期値のng,okを受け取り,is_okを満たす最小(最大)のokを返す
まずis_okを定義すべし
ng ok は とり得る最小の値-1 とり得る最大の値+1
最大最小が逆の場合はよしなにひっくり返す
'''
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
ng = -1
ok = 10**12 + 10
ans = meguru_bisect(ng,ok)
print(ans) | N, K = map(int, input().split())
*A, = map(int, input().split())
*F, = map(int, input().split())
A, F = sorted(A), sorted(F, reverse=True)
def cond(x):
k = 0
for a, f in zip(A, F): k += max(a - (x // f), 0)
return True if k <= K else False
MIN = -1
MAX = 10**12 + 1
left, right = MIN, MAX # search range
while right - left > 1:
mid = (left + right) // 2
if cond(mid): right = mid
else: left = mid
print(right) | 1 | 164,722,417,860,910 | null | 290 | 290 |
S = input()
Q = int(input())
Query = list(input().split() for _ in range(Q))
count = 0
L, R = "", ""
for i in range(Q):
if Query[i][0] == "1": count += 1
else:
if Query[i][1] == "1":
if count % 2 == 0: L = Query[i][2] + L
else: R += Query[i][2]
else:
if count % 2 == 0: R += Query[i][2]
else: L = Query[i][2] + L
if count % 2 == 0: print(L + S + R)
else: print(R[::-1] + S[::-1] + L[::-1]) | # coding: utf-8
# Your code here!
N,K=map(int,input().split())
A=list(map(float, input().split()))
low=0
high=10**9+1
while high-low!=1:
mid=(high+low)//2
cut_temp=0
ans=-1
for a in A:
cut_temp+=-(-a//mid)-1
if cut_temp>K:
low=mid
else:
high=mid
print(high) | 0 | null | 31,906,265,299,838 | 204 | 99 |
text = raw_input()
t = list(text)
for i in range(len(t)):
if t[i].isupper():
t[i] = t[i].lower()
elif t[i].islower():
t[i] = t[i].upper()
print "".join(t) | import numpy as np
import sys
input = sys.stdin.readline
def main():
n, s = map(int, input().split())
A = np.array([int(i) for i in input().split()])
MOD = 998244353
dp = np.zeros(s + 1, dtype="int32")
dp[0] = 1
for i in range(n):
p = (dp * 2) % MOD
p %= MOD
p[A[i]:] += dp[:-A[i]]
dp = p % MOD
print(dp[s])
if __name__ == '__main__':
main() | 0 | null | 9,687,513,851,620 | 61 | 138 |
n = int(input())
lst = list(map(int, input().split()))
mod = 10**9+7
# 累積和(Cumulative sum)リストの作成
cumsum = [0]*(n+1)
for i in range(n):
cumsum[i+1] = lst[i] + cumsum[i]
# 題意より、lst の1つ前までが対象
ans = 0
for i in range(n-1):
ans += (cumsum[n] - cumsum[i+1]) * lst[i]
print(ans % mod)
| import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H):
'''
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_matrix(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
def combination_mod(n, r, mod):
# if r > n:
# return 0 # このような通りの数は無いため便宜上こう定義する
r = min(r, n - r)
nf = rf = 1
for i in range(r):
nf = nf * (n - i) % mod
rf = rf * (i + 1) % mod
return nf * pow(rf, mod - 2, mod) % mod
def ret_list_combination_mod(n, r, mod):
ret = [1]
if r > n:
return 0 # このような通りの数は無いため便宜上こう定義する
# r = min(r, n - r)
nf = rf = 1
for i in range(r):
nf = nf * (n - i) % mod
rf = rf * (i + 1) % mod
ret.append(nf * pow(rf, mod - 2, mod) % mod)
return ret
# https://atcoder.jp/contests/abc156/tasks/abc156_e
MOD = 10**9 + 7
n, k = read_ints()
# n<=kのときは簡単
if n <= k:
print(combination_mod(n + n - 1, n, MOD))
exit()
# n>kのときはどうしよう
ans = 1
nCa = ret_list_combination_mod(n, k, MOD)
n_1Ca = ret_list_combination_mod(n - 1, k, MOD)
for a in range(1, k + 1):
ans += nCa[a] * n_1Ca[a] # ここ高速化しないと厳しいかな
ans %= MOD
print(ans)
| 0 | null | 35,261,783,555,740 | 83 | 215 |
num = int(input())
A = input().split(" ")
B = A.copy()
#bubble sort
for i in range(num):
for j in range(num-1,i,-1):
#英字ではなく、数字で比較する
m1 = int(A[j][1:])
m2 = int(A[j-1][1:])
if m1 < m2:
A[j],A[j-1] = A[j-1],A[j]
print(*A)
print("Stable")
#selection sort
for i in range(num):
minv = i
for j in range(i+1,num):
m1 = int(B[minv][1:])
m2 = int(B[j][1:])
if m1 > m2:
minv = j
B[i],B[minv] = B[minv],B[i]
print(*B)
if A == B:
print("Stable")
else:
print("Not stable")
| N = int(input())
l = input().split()
l2 = l[:]
for j in range(N):
for i in range(N-1):
if l[i][1] > l[i+1][1]:
l[i], l[i+1] = l[i+1], l[i]
for i in range(0,len(l)-1):
print(l[i],end=' ')
print(l[N-1])
print("Stable")
for j in range(0,len(l2)-1):
min = l2[j][1]
a = j
for i in range(j,len(l2)):
if min > l2[i][1]:
min = l2[i][1]
a = i
l2[j],l2[a] = l2[a],l2[j]
for i in range(0,len(l2)-1):
print(l2[i],end=' ')
print(l2[N-1])
if l==l2:
print("Stable")
else:
print("Not stable")
| 1 | 26,216,550,460 | null | 16 | 16 |
N, K = map(int, input().split())
N += 1
ans = 0
p = 10 ** 9 + 7
for k in range(K, N + 1):
ans += (k * (N - k) + 1) % p
ans %= p
print(ans) | import sys
import copy
from collections import deque
stdin = sys.stdin
mod = 10**9+7
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n,k = na()
if n==k-1:
print(1)
exit(0)
prev_min = sum([i for i in range(k)])
prev_max = sum([i for i in range(n, n-k, -1)])
prev_num_min = k-1
prev_num_max = n-k+1
cnt = 0
for i in range(n-k+2):
# print("{} {}".format(prev_min, prev_max))
cnt += prev_max-prev_min+1
cnt %= mod
prev_num_min += 1
prev_num_max -= 1
prev_min += prev_num_min
prev_max += prev_num_max
print(cnt)
| 1 | 33,287,794,005,752 | null | 170 | 170 |
from collections import deque
n = int(input())
li = deque()
for i in range(n):
command = input().split()
if command[0] == 'insert':
li.appendleft(command[1])
elif command[0] == 'delete':
if command[1] in li:
li.remove(command[1])
elif command[0] == 'deleteFirst':
li.popleft()
else:
li.pop()
print(*li) | import math
N = int(input())
ans = math.inf
for i in range(1, math.ceil(math.sqrt(N)) + 1):
if N%i == 0:
ans = i+N//i-2
print(ans)
| 0 | null | 80,450,873,845,970 | 20 | 288 |
for i in range(9):
for k in range(9):
p = (i+1)*(k+1)
print('{}x{}={}'.format(i+1,k+1,p))
| A,B=map(int,input().split())
if A==0 or A>=10 or B==0 or B>=10:
print(-1)
else:
print(A*B) | 0 | null | 78,997,769,420,320 | 1 | 286 |
import sys
input=sys.stdin.readline
def main():
r,c,k=map(int,input().split())
item=[[0]*c for i in range(r)]
for i in range(k):
R,C,v=map(int,input().split())
item[R-1][C-1]=v
dp0=[[-10**10]*c for i in range(r)]
dp1 = [[-10 ** 10] * c for i in range(r)]
dp2 = [[-10 ** 10] * c for i in range(r)]
dp3 = [[-10 ** 10] * c for i in range(r)]
if item[0][0]==0:
dp0[0][0]=0
else:
dp0[0][0]=0
dp1[0][0]=item[0][0]
for i in range(r):
for j in range(c):
if j!=c-1:
v=item[i][j+1]
if v==0:
dp0[i][j+1]=max(dp0[i][j],dp0[i][j+1])
dp1[i][j + 1] = max(dp1[i][j], dp1[i][j + 1])
dp2[i][j + 1] = max(dp2[i][j], dp2[i][j + 1])
dp3[i][j + 1] = max(dp3[i][j], dp3[i][j + 1])
else:
dp0[i][j+1]=max(dp0[i][j],dp0[i][j+1])
dp1[i][j+1]=max(dp0[i][j]+v,dp1[i][j],dp1[i][j+1])
dp2[i][j + 1] = max(dp1[i][j] + v, dp2[i][j], dp2[i][j + 1])
dp3[i][j + 1] = max(dp2[i][j] + v, dp3[i][j], dp3[i][j + 1])
if i!=r-1:
v=item[i+1][j]
if v==0:
dp0[i+1][j]=max(dp0[i][j],dp1[i][j],dp2[i][j],dp3[i][j],dp0[i+1][j])
else:
dp0[i+1][j]=max(dp0[i][j],dp1[i][j],dp2[i][j],dp3[i][j],dp0[i+1][j])
dp1[i + 1][j] = max(dp0[i][j]+v, dp1[i][j]+v, dp2[i][j]+v, dp3[i][j]+v, dp1[i + 1][j])
ans=max(dp0[r-1][c-1],dp1[r-1][c-1],dp2[r-1][c-1],dp3[r-1][c-1])
print(ans)
if __name__=='__main__':
main() | import os
import sys
import numpy as np
def solve(inp):
r, c, k = inp[:3]
items = np.zeros((r + 1, c + 1), dtype=np.int64)
rrr = inp[3::3]
ccc = inp[4::3]
vvv = inp[5::3]
for r_, c_, v in zip(rrr, ccc, vvv):
items[r_, c_] = v
dp = np.zeros((r + 1, c + 1, 4), dtype=np.int64)
for i in range(1, r + 1):
for j in range(1, c + 1):
v = items[i, j]
dp[i, j] = np.maximum(dp[i, j - 1], dp[i - 1, j, 3])
if v > 0:
dp[i, j, 1:] = np.maximum(dp[i, j, 1:], dp[i, j, :-1] + v)
return dp[-1, -1, -1]
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', '(i8[:],)')(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit('(i8[:],)', cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print(ans)
| 1 | 5,592,764,254,220 | null | 94 | 94 |
N = int(input())
print(N // 2 + N % 2)
| class BalancingTree:
def __init__(self, n):
self.N = n
self.root = self.node(1<<n, 1<<n)
def append(self, v):# v を追加（その時点で v はない前提）
v += 1
nd = self.root
while True:
if v == nd.value:
# v がすでに存在する場合に何か処理が必要ならここに書く
return 0
else:
mi, ma = min(v, nd.value), max(v, nd.value)
if mi < nd.pivot:
nd.value = ma
if nd.left:
nd = nd.left
v = mi
else:
p = nd.pivot
nd.left = self.node(mi, p - (p&-p)//2)
break
else:
nd.value = mi
if nd.right:
nd = nd.right
v = ma
else:
p = nd.pivot
nd.right = self.node(ma, p + (p&-p)//2)
break
def leftmost(self, nd):
if nd.left: return self.leftmost(nd.left)
return nd
def rightmost(self, nd):
if nd.right: return self.rightmost(nd.right)
return nd
def find_l(self, v): # vより真に小さいやつの中での最大値（なければ-1）
v += 1
nd = self.root
prev = 0
if nd.value < v: v = nd.value
while True:
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return prev - 1
else:
prev = nd.value
if nd.right:
nd = nd.right
else:
return prev - 1
def find_r(self, v): # vより真に大きいやつの中での最小値（なければRoot）
v += 1
nd = self.root
prev = 0
while True:
if v < nd.value:
prev = nd.value
if nd.left:
nd = nd.left
else:
return prev - 1
else:
if nd.right:
nd = nd.right
else:
return prev - 1
@property
def max(self):
return self.find_l((1<<self.N)-1)
@property
def min(self):
return self.find_r(-1)
def delete(self, v, nd = None, prev = None): # 値がvのノードがあれば削除（なければ何もしない）
v += 1
if not nd: nd = self.root
if not prev: prev = nd
while v != nd.value:
prev = nd
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return
else:
if nd.right:
nd = nd.right
else:
return
if (not nd.left) and (not nd.right):
if nd.value < prev.value:
prev.left = None
else:
prev.right = None
elif not nd.left:
if nd.value < prev.value:
prev.left = nd.right
else:
prev.right = nd.right
elif not nd.right:
if nd.value < prev.value:
prev.left = nd.left
else:
prev.right = nd.left
else:
nd.value = self.leftmost(nd.right).value
self.delete(nd.value - 1, nd.right, nd)
def __contains__(self, v: int) -> bool:
return self.find_r(v - 1) == v
class node:
def __init__(self, v, p):
self.value = v
self.pivot = p
self.left = None
self.right = None
k = (500000+1).bit_length()
dic = {}
for i in range(97, 123):
dic[chr(i)] = BalancingTree(k)
n = int(input())
s = input()
lst = []
for i in range(n):
lst.append(s[i])
dic[s[i]].append(i)
ans = []
q = int(input())
for _ in range(q):
que = input()
if que[0] == '1':
kind, i, c = que.split()
i = int(i) - 1
dic[lst[i]].delete(i)
dic[c].append(i)
lst[i] = c
else:
kind, l, r = map(int, que.split())
l -= 2; r -= 1
temp = 0
for key in dic.keys():
if dic[key].find_r(l) <= r:
temp += 1
ans.append(temp)
for i in ans:
print(i) | 0 | null | 60,642,422,635,392 | 206 | 210 |
#146_F
n, m = map(int, input().split())
s = input()[::-1]
ans = []
flg = True
cur = 0
while cur < n and flg:
for to in range(cur + m, cur, -1):
if to > n:
continue
if s[to] == '0':
ans.append(to - cur)
cur = to
break
if to == cur + 1:
flg = False
if flg:
print(*ans[::-1])
else:
print(-1) | s = input()
t = input()
s_len = len(s)
t_len = len(t)
out = t_len
for i in range(0, s_len - t_len + 1):
diff = 0
for j in range(0, t_len):
if t[j] != s[i + j]:
diff += 1
out = min(out, diff)
print(out)
| 0 | null | 71,482,032,601,590 | 274 | 82 |
T1,T2=[int(i) for i in input().split()]
A1,A2=[int(i) for i in input().split()]
B1,B2=[int(i) for i in input().split()]
if((B1-A1)*((B1-A1)*T1+(B2-A2)*T2)>0):
print(0);
exit();
if((B1-A1)*T1+(B2-A2)*T2==0):
print("infinity")
exit();
ans=(abs((B1-A1)*T1)//abs((B1-A1)*T1+(B2-A2)*T2))*2+1
if(abs((B1-A1)*T1)%abs((B1-A1)*T1+(B2-A2)*T2)==0):
ans-=1
print(ans)
| from sys import stdin
n = int(stdin.readline().rstrip())
A = [int(x) for x in stdin.readline().rstrip().split()]
ans = [0] * n
for i, a in enumerate(A):
ans[a-1] = i+1
print(' '.join(map(str, ans))) | 0 | null | 156,389,003,376,032 | 269 | 299 |
#!/usr/bin/env python3
from fractions import gcd
n = int(input())
a = list(map(int, input().split()))
MOD = 10 ** 9 + 7
l = 1
for x in a:
l = l * x // gcd(l, x)
ans = sum(l // x for x in a) % MOD
print(ans)
| def gcd(m, n):
r = m % n
return gcd(n, r) if r else n
def lcm(m, n):
return m//gcd(m, n)*n
MOD = 10**9+7
n = int(input())
a = list(map(int, input().split()))
l = a[0]
for x in a[1:]:
l = lcm(x, l)
l %= MOD
ans = 0
for x in a:
ans = (ans + l * pow(x, MOD-2, MOD)%MOD)%MOD
print(ans)
| 1 | 87,955,287,393,610 | null | 235 | 235 |
x = int(input())
taka = 100
count = 0
while taka < x:
taka = taka * 101 // 100
count += 1
print(count)
| X = int(input())
price = 100
year = 0
while price<X:
price += price//100
year += 1
print(year) | 1 | 27,201,154,409,660 | null | 159 | 159 |
N = int(input())
MAX = 10**6
table = [0]*(MAX+1)
for x in map(int,input().split()):
table[x] += 1
for i in range(MAX+1):
if table[i]:
for j in range(2*i if table[i] == 1 else i, MAX+1, i):
table[j] = 0
print(sum(table)) | a,b,c=map(int, input().split())
0<=a<=100,0<=b<=100,0<=c<=100,
if a<b:
if b<c:
print('Yes')
else:
print('No')
else:
print('No')
| 0 | null | 7,439,053,286,158 | 129 | 39 |
S = int(input())
h = int(S/3600)
m = int((S- h*3600)/60)
sec = S- h*3600-m*60;
print(str(h)+":"+str(m)+":"+str(sec))
| x = input()
a = x/3600
b = x%3600/60
c = x - a*3600 - b*60
print '%d:%d:%d'%(a, b, c) | 1 | 331,351,003,452 | null | 37 | 37 |
class Dice:
def __init__(self,num):
self.num = num.copy()
def east(self):
temp = self.num.copy()
self.num[1-1] = temp[4-1]
self.num[4-1] = temp[6-1]
self.num[6-1] = temp[3-1]
self.num[3-1] = temp[1-1]
def north(self):
temp = self.num.copy()
self.num[1-1] = temp[2-1]
self.num[2-1] = temp[6-1]
self.num[6-1] = temp[5-1]
self.num[5-1] = temp[1-1]
def south(self):
temp = self.num.copy()
self.num[1-1] = temp[5-1]
self.num[5-1] = temp[6-1]
self.num[6-1] = temp[2-1]
self.num[2-1] = temp[1-1]
def west(self):
temp = self.num.copy()
self.num[1-1] = temp[3-1]
self.num[3-1] = temp[6-1]
self.num[6-1] = temp[4-1]
self.num[4-1] = temp[1-1]
def right(self):
temp = self.num.copy()
self.num[2-1] = temp[4-1]
self.num[4-1] = temp[5-1]
self.num[5-1] = temp[3-1]
self.num[3-1] = temp[2-1]
num = list(map(int,input().split()))
dice = Dice(num)
q = int(input())
for _ in range(q):
top,front = map(int,input().split())
while not (top == dice.num[0] or front == dice.num[1]): dice.north()
while top != dice.num[0]: dice.east()
while front != dice.num[1]: dice.right()
print(dice.num[2])
| import random
class Dice:
def __init__(self, list = map(str, range(1, 7))):
self.top = list[0]
self.front = list[1]
self.right = list[2]
self.left = list[3]
self.back = list[4]
self.bottom = list[5]
def print_all(self):
print "top = " + self.top
print "front = " + self.front
print "right = " + self.right
print "left = " + self.left
print "back = " + self.back
print "bottom = " + self.bottom
def roll_N(self):
temp = self.top
self.top = self.front
self.front = self.bottom
self.bottom = self.back
self.back = temp
def roll_S(self):
temp = self.top
self.top = self.back
self.back = self.bottom
self.bottom = self.front
self.front = temp
def roll_W(self):
temp = self.top
self.top = self.right
self.right = self.bottom
self.bottom = self.left
self.left = temp
def roll_E(self):
temp = self.top
self.top = self.left
self.left = self.bottom
self.bottom = self.right
self.right = temp
def random_roll(self):
ram = random.randint(1, 4)
if ram == 1:
self.roll_E()
elif ram == 2:
self.roll_N()
elif ram == 3:
self.roll_S()
else:
self.roll_W()
my_dice = Dice(raw_input().split(" "))
q = int(raw_input())
for i in xrange(q):
input_dice = raw_input().split(" ")
while True:
if my_dice.top == input_dice[0] and my_dice.front == input_dice[1]:
break
else:
my_dice.random_roll()
print my_dice.right | 1 | 260,427,984,258 | null | 34 | 34 |
def Distance(X,Y,p):
s=0
for x,y in zip(X,Y):
s+=abs(x-y)**p
print(s**(1/p))
n=int(input())
X=list(map(int,input().split()))
Y=list(map(int,input().split()))
for p in range(1,4):
Distance(X,Y,p)
print(max(abs(x-y) for x,y in zip(X,Y)))
| n, d = map(int, input().split())
number = 0
for i in range(n):
x, y = map(int, input().split())
distance = x ** 2 + y ** 2
if distance <= d ** 2:
number += 1
print(number) | 0 | null | 3,056,323,064,510 | 32 | 96 |
A = int(input())
B = int(input())
anss = set([1, 2, 3])
anss.remove(A)
anss.remove(B)
for i in anss:
print(i)
| w,c = map(int,input().split())
res = w - (2*c)
if res < 0:
res =0
print(res) | 0 | null | 138,613,654,904,160 | 254 | 291 |
N, K, C = map(int, input().split())
S = input()
S_reverse = S[::-1]
left_justified = [-1 for _ in range(N)]
right_justified = [-2 for _ in range(N)]
for i_justified in (left_justified, right_justified):
if i_justified == left_justified:
i_S = S
nearest_position = 1
positioning = 1
else:
i_S = S_reverse
nearest_position = K
positioning = -1
i_K = 0
while i_K <= N-1:
if i_S[i_K] == 'o':
i_justified[i_K] = nearest_position
i_K += C
nearest_position += positioning
i_K += 1
for i_N in range(N):
if left_justified[i_N] == right_justified[N - i_N - 1]:
print(i_N + 1) | X = int(input())
K = 1
d = X
while d % 360 != 0:
d += X
K += 1
print(K)
| 0 | null | 26,999,979,970,990 | 182 | 125 |
#!/usr/bin/env python3
n = list(input())
if '3' == n[-1]:
print('bon')
elif n[-1] in ['0', '1', '6', '8']:
print('pon')
else:
print('hon')
| N = int(input()) % 10
if N in {2,4,5,7,9}:
print("hon")
elif N in {0,1,6,8}:
print("pon")
else:
print("bon") | 1 | 19,115,649,947,808 | null | 142 | 142 |
while 1:
x,y=sorted(map(int,raw_input().split()))
if x==y==0:break
print str(x)+" "+str(y) | while True:
x,y=map(int,input().split())
if (x==0) & (y==0):
break
else:
if x>y:
print(y,x)
else:
print(x,y) | 1 | 514,337,311,676 | null | 43 | 43 |
arg_01, arg_02, arg_03 = map(int,input().split())
if arg_01<arg_02<arg_03:
print('Yes')
else:
print('No') | #coding:utf-8
a , b , c =input().rstrip().split(" ")
if int(a)<int(b):
if int(b)<int(c):
print("Yes")
else:
print("No")
else:
print("No") | 1 | 384,244,945,060 | null | 39 | 39 |
import fractions
mod=10**9+7
def lcm(m,n):return m//fractions.gcd(m,n)*n
n=int(input())
a=list(map(int,input().split()))
l=a[0]
ans=0
for i in a:l=lcm(i,l)
for i in a:ans+=l*pow(i,mod-2,mod)%mod
print(ans%mod) | class SegmentTree:
def __init__(self, lst, op, e):
self.n = len(lst)
self.N = 1 << ((self.n - 1).bit_length())
self.op = op # operation
self.e = e # identity element
self.v = self._build(lst) # self.v is set to be 1-indexed for simplicity
def _build(self, lst):
# construction of a tree
# total 2 * self.N elements (tree[0] is not used)
tree = [self.e] * (self.N) + lst + [self.e] * (self.N - self.n)
for i in range(self.N - 1, 0, -1): tree[i] = self.op(tree[i << 1], tree[(i << 1)|1])
return tree
def __getitem__(self, i):
return self.v[i + self.N]
# update a_i to be x
def update(self, i, x):
v, op = self.v, self.op
i += self.N
v[i] = x
while i > 0:
i >>= 1 # move to parent
v[i] = op(v[i << 1], v[(i << 1)|1])
# returns answer for the query interval [l, r)
def fold(self, l, r):
N, e, v, op = self.N, self.e, self.v, self.op
left = l + N; right = r + N
L = R = e
while left < right:
if left & 1: # self.v[left] is the right child
L = op(L, v[left])
left += 1
if right & 1: # self.v[right-1] is the left child
right -= 1
R = op(v[right], R)
left >>= 1; right >>= 1
return op(L, R)
def wa(set1, set2):
return set1 | set2
n = int(input())
s = input()
lst = []
for i in range(n):
lst.append(set([s[i]]))
st = SegmentTree(lst, wa, set([]))
ans = []
q = int(input())
for i in range(q):
que = input()
if que[0] == '1':
kind, i, c = que.split()
i = int(i) - 1
st.update(i, set([c]))
else:
kind, l, r = map(int, que.split())
l -= 1
ans.append(len(st.fold(l, r)))
for i in ans:
print(i) | 0 | null | 75,092,072,115,610 | 235 | 210 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.