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
|
|---|---|---|---|---|---|---|
tmp = input().split(" ")
a = int(tmp[0])
b = int(tmp[1])
c = int(tmp[2])
if a + b + c >= 22:
print("bust")
else:
print("win")
|
# C Traveling Salesman around Lake
K, N = map(int, input().split())
A = list(map(int, input().split()))
ans = 0
before = A[0]
for i in range(1, len(A)):
ans = max(ans, A[i] - before)
before = A[i]
ans = max(ans, A[0] + K - A[N-1])
print(K - ans)
| 0 | null | 81,126,362,225,010 | 260 | 186 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
H, W = map(int, input().split())
grid = [list("." + input()) for _ in range(H)]
dp = [[f_inf] * (W + 1) for _ in range(H)]
dp[0][0] = 0
for h in range(H):
for w in range(W + 1):
if w == 0:
if h != 0:
continue
next_h, next_w = h, w + 1
if grid[h][w] == "." and grid[next_h][next_w] == "#":
dp[next_h][next_w] = min(dp[next_h][next_w], dp[h][w] + 1)
elif grid[h][w] == "." and grid[next_h][next_w] == "#":
dp[next_h][next_w] = min(dp[next_h][next_w], dp[h][w] + 1)
else:
dp[next_h][next_w] = min(dp[next_h][next_w], dp[h][w])
else:
for dh, dw in [(1, 0), (0, 1)]:
next_h, next_w = h + dh, w + dw
if next_h < 0 or next_h >= H or next_w < 0 or next_w >= W + 1:
continue
if grid[h][w] == "." and grid[next_h][next_w] == "#":
dp[next_h][next_w] = min(dp[next_h][next_w], dp[h][w] + 1)
elif grid[h][w] == "." and grid[next_h][next_w] == "#":
dp[next_h][next_w] = min(dp[next_h][next_w], dp[h][w] + 1)
else:
dp[next_h][next_w] = min(dp[next_h][next_w], dp[h][w])
print(dp[-1][-1])
if __name__ == '__main__':
resolve()
|
n,t=map(int,input().split())
ab=[[0]*2 for i in range(n+1)]
for i in range(1,n+1):
ab[i][0],ab[i][1]=map(int,input().split())
dp=[[0]*(t+3001) for i in range(n+1)]
ab.sort(key=lambda x:x[0])
for i in range(1,n+1):
for j in range(t):
dp[i][j]=max(dp[i][j],dp[i-1][j])
dp[i][j+ab[i][0]]=max(dp[i][j+ab[i][0]],dp[i-1][j]+ab[i][1])
ans=0
for i in range(n+1):
ans=max(ans,max(dp[i]))
print(ans)
| 0 | null | 100,074,779,965,410 | 194 | 282 |
s=str(input())
j="No"
if s[2]==s[3] and s[4]==s[5]:
j="Yes"
print(j)
|
s = input()
flg = False
if s[2] == s[3] and s[4] == s[5]:
flg = True
print('Yes') if flg else print('No')
| 1 | 42,333,164,482,268 | null | 184 | 184 |
n,k=map(int,input().split())
mod=10**9+7
count=[0]*(k+1)
def getnum(m):
ret = pow(k//m,n,mod)
mul=2
while m*mul<=k:
ret-=count[m*mul]
mul+=1
return ret%mod
ans=0
for i in range(1,k+1)[::-1]:
g=getnum(i)
count[i]=g
ans+=g*i
ans%=mod
print(ans)
|
N=int(input())
X=input()
popcount=X.count('1')
bi1=[]
bi0=[]
Xnum1 = 0
Xnum0 = 0
if popcount != 1:
for i in range(N):
if i==0: bi1.append(1)
else: bi1.append(bi1[i-1]*2%(popcount-1))
Xnum1 = (Xnum1 + int(X[N-i-1])*bi1[i])%(popcount-1)
for i in range(N):
if i==0: bi0.append(1)
else: bi0.append(bi0[i-1]*2%(popcount+1))
Xnum0 = (Xnum0 + int(X[N-i-1])*bi0[i])%(popcount+1)
for i in range(N):
if popcount==1 and X[i]=='1':
print(0)
continue
if X[i]=='1':
Xi = (Xnum1 - bi1[N-i-1])%(popcount-1)
else:
Xi = (Xnum0 + bi0[N-i-1])%(popcount+1)
ans = 1
while Xi!=0:
Xi = Xi % bin(Xi).count('1')
ans += 1
print(ans)
| 0 | null | 22,382,220,661,828 | 176 | 107 |
h,w,k = map(int, input().split())
s = [[int(c) for c in input()] for i in range(h)]
ans = 114514893
for bit in range(1 << (h-1)):
cut = [-1]
for i in range(h-1):
if bit & (1 << i) : cut.append(i)
cut.append(h-1)
l = len(cut)-1
count = l-1
suml = [0 for i in range(l)]
ok = True
for i in range(w):
sumtemp = [0 for ii in range(l)]
flag2 = True #kを超えないかどうか
for j in range(l):
for kk in range(cut[j]+1,cut[j+1]+1):
sumtemp[j] = sumtemp[j] + s[kk][i]
if sumtemp[j] > k:
ok = False
break
if not ok : break
for j in range(l):
if suml[j]+sumtemp[j] > k:flag2 = False
if flag2:
for j in range(l):
suml[j] = suml[j]+sumtemp[j]
else:
count += 1
suml = sumtemp[:]
if not ok:continue
ans = min(ans,count)
print(ans)
|
def main():
H, W, K = map(int, input().split())
g = [input() for _ in range(H)]
ans = 1 << 100
for i in range(1 << H - 1):
need = bin(i).count("1")
sz = need + 1
cnt = [0] * sz
f = 1
for j in range(W):
c = 0
for k in range(H):
cnt[c] += g[k][j] == "1"
if cnt[c] > K:
break
c += (i >> k) & 1
else:
continue
cnt = [0] * sz
need += 1
if need > ans:
f = 0
break
c = 0
for k in range(H):
cnt[c] += g[k][j] == "1"
if cnt[c] > K:
break
c += (i >> k) & 1
else:
continue
f = 0
break
if f:
ans = min(ans, need)
print(ans)
if __name__ == '__main__':
main()
| 1 | 48,599,117,924,632 | null | 193 | 193 |
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
def main():
A,B=mi()
print(max(0,A-2*B))
if __name__ == "__main__":
main()
|
A, B = [int(n) for n in input().split()]
print(max(0, int(A-2*B)))
| 1 | 166,587,047,773,552 | null | 291 | 291 |
import sys
def selectionSort(x_list, y):
a = 0
for i in range(y):
minj = i
for j in range(i, y):
if x_list[j] < x_list[minj]:
minj = j
x_list[i], x_list[minj] = x_list[minj], x_list[i]
if x_list[i] != x_list[minj]:
a += 1
return a
y = sys.stdin.readline()
y = int(y)
x = sys.stdin.readline()
x_list = x.split(" ")
for i in range(y):
x_list[i] = int(x_list[i])
a = selectionSort(x_list, y)
for k in range(0, y):
print x_list[k],
print
print a
|
n, m = map(int, input().split())
s = input()
x = n
roulette = []
while x > m:
for i in range(m, 0, -1):
if s[x-i] == '0':
x -= i
roulette.append(i)
break
else:
print(-1)
exit()
roulette.append(x)
roulette.reverse()
print(' '.join(map(str, roulette)))
| 0 | null | 69,752,588,931,940 | 15 | 274 |
n = int(input())
ss = [input() for _ in range(n)]
cnt = {}
ans =0
for s in ss:
if s not in cnt:
cnt[s]=0
ans += 1
print(ans)
|
N, X, M = map(int, input().split())
tmp = X
seq = []
ans = 0
for i in range(N):
if X in seq:
break
seq.append(X)
X = (X ** 2) % M
ans = sum(seq[:min(N, len(seq))])
N -= len(seq)
if N < 1:
print(ans)
exit()
i = seq.index(X)
l = len(seq) - i
ans += sum(seq[i:]) * (N//l)
N %= l
ans += sum(seq[i:i+N])
print(ans)
| 0 | null | 16,425,331,133,160 | 165 | 75 |
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))
from math import gcd
mod = int(1e9+7)
n = ii()
cnd = {}
azero = 0
bzero = 0
allzero = 0
for _ in range(n):
a,b = iim()
if a*b == 0:
if a == 0 and b != 0:
azero += 1
elif a != 0 and b == 0:
bzero += 1
else:
allzero += 1
else:
g = gcd(a,b)
a //= g
b //= g
if a<0:
a *= -1
b *= -1
before = cnd.get((a,b),False)
if b > 0:
check = cnd.get((b,-a),False)
else:
check = cnd.get((-b,a),False)
if before:
cnd[(a,b)] = [before[0]+1,before[1]]
elif check:
if b > 0:
cnd[(b,-a)] = [check[0],check[1]+1]
else:
cnd[(-b,a)] = [check[0],check[1]+1]
else:
cnd[(a,b)] = [1,0]
cnd[0] = [azero,bzero]
noreg = 0
ans = 1
#print(cnd)
for item in cnd.values():
if item[0] == 0 or item[1] == 0:
noreg += max(item[0],item[1])
else:
ans *= (2**item[0]+2**item[1]-1)
ans %= mod
print((ans*((2**noreg)%mod)-1+allzero)%mod)
|
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import sys
# sys.stdout.write(str(n)+"\n")
MODULO = 1000000007
# INF = 1e18+10
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
n = int(input())
a_b = [() for i in range(n)]
m_b_a = [() for i in range(n)]
# a_b_value_indices = {}
# m_b_a_value_indices = {}
a_b_value_count = {}
m_b_a_value_count = {}
a_b_value_rep = {}
m_b_a_value_rep = {}
used = [False for _ in range(n)]
zeroes = 0
is_zero = [False for _ in range(n)]
for i in range(n):
a, b = map(int, input().split())
if a == 0 and b == 0:
zeroes += 1
used[i] = True
is_zero[i] = True
else:
if a == 0:
a_b[i] = (0, 1)
m_b_a[i] = (1, 0)
elif b == 0:
a_b[i] = (1, 0)
m_b_a[i] = (0, 1)
else:
neg = False
if a*b < 0:
neg = True
d = gcd(abs(a), abs(b))
a = abs(a) // d
b = abs(b) // d
if neg:
a_b[i] = (-a, b)
m_b_a[i] = (b, a)
else:
a_b[i] = (a, b)
m_b_a[i] = (-b, a)
a_b_value_count[a_b[i]] = a_b_value_count.get(a_b[i], 0) + 1
# a_b_value_indices[a_b[i]] = a_b_value_indices.get(a_b[i], []) + [i]
m_b_a_value_count[m_b_a[i]] = m_b_a_value_count.get(m_b_a[i], 0) + 1
# m_b_a_value_indices[m_b_a[i]] = m_b_a_value_indices.get(m_b_a[i], []) + [i]
if a_b[i] not in a_b_value_rep:
a_b_value_rep[a_b[i]] = i
if m_b_a[i] not in m_b_a_value_rep:
m_b_a_value_rep[m_b_a[i]] = i
ans = 1
for i in range(n):
if not is_zero[i] and not used[a_b_value_rep[a_b[i]]]:
# if not connected
if a_b[i] not in m_b_a_value_count:
ans *= pow(2, a_b_value_count[a_b[i]], MODULO)
ans %= MODULO
used[a_b_value_rep[a_b[i]]] = True
# for j in a_b_value_indices[a_b[i]]:
# used[j] = True
else:
s = a_b_value_count[a_b[i]]
t = m_b_a_value_count[a_b[i]]
ans *= ((1*pow(2, s, MODULO) + 1*pow(2, t, MODULO) -1) % MODULO)
ans %= MODULO
used[a_b_value_rep[a_b[i]]] = True
used[m_b_a_value_rep[a_b[i]]] = True
# for j in m_b_a_value_indices[a_b[i]]:
# used[j] = True
# used_a_b_keys.add(a_b_key)
# used_a_b_keys.add(-1/a_b_key)
# -1 is for empty
print((ans-1+zeroes) % MODULO)
| 1 | 20,883,459,363,338 | null | 146 | 146 |
MAX = 10 ** 6
MOD = 10 ** 9 + 7
fac = [0] * MAX
finv = [0] * MAX
inv = [0] * MAX
def COMinit():
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def COM(n, r):
if n < r or r < 0 or n < 0:
return 0
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD
def main():
COMinit()
n, k = map(int, input().split())
a = sorted(list(map(int, input().split())), reverse=True)
i = 0
sum_max = 0
sum_min = 0
while n - i - 1 >= k - 1:
cnt = COM(n - i - 1, k - 1)
sum_max += a[i] * cnt
sum_min += a[n - i - 1] * cnt
i += 1
ans = (sum_max - sum_min) % MOD
print(ans)
if __name__ == '__main__':
main()
|
if __name__ == '__main__':
n = int(input())
A = list(input())
white = A.count("W")
red = A.count("R")
#最終形を作る
B = sorted(A)
#現在の形と最終形との比較をする
a = b = 0
for w,r in zip(A,B):
if w != r:
if w == "W":
a += 1
else:
b += 1
#結果
com = min(a,b)
bg = max(a,b)
dif = bg - com
ans = com + dif
print(ans)
| 0 | null | 51,053,950,693,538 | 242 | 98 |
n=int(input())
ans=0
if n%2==1:
print(ans)
else:
i=10
while n>i-1:
ans+=n//i
i*=5
print(ans)
|
import sys
W,H,x,y,r = map(int,sys.stdin.readline().split())
if x+r > W or x-r < 0 or y+r > H or y-r < 0:
print('No')
else:
print('Yes')
| 0 | null | 58,311,360,117,344 | 258 | 41 |
S, T = map(str, input().split())
T += S
print(T)
|
def main():
s, t = input().split()
print(t, s, sep='')
if __name__ == '__main__':
main()
| 1 | 103,448,390,585,102 | null | 248 | 248 |
while 1:
w,h=map(int,input().split())
if w==0 and h==0: break
for a in range(w):
print('#'*h)
print()
|
def print_rectangle(h, w):
"""
h: int
w: int
outputs rectangle using '#'
>>> print_rectangle(3, 4)
####
####
####
>>> print_rectangle(5, 6)
######
######
######
######
######
>>> print_rectangle(2, 2)
##
##
"""
for i in range(h):
print('#' * w)
if __name__ == '__main__':
#import doctest
#doctest.testmod()
while True:
(h, w) = [int(i) for i in input().split(' ')]
if h == 0 and w == 0:
break
print_rectangle(h, w)
print()
| 1 | 779,542,112,818 | null | 49 | 49 |
i=1
while True:
x = int(input())
if x==0:
break
print('Case ',i,': ',x,sep='')
i=i+1;
|
from collections import deque
DLL = deque()
n = int(input())
for i in range(n):
Line = input().split()
if Line[0] == "insert":
DLL.appendleft(Line[1])
elif Line[0] == "delete":
try:
DLL.remove(Line[1])
except ValueError:
None
elif Line[0] == "deleteFirst":
DLL.popleft()
elif Line[0] == "deleteLast":
DLL.pop()
print(" ".join(DLL))
| 0 | null | 265,182,484,852 | 42 | 20 |
word = input()
num = int(input())
for index in range(num):
code = input().split()
instruction = code[0]
start, end = int(code[1]), int(code[2])
if instruction == "replace":
word = word[:start] + code[3] + word[end+1:]
elif instruction == "reverse":
reversed_ch = "".join(reversed(word[start:end+1]))
word = word[:start] + reversed_ch + word[end+1:]
else:
print(word[start:end+1])
|
s = input()
n = int(input())
for i in range(n):
command = input().split()
if command[0] == 'replace':
a,b = map(int,command[1:3])
s = s[:a]+ command[3] + s[b+1:]
elif command[0] == 'reverse':
a,b = map(int,command[1:3])
s = s[0:a] + s[a:b+1][::-1] + s[b+1:]
elif command[0] == 'print':
a,b = map(int,command[1:3])
print(s[a:b+1])
| 1 | 2,089,402,386,890 | null | 68 | 68 |
#coding:utf-8
n,m=list(map(int,input().split()))
A,b=[],[]
for i in range(n):
A.append(list(map(int,input().split())))
for j in range(m):
b.append(int(input()))
ans=[0 for i in range(n)]
for i in range(n):
for j in range(m):
ans[i]+=A[i][j]*b[j]
for i in ans:
print(i)
|
n, m = map(int, raw_input().split())
a, b = [], []
c = [0 for _ in range (n)]
for _ in range(n):
a.append(map(int, raw_input().split()))
for _ in range(m):
b.append(int(raw_input()))
for i in range(n):
c[i] = 0
for j in range(m):
c[i] += a[i][j]*b[j]
print c[i]
| 1 | 1,175,943,207,570 | null | 56 | 56 |
import math
N = int(input())
# A = list(map(int, input().split()))
A = [int(x) for x in input().split(' ')]
a_max = [0] * (N+1)
a_min = [0] * (N+1)
a = [0] * (N+1)
#１．可・不可の判定
# 最下段からとりうる個数の範囲を考える
#0段目の範囲に１が含まれないならば”不可”(根＝１)
for i in range(N+1):
if i == 0:
a_max[N-i] = A[N-i]
a_min[N-i] = A[N-i]
else:
a_max[N-i] = a_max[N-i+1] + A[N-i]
a_min[N-i] = math.ceil(a_min[N-i+1]/2) + A[N-i]
#check print
# for i in range(N+1):
# print(str(i) + ':----')
# print(a_min[i],a_max[i])
#最上段から個数のカウント
for i in range(N+1):
if i == 0:
a[i] = 1
else:
a[i] = min((a[i-1] - A[i-1])*2 , a_max[i])
#不可は-1を、可は個数の合計を
if a_min[0] > 1:
print(-1)
else:
print(sum(a))
|
import sys
def input():
return sys.stdin.readline().strip()
n = int(input())
s = []
for _ in range(n):
s.append(input())
'''
N = sum([len(i) for i in s])
R = sum([i.count('(') for i in s])
if N % 2 == 1 or s.count('(') != N // 2:
print('No')
exit()
'''
bothleft = []
bothright = []
bothneutral = [0]
left = [0]
right = [0]
for i in s:
lnum = 0
now = 0
for j in range(len(i)):
if i[j] == '(':
now -= 1
else:
now += 1
lnum = max([lnum, now])
rnum = 0
now = 0
for j in range(len(i) - 1, -1, -1):
if i[j] == ')':
now -= 1
else:
now += 1
rnum = max([rnum, now])
if lnum > 0:
if rnum > 0:
if lnum > rnum:
bothleft.append((rnum, lnum - rnum))
elif rnum > lnum:
bothright.append((lnum, rnum - lnum))
else:
bothneutral.append(lnum)
else:
left.append(lnum)
elif rnum > 0:
right.append(rnum)
bothneutral = max(bothneutral)
bothleft.sort()
bothright.sort()
lsum = sum(left)
for i in range(len(bothleft)):
if bothleft[i][0] > lsum:
print('No')
exit()
lsum += bothleft[i][1]
if bothneutral > lsum:
print('No')
exit()
rsum = sum(right)
for i in range(len(bothright)):
if bothright[i][0] > rsum:
print('No')
exit()
rsum += bothright[i][1]
if lsum != rsum:
print('No')
exit()
print('Yes')
| 0 | null | 21,347,109,019,532 | 141 | 152 |
print(abs(int(input())-1))
|
from math import log2, ceil
class SegTree:
#####単位元######
ide_ele = 0
def __init__(self, init_val):
n = len(init_val)
self.num = 2**ceil(log2(n))
self.seg = [self.ide_ele] * (2 * self.num - 1)
for i in range(n):
self.seg[i + self.num - 1] = init_val[i]
# built
for i in range(self.num - 2, -1, -1):
self.seg[i] = self.segfunc(self.seg[2 * i + 1], self.seg[2 * i + 2])
#####segfunc######
def segfunc(self, x, y):
return x|y
def update(self, k, x):
k += self.num - 1
self.seg[k] = x
while k:
k = (k - 1) // 2
self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])
def query(self, a, b, k, l, r):
if r <= a or b <= l:
return self.ide_ele
if a <= l and r <= b:
return self.seg[k]
else:
vl = self.query(a, b, k*2+1, l, (l+r)//2)
vr = self.query(a, b, k*2+2, (l+r)//2, r)
return self.segfunc(vl, vr)
N = int(input())
S = input()
Q = int(input())
li = [1 << (ord(s) - ord('a')) for s in S]
seg_tree = SegTree(li)
ans = []
for _ in range(Q):
i, l, r = input().split()
i = int(i)
l = int(l)
if i == 1:
seg_tree.update(l-1, 1 << (ord(r) - ord('a')))
else:
r = int(r)
num = seg_tree.query(l-1, r, 0, 0, seg_tree.num)
ans.append(bin(num).count('1'))
for a in ans:
print(a)
| 0 | null | 32,876,999,371,520 | 76 | 210 |
if __name__ == '__main__':
def linearSearch(t):
S.append(t)
#print(S)
i=0
while S[i]!=t:
i+=1
del S[n]
return 1 if i!=n else 0
n=int(input())
S=list(map(int,input().split()))
q=int(input())
T=set(map(int,input().split()))
ans=0
for t in T:
ans+=linearSearch(t)
#print(t,ans)
print(ans)
|
# Aizu Problem ALDS_1_4_A: Linear Search
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input2.txt", "rt")
_ = input()
S = set([int(_) for _ in input().split()])
_ = input()
T = set([int(_) for _ in input().split()])
print(len(S.intersection(T)))
| 1 | 67,396,850,540 | null | 22 | 22 |
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_4_C&lang=jp
#??????
if __name__ == "__main__":
n_line = int(input())
l = set([])
for i in range(n_line):
input_line = input().split()
if input_line[0] == "insert":
l.add(input_line[1])
else:
if input_line[1] in l:
print("yes")
else:
print("no")
|
n = list(map(int, list(input())))
n_sum = sum(n)
print("Yes" if n_sum % 9 == 0 else "No")
| 0 | null | 2,226,669,610,692 | 23 | 87 |
n, k = list(map(int, input().split()))
MOD = (10 ** 9) + 7
ans = 0
min_val = 0
max_val = n
p = 1
for i in range(n + 1):
# print(min_val, max_val)
if i + 1 >= k:
ans += max_val - min_val + 1
ans = ans % MOD
min_val += p
max_val += n - p
p += 1
print(ans)
|
i=0
j = int(input())
numlist = list(int(i) for i in input().split())
while i < j-1:
print(numlist[j-i-1],end='')
print(' ',end='')
i += 1
print(numlist[0])
| 0 | null | 16,983,319,289,454 | 170 | 53 |
a,b,c,d=map(int, input().split())
if b<0 and c>0:
print(c*b)
elif d<0 and a>0:
print(d*a)
elif b>=0 or d>=0:
print(max(b*d,a*c))
else:
print(a*c)
|
a,b,c,d = map(int,input().split())
x1 = a*c
x2 = a*d
x3 = b*c
x4 = b*d
x = [x1,x2,x3,x4]
print(max(x))
| 1 | 3,056,165,963,500 | null | 77 | 77 |
n=int(input())
xl=[list(map(int, input().split())) for _ in range(n)]
rl=[]
for x,l in xl:
right=x-l
left=x+l
rl.append([right,left])
rl.sort(key=lambda x: x[1])
# print(rl)
cnt=0
pos=-float('inf')
for i in range(n):
if rl[i][0]>=pos:
pos=rl[i][1]
cnt+=1
print(cnt)
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N,M,K=map(int,input().split())
tree=UnionFind(N)
not_friend_candidates=[]
for i in range(M):
A,B=list(map(int,input().split()))
A-=1
B-=1
tree.union(A,B)
not_friend_candidates.append([A,B])
for j in range(K):
C,D=list(map(int,input().split()))
C-=1
D-=1
not_friend_candidates.append([C,D])
ans=[0]*N
for i,j in not_friend_candidates:
if tree.same(i,j):
ans[i]-=1
ans[j]-=1
for i in range(N):
ans[i]+=tree.size(i)-1
print(*ans)
| 0 | null | 75,680,782,909,732 | 237 | 209 |
#!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
N = int(input())
d = defaultdict(int)
maxi = 0
for _ in range(N):
S = input()
d[S] += 1
maxi = max(maxi, d[S])
ans = []
for k, v in d.items():
if v == maxi:
ans.append(k)
for a in sorted(ans):
print(a)
def main():
solve()
if __name__ == '__main__':
main()
|
def sep():
return map(int,input().strip().split(" "))
def lis():
return list(sep())
n=int(input())
print((n+1)//2)
| 0 | null | 64,432,564,347,492 | 218 | 206 |
n=input()
a=int(n[-1])
if a==2 or a==4 or a==5 or a ==7 or a==9:
print('hon')
elif a==0 or a==1 or a==6 or a==8:
print('pon')
else:
print('bon')
|
n = input()
str_n = list(n)
if str_n[-1] == "3":
print("bon")
elif str_n[-1] == "0" or str_n[-1] == "1" or str_n[-1] == "6" or str_n[-1] == "8":
print("pon")
else:
print("hon")
| 1 | 19,240,234,739,752 | null | 142 | 142 |
import sys,bisect
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
# 区間加算、上書き、一点取得
class SegmentTree:
def __init__(self, n, ele, segfun):
#####単位元######要設定0or1orinf
self.ide_ele = ele
self.segfun = segfun
####################
self.n = n
self.N0 = 1 << n.bit_length()
self.data = [self.ide_ele] * (self.N0 * 2)
def update_add(self, l, r, val):
l += self.N0
r += self.N0
while l < r:
if l & 1:
self.data[l] += val
l += 1
if r & 1:
self.data[r - 1] += val
r -= 1
l //= 2
r //= 2
def update(self, l, r, val):
l += self.N0
r += self.N0
while l < r:
if l & 1:
self.data[l] = self.segfun(self.data[l], val)
l += 1
if r & 1:
self.data[r - 1] = self.segfun(self.data[r - 1], val)
r -= 1
l //= 2
r //= 2
def query(self, i):
i += len(self.data) // 2
ret = self.data[i]
while i > 0:
i //= 2
ret = self.segfun(ret, self.data[i])
return ret
N, D, A = map(int,readline().split())
X = [list(map(int,readline().split())) for _ in range(N)]
X.sort()
L = [0]*N
for i in range(N):
L[i] = X[i][0]
S = SegmentTree(N,0,lambda a, b: a+b)
ans = 0
for i,[x,h] in enumerate(X):
H = h - S.query(i)
if H<=0:
continue
ind = bisect.bisect(L,x+2*D)
need = (H-1)//A + 1
S.update(i,ind,need*A)
ans += need
print(ans)
return
if __name__ == '__main__':
main()
|
n = int(input())
c0 = 0
c1 = 0
c2 = 0
c3 = 0
for i in range(n):
c = input()
if c == 'AC':
c0 += 1
elif c == 'WA':
c1 += 1
elif c == 'TLE':
c2 += 1
else:
c3 += 1
print(f'AC x {c0}')
print(f'WA x {c1}')
print(f'TLE x {c2}')
print(f'RE x {c3}')
| 0 | null | 45,290,453,100,840 | 230 | 109 |
# coding: utf-8
# ????´¢????±? W
target_word = input()
# ??????
words = []
while (1):
input_text = input().strip()
if (input_text == 'END_OF_TEXT'):
break
words.extend(input_text.split())
counter = 0
for w in words:
if (w.lower() == target_word.lower()):
counter += 1
print(counter)
|
target_word = raw_input()
text = ''
while True:
raw = raw_input()
if raw == "END_OF_TEXT":
break
text += raw.strip('.') + ' '
ans = 0
for word in text.lower().split():
if word == target_word:
ans += 1
print(ans)
| 1 | 1,841,227,062,272 | null | 65 | 65 |
# import string
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
h=int(input())
w=int(input())
n=int(input())
v=max(h,w)
cnt=0
while n>0:
n-=v
cnt+=1
print(cnt)
resolve()
|
'''
参考
https://www.hamayanhamayan.com/entry/2019/12/29/032305
https://qiita.com/c-yan/items/4724d67c171d82a2366a
パターン1：A,Bともに偶数またはA,Bともに奇数の場合
⇒そのままお互いに近づく…(B-A)/2
パターン2：A,Bのいずれかが奇数の場合
⇒左端（Aに近いほう）か、右端（Bに近いほう）のいずれかで1ターン待機後、お互いに近づく
'''
N, A, B = map(int, input().split())
def approach(x, y):
return (B-A)//2
ans = 0
if A % 2 == B % 2:
ans = approach(A, B)
else:
if A <= (N-B):
ans += A
A = 1
B -= ans
else:
ans += N - B + 1
B = N
A += ans
ans += approach(A, B)
print(ans)
| 0 | null | 99,096,212,079,500 | 236 | 253 |
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
X = I()
print((X // 500) * 1000 + ((X - ((X // 500) * 500)) // 5) * 5)
|
import math
def fact(n):
ans = 1
for i in range(2, n+1):
ans*= i
return ans
def comb(n, c):
return fact(n)//(fact(n-c)*c)
r = float(input())
print("%.20f"%(2.0*math.pi*r))
| 0 | null | 36,975,627,835,170 | 185 | 167 |
# 解説見た
n,k = map(int,input().split())
lr = [list(map(int,input().split())) for _ in range(k)]
dp = [0]*(n+1)
sdp = [0]*(n+1)
dp[1],sdp[1] = 1,1
mod = 998244353
for i in range(1,n+1):
for l,r in lr:
if i-l<0:
continue
else:
dp[i] += sdp[i-l] - sdp[max(0,i-r-1)]
sdp[i] = sdp[i-1] + dp[i]
dp[i] %= mod
sdp[i] %= mod
print(dp[-1])
|
import math
H = int(input())
print(2 ** (int(math.log(H, 2)) + 1 ) - 1)
| 0 | null | 41,586,706,986,748 | 74 | 228 |
n, m = map(int, input().split())
a = []
b = []
c = []
for i in range(n):
a.append(list(map(int, input().split())))
for i in range(m):
b.append(int(input()))
for i in range(n):
elm = 0
for k in range(m):
elm += a[i][k] * b[k]
c.append(elm)
for i in c:
print(i)
|
n, m = [int(_) for _ in input().split()]
a = []
for _ in range(n):
a.append([int(_) for _ in input().split()])
b = []
for _ in range(m):
b.append(int(input()))
for ai in a:
print(sum([a_c * b_c for a_c, b_c in zip(ai, b)]))
| 1 | 1,167,960,453,710 | null | 56 | 56 |
def main():
n, p = map(int, input().split())
s = input()
mu = [None]*n
ans = 0
c = [0]*p
if 10%p == 0:
ss = map(int, s)
ss = list(ss)
for i in range(n):
if ss[i]%p == 0:
ans += i+1
print(ans)
return
sr = s[::-1]
ssr = map(int, sr)
tens = 1
v = 0
for i, si in enumerate(ssr):
v = (v + (si%p)*tens)%p
mu[i] = v
c[v] += 1
tens *= 10
tens %= p
c[0] += 1
for i in c:
if i:
ans += ((i-1)*i)//2
print(ans)
if __name__ == "__main__":
main()
|
from collections import defaultdict
N, P = map(int,input().split())
S = input()
if P==5:
ans = 0
for i,m in enumerate(S):
if m == '5' or m == '0':
ans += i+1
elif P==2:
ans = 0
for i,m in enumerate(S):
if int(m) % 2 ==0:
ans += i+1
else:
S = S[::-1]
primdic = defaultdict(int)
before = 0
for i in range(0,N):
now = (int(S[i])*pow(10,i,P)+before)%P
primdic[now] += 1
before = now
# 文字なしの時はあまり0なので
primdic[0] += 1
ans = 0
for value in primdic.values():
ans += value*(value-1)//2
print(ans)
| 1 | 58,140,801,116,512 | null | 205 | 205 |
while True:
m,f,r = map(int,input().split())
score = ""
if(m == -1 and f == -1 and r == -1): break
if(m == -1 or f == -1): score = "F"
elif(m+f >= 80): score = "A"
elif(m+f >= 65): score = "B"
elif(m+f >= 50): score = "C"
elif(m+f >= 30):
if(r >= 50): score = "C"
else: score = "D"
else:
score = "F"
print(score)
|
n=int(input())
dp=[0]*(10**5+1)
dp[100]=1
dp[101]=1
dp[102]=1
dp[103]=1
dp[104]=1
dp[105]=1
for i in range(106,10**5+1):
if dp[i-100]==1:
dp[i]=1
elif dp[i-101]==1:
dp[i]=1
elif dp[i-102]==1:
dp[i]=1
elif dp[i-103]==1:
dp[i]=1
elif dp[i-104]==1:
dp[i]=1
elif dp[i-105]==1:
dp[i]=1
print(dp[n])
| 0 | null | 63,869,617,130,710 | 57 | 266 |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N, M, L = getNM()
edges = [getList() for i in range(M)]
Q = getN()
query = [getList() for i in range(Q)]
dist = [[float('inf')] * N for i in range(N)]
for i in range(N):
dist[i][i] = 0
for i in range(M):
a, b, c = edges[i]
dist[a - 1][b - 1] = c
dist[b - 1][a - 1] = c
def warshall_floyd(dist):
for k in range(N):
# i:start j:goal k:中間地点でループ回す
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
return dist
# まず一回回す
warshall_floyd(dist)
# distの抽象化
# edgesの張り替え
dist_alta = [[float('inf')] * N for i in range(N)]
for i in range(N):
for j in range(i, N):
if i == j:
dist_alta[i][j] = 0
continue
if dist[i][j] <= L:
dist_alta[i][j] = 1
dist_alta[j][i] = 1
warshall_floyd(dist_alta)
for s, t in query:
if dist_alta[s - 1][t - 1] == float('inf'):
print(-1)
continue
print(dist_alta[s - 1][t - 1] - 1)
|
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, M, L = map(int, readline().split())
G = [[INF] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, readline().split())
G[a - 1][b - 1] = G[b - 1][a - 1] = c
for i in range(N):
G[i][i] = 0
Q, *ST = map(int, read().split())
for k in range(N):
for i in range(N):
for j in range(N):
if G[i][j] > G[i][k] + G[k][j]:
G[i][j] = G[i][k] + G[k][j]
H = [[INF] * N for _ in range(N)]
for i in range(N - 1):
for j in range(i + 1, N):
if G[i][j] <= L:
H[i][j] = H[j][i] = 1
for i in range(N):
H[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
if H[i][j] > H[i][k] + H[k][j]:
H[i][j] = H[i][k] + H[k][j]
ans = [0] * Q
for i, (s, t) in enumerate(zip(*[iter(ST)] * 2)):
s -= 1
t -= 1
if H[s][t] == INF:
ans[i] = -1
else:
ans[i] = H[s][t] - 1
print(*ans, sep='\n')
return
if __name__ == '__main__':
main()
| 1 | 173,647,836,102,950 | null | 295 | 295 |
A,B = map(int, input().split())
A1,B1 = str(A), str(B)
A2 = int(str(A)*B)
B2 = int(str(B)*A)
if A2 >= B2:
print(A2)
else:
print(B2)
|
def sum_dict(d):
num = 0
for k, v in d.items():
num += k * v
return num
def create_dict(A):
d = {}
for a in A:
if d.get(a) is None:
d[a] = 1
else:
d[a] += 1
return d
if __name__ == "__main__":
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
BC = []
for i in range(Q):
BC.append(tuple(map(int, input().split())))
d = create_dict(A)
ans = sum_dict(d)
for b, c in BC:
db = d.get(b)
if db is None:
db = 0
if d.get(c) is None:
d[c] = 0
d[c] += db
d[b] = 0
ans += (c - b) * db
print(ans)
| 0 | null | 48,172,644,588,098 | 232 | 122 |
n,k = map(int, input().split())
num = []
for i in range(k):
d = int(input())
num += list(map(int, input().split()))
Q = list(set(num))
print(n-len(Q))
|
x, k, d = map(int, input().split())
x = abs(x)
kk = x // d
amari = x % d
if kk >= k:
ans = (kk - k) * d + amari
elif (k - kk) % 2 == 1:
ans = abs(amari - d)
else:
ans = amari
print(ans)
| 0 | null | 14,876,602,970,140 | 154 | 92 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
X = sorted([a for a in A if a >= 0])
Y = sorted([a for a in A if a < 0], key=lambda x: abs(x))
ans = 1
if 2 * (min(K, len(Y)) // 2) + len(X) >= K:
if K % 2 == 1:
ans *= X.pop()
K -= 1
XX = [(x1 * x2) for x1, x2 in zip(*[iter(X[::-1])] * 2)]
YY = [(y1 * y2) for y1, y2 in zip(*[iter(Y[::-1])] * 2)]
ZZ = sorted(XX + YY)
for i in range(K // 2):
ans *= ZZ.pop()
ans %= MOD
else:
Z = sorted(X + Y, key=lambda x: abs(x), reverse=True)
for i in range(K):
ans *= Z.pop()
ans %= MOD
print(ans)
|
import math
while True:
try:
a =map(int,raw_input().split())
b = a[0] + a[1]
print len(str(a[0]+a[1]))
except EOFError:
break
| 0 | null | 4,735,766,765,440 | 112 | 3 |
n,a,b=map(int,input().split())
s=n//(a+b)
w=n%(a+b)
if w<=a:
print(s*a+w)
else:
print(s*a+a)
|
n, a, b = map(int, input().split())
q = n // (a + b)
mod = n % (a + b)
if mod > a:
remain = a
else:
remain = mod
print(q * a + remain)
| 1 | 55,501,831,219,858 | null | 202 | 202 |
import sys
def f(x):
p=0
cnt=0
for i in range(n-1,-1,-1):
while p<n and a[i]+a[p]<x:
p+=1
cnt+=n-p
return cnt
n,m=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
l,r=a[0]*2,a[n-1]*2
while True:
if r-l<=1:
if f(r)==m: md=r;break
else: md=l;break
md=(r+l)//2
k=f(md)
if k==m: break
elif k>m: l=md
else: r=md
p=0
cnt=0
ans=0
for q in range(n-1,-1,-1):
while p<n and a[q]+a[p]<=md:
p+=1
if p==n: break
cnt+=n-p
ans+=a[q]*(n-p)*2
ans+=(m-cnt)*md
print(ans)
|
from numpy import*
n,m,*a=int_(open(0).read().split())
a=int_(fft.irfft(fft.rfft(bincount(a,[1]*n,2**18))**2)+.5)
c=0
for i in where(a>0)[0][::-1]:
t=min(m,a[i])
c+=i*t
m-=t
if m<1:break
print(c)
| 1 | 107,767,821,583,568 | null | 252 | 252 |
A,B,C,K=map(int,input().split())
print(1*min(A,K)-1*max(0,K-A-B))
|
a, b, c, k = map(int, input().split())
if k >= a + b + c:
print(a - c)
exit()
elif k <= a:
print(k)
elif k <= a + b:
print(a)
exit()
else:
print(a - (k - a - b))
exit()
| 1 | 21,752,563,168,480 | null | 148 | 148 |
n = int(input())
AB = [[] * 2 for _ in range(n - 1)]
graph = [[] for _ in range(n + 1)]
for i in range(n - 1):
a, b = map(int, input().split())
AB[i].append(a)
AB[i].append(b)
graph[a].append(b)
graph[b].append(a)
root = 1
parent = [0] * (n + 1)
order = []
stack = [root] # 根を stack に入れる
while stack:
x = stack.pop()
order.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
color = [-1] * (n + 1)
for x in order:
ng = color[x]
c = 1
for y in graph[x]:
if y == parent[x]:
continue
if c == ng:
c += 1
color[y] = c
c += 1
res = []
for a, b in AB:
if parent[a] == b:
res.append(color[a])
else:
res.append(color[b])
print(max(res)) # root
print('\n'.join(map(str, res)))
|
from collections import deque
import sys
sys.setrecursionlimit(10**9)
N = int(input())
to = [[] for _ in range(N)]
order = []
for _ in range(N - 1):
a, b = list(map(lambda x:int(x) - 1, input().split()))
to[a].append(b)
to[b].append(a)
order.append(b)
def solve():
dist = [-1] * N
# 頂点iに向かう辺をiとする
color = [0] * N
dist[0] = 0
color[0] = 0
que = deque([0])
while que:
v = que.popleft()
used_color = [color[v]]
next_color = 1
for nv in to[v]:
if dist[nv] == -1:
dist[nv] = dist[v] + 1
while next_color in used_color:
next_color += 1
color[nv] = next_color
used_color.append(next_color)
que.append(nv)
print(len(set(color[1:])))
for i in range(N - 1):
print(color[order[i]])
if __name__ == "__main__":
solve()
| 1 | 136,164,824,863,002 | null | 272 | 272 |
c = input()
cl =[chr(ord("a")+i) for i in range(26)]
print(cl[cl.index(c)+1])
|
N,K= map(int, input().split())
p = 10**9+7
f=[1]
for i in range(1,N+1):
f.append(f[-1]*i % p)
def nCk(n,k):
return f[n]*pow(f[n-k], p-2, p)*pow(f[k], p-2, p)
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(N-K+1):
ans -= (a[i] * nCk(N-i-1, K-1)) % p
ans += (a[N-i-1] * nCk(N-i-1, K-1)) % p
print(ans % p)
| 0 | null | 94,355,094,843,410 | 239 | 242 |
#!/usr/bin/env python3
def main():
N, M = map(int, input().split())
A = [int(x) for x in input().split()]
if N >= sum(A):
print(N - sum(A))
else:
print(-1)
if __name__ == '__main__':
main()
|
n,m = map(int,input().split())
a = map(int,input().split())
s = 0
for i in a:
s += i
if n-s >=0:
print(n-s)
else:
print(-1)
| 1 | 32,126,191,766,802 | null | 168 | 168 |
# f=open('in','r')
# input=lambda:f.readline().strip()
n=int(input())
r=list(map(int,input().split()))
mod=1000000007
s=sum(r)%mod
x=0
for u in r:
x+=u**2
x%=mod
t=500000004
print((s**2-x)*t%mod)
|
N = int(input())
A = [int(i) for i in input().split()]
S = []
e = 0
for i in A:
e += i
S.append(e)
ans = 0
for i in range(N-1):
ans += A[i]%(10**9+7)*((S[N-1] - S[i])%(10**9+7))
print(ans%(10**9+7))
| 1 | 3,840,556,700,708 | null | 83 | 83 |
n, k = map(int, input().split())
prime_mod = 10**9+7
countgcd = [0]*k
for idx in range(k, 0, -1):
num_multiples = k//idx
num_sequences = pow(num_multiples, n, prime_mod)
overcount = sum(countgcd[j*idx-1] for j in range(2, num_multiples+1))
overcount = overcount%prime_mod
countgcd[idx-1] = (num_sequences-overcount)%prime_mod
# print(idx, num_multiples, num_sequences, overcount, num_sequences-overcount)
final_sum = 0
for idx in range(1, k+1):
final_sum = (final_sum + idx*countgcd[idx-1])%prime_mod
print(final_sum)
|
import bisect
import collections
import functools
import heapq
import math
import sys
from collections import deque
from collections import defaultdict
input = sys.stdin.readline
MOD = 10**9+7
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n):
return kaijo_memo[n]
if(len(kaijo_memo) == 0):
kaijo_memo.append(1)
while(len(kaijo_memo) <= n):
kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n):
return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0):
gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n):
gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if(n == r):
return 1
if(n < r or r < 0):
return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
N,K = map(int,(input().split()))
a = list(map(int,(input().split())))
a.sort()
ans = 0
for i in range(1,N-K+2):
ans += (a[-i] - a[i-1]) * nCr(N-i,K-1)
ans %= MOD
print(ans)
| 0 | null | 66,358,436,904,396 | 176 | 242 |
import sys
input = sys.stdin.readline
n,m=map(int,input().split())
d={i+1:[] for i in range(n)}
for i in range(m):
x,y=map(int,input().split())
d[x].append(y)
d[y].append(x)
visit=set()
ans= 0
for i in range(1,n+1):
if i not in visit:
ans+=1
stack = [i]
while stack:
c=stack.pop()
visit.add(c)
for i in d[c]:
if i not in visit:
stack.append(i)
print(ans-1)
|
N,K = map(int,input().split())
A = sorted(list(map(int,input().split())))
mod = 10**9+7
ans = 1
mi = []
pl = []
for a in A:
if a < 0:
mi.append(a)
else:
pl.append(a)
if N == K:
for a in A:
ans *= a
ans %= mod
print(ans)
exit()
if pl == []:
if K%2:
for k in range(K):
ans *= mi[-1-k]
ans %= mod
else:
for k in range(K):
ans *= mi[k]
ans %= mod
print(ans)
exit()
pl = pl[::-1]
ip = 0
im = 0
if K % 2:
ans = pl[0]
ip += 1
K -= 1
while K > 0:
check = True
if ip + 2 <= len(pl):
x = pl[ip]*pl[ip+1]
else:
x = 1
if im + 2 <= len(mi):
y = mi[im]*mi[im+1]
else:
check = False
y = 1
if x >= y or check == False:
ans *= x
ans %= mod
ip += 2
else:
ans *= y
ans %= mod
im += 2
K -= 2
print(ans)
| 0 | null | 5,865,259,689,620 | 70 | 112 |
while True:
n = list(map(int,input()))
if n[0] ==0:
break
else:
print(sum(n))
|
# coding: utf-8
import sys
ans = []
while ( 1 ):
strings = input()
if (len(strings) == 1 and int(strings[0]) == 0):
break
ans = 0
for s in strings:
ans += int(s)
print(ans)
| 1 | 1,611,570,002,518 | null | 62 | 62 |
N, A, B = [int(x) for x in input().split()]
n = N//(A+B)
ans = n * A
d = N - n*(A+B)
if d >= A:
ans += A
else:
ans += d
print(ans)
|
list=list(map(int,input().split()))
if list[0]%(list[1]+list[2])==0:
print((list[0]//(list[1]+list[2]))*list[1])
elif list[0]%(list[1]+list[2])<=list[1]:
print((list[0]//(list[1]+list[2]))*list[1]+list[0]%(list[1]+list[2]))
else:
print(list[0]//(list[1]+list[2])*list[1]+list[1])
| 1 | 55,581,300,426,080 | null | 202 | 202 |
n = int(input())
xpy = []
xmy = []
for i in range(n):
x,y = map(int,input().split())
xpy.append(x+y)
xmy.append(x-y)
xpy.sort()
xmy.sort()
print(max(abs(xpy[0]-xpy[-1]),abs(xmy[0]-xmy[-1])))
|
import sys
def input():
return sys.stdin.readline()[:-1]
N = int(input())
plus = []
minus = []
for _ in range(N):
x, y = map(int, input().split())
plus.append(x+y)
minus.append(x-y)
print(max(max(plus)-min(plus), max(minus)-min(minus)))
| 1 | 3,423,613,588,672 | null | 80 | 80 |
s=input()
l=[ "SUN","MON","TUE","WED","THU","FRI","SAT"]
ind=l.index(s)
if ind==0:
print(7)
else:
print(7-ind)
|
n = int(input())
a = list(map(int,input().split()))
m = 1000
stocks = 0
drops = [False]*(n-1)
for i in range(n-1):
if a[i] > a[i+1]:
drops[i] = True
for i in range(n-1):
if drops[i]:
m+=stocks*a[i]
stocks = 0
else:
stocks+=m//a[i]
m -= (m//a[i])*a[i]
print(m + stocks*a[-1])
| 0 | null | 70,536,211,212,948 | 270 | 103 |
N = int(input())
S = list(input())
Q = int(input())
alphabet = "abcdefghijklmnopqrstuvwxyz"
num = dict()
for i, var in enumerate(alphabet):
num[var] = i
class Bit():
def __init__(self, N):
self.__N = N
self.__arr = [[0] * 26 for _ in range(1 + N)]
def add_(self, x, a, i):
while(x < self.__N + 1):
self.__arr[x][i] += a
x += x & -x
def sum_(self, x, i):
res = 0
while(x > 0):
res += self.__arr[x][i]
x -= x & -x
return res
def sub_sum_(self, x, y, i):
return self.sum_(y, i) - self.sum_(x, i)
Bit = Bit(N)
for i, var in enumerate(S):
Bit.add_(i+1, 1, num[var])
for i in range(Q):
q, l, r = input().split()
l = int(l)
if q == "1" and r != S[l-1]:
temp = S[l-1]
S[l-1] = r
Bit.add_(l, -1, num[temp])
Bit.add_(l, 1, num[r])
elif q == "2":
r = int(r)
res = 0
for j in range(26):
res += min(1, Bit.sub_sum_(l-1, r, j))
print(res)
|
n,k = map(int,input().split())
r,s,p = map(int,input().split())
points = {'r':r, 's':s, 'p':p}
hands = {'r':'p', 's':'r', 'p':'s'}
t = list(input())
rpsList = ['']*n
ans = 0
for i,hand in enumerate(t):
rpsList[i] += hands[hand]
if i>=k and rpsList[i]==rpsList[i-k]:
last_hand= rpsList[i-k]
next_hand = hands[t[i+k]] if i+k<n else ''
for j in ['r','s','p']:
if j!=last_hand and j!=next_hand:
rpsList[i] = j
else:
ans += points[hands[hand]]
print(ans)
| 0 | null | 84,595,184,680,642 | 210 | 251 |
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
@functools.lru_cache(None)
def aa(k):
if k > 1: return 2*aa(k//2) + 1
return 1
h = int(stdin.readline().rstrip())
print(aa(h))
|
def solve(n):
if n is 0:
return 0
return 1 + 2 * solve(n // 2)
print(solve(int(input())))
| 1 | 80,217,814,923,788 | null | 228 | 228 |
from functools import reduce
n,a,b=map(int,input().split())
mod=10**9+7
def nCk(n,k):
c=reduce(lambda x,y: x*y%mod, range(n,n-k,-1))
m=reduce(lambda x,y: x*y%mod, range(1,k+1))
return c*pow(m,mod-2,mod)%mod
all=pow(2,n,mod)
nCa=nCk(n,a)
nCb=nCk(n,b)
print((all-nCa-nCb-1)%mod)
|
N = int(input())
a = [int(x) for x in input().split()]
def selectionSort(A, N):
count = 0
for i in range(0,N):
minj = i
for j in range(i,N):
if A[minj] > A[j]:
minj = j
if i != minj:
tmp = A[minj]
A[minj] = A[i]
A[i] = tmp
count += 1
return A,count
ans,c = selectionSort(a,N)
print(*ans)
print(c)
| 0 | null | 33,008,334,387,060 | 214 | 15 |
k = int(input())
if k%2==0 or k%5==0:
print(-1)
else:
ans = 1
res = 7
while True:
if res%k == 0:
print(ans)
break
res = res*10+7
res %= k
ans += 1
|
import sys
import numpy as np # noqa
import numba # noqa
from numba import njit, b1, i4, i8, f8 # noqa
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
@njit((i8, ), cache=True)
def main(K):
for i in range(K):
if i == 0:
a = 7 % K
else:
a = (a * 10 + 7) % K
if a == 0:
return i + 1
return -1
K = int(readline())
print(main(K))
| 1 | 6,108,619,282,876 | null | 97 | 97 |
def main():
n, m = map(int, input().split())
rev = input()[::-1]
ans = []
cur = nxt = 0
while cur < n:
for i in range(cur + 1, cur + m + 1):
if i==n:
nxt = i
break
if rev[i]=="0":
nxt = i
if cur==nxt:
print(-1)
exit()
ans += [str(nxt - cur)]
cur = nxt
print(" ".join(ans[::-1]))
if __name__=="__main__":
main()
|
N,M=map(int, input().split())
S=list(input())
T=S[::-1]
D=[0]*N
if N<=M:
print(N)
exit()
renzoku,ma=0,0
for i in range(1,N+1):
if S[i]=='1':
renzoku+=1
else:
ma=max(ma,renzoku)
renzoku=0
if ma>=M:
print(-1)
exit()
r=0
for i in range(1,M+1):
if T[i]!='1':
r=i
ans=[r]
while r+M<N:
for i in range(M,0,-1):
if T[r+i]=='0':
ans.append(i)
r+=i
break
ans.append(N-r)
print(*ans[::-1])
| 1 | 139,482,445,015,892 | null | 274 | 274 |
import math
A = []
N = int(input())
count = 0
for n in range(N):
x = int(input())
if x == 2:
A.append(x)
count += 1
elif x % 2 == 0:
pass
elif x > 2:
for i in range(3, int(math.sqrt(x))+2, 2):
if x % i == 0:
break
else:
count += 1
A.append(x)
print(count)
|
import math
cnt = 0
for i in range(int(input())):
x = int(input())
flg = False # なんらかの数で割り切れるかどうか
if x == 1:
continue
if x == 2:
cnt += 1
continue
for k in range(2, math.floor(math.sqrt(x))+1):
if not(x % k):
flg = True
break
if not flg:
cnt += 1
print(cnt)
| 1 | 10,466,930,768 | null | 12 | 12 |
import sys
input = sys.stdin.readline
def main():
N = int(input())
A = list(map(int, input().split()))
node_count = [0] * (N+1)
for i, a in enumerate(A[::-1]):
if i == 0:
node_count[N] = a
continue
node_count[N-i] = node_count[N-i+1] + a
can_build = True
for i, a in enumerate(A):
if i == 0:
if N > 0 and a > 0:
can_build = False
break
if N == 0 and a > 1:
can_build = False
break
node_count[0] = min(node_count[0], 1)
continue
if (i < N and a >= node_count[i-1]*2) or (i == N and a > node_count[i-1]*2):
can_build = False
break
node_count[i] = min(node_count[i], node_count[i-1]*2-A[i-1]*2)
if can_build:
ans = sum(node_count)
else:
ans = -1
print(ans)
if __name__ == "__main__":
main()
|
def main():
n = int(input()) + 1
a = [int(x) for x in input().split()]
q = [0] * n
for i in range(n):
q[i] = (q[i - 1] - a[i - 1]) * 2 if i != 0 else 1
# print(q[i])
if q[i] <= 0:
print(-1)
return
if q[n - 1] < a[n - 1]:
print(-1)
return
q[n - 1] = a[n - 1]
s = q[n - 1]
# print('--')
# print(q[n - 1])
for i in range(n - 2, -1, -1):
q[i] = min(q[i], q[i + 1] + a[i])
if q[i] == 0:
print(-1)
return
# print(q[i])
s += q[i]
print(s)
main()
| 1 | 19,013,152,652,800 | null | 141 | 141 |
class dictionary:
def __init__(self):
self._d = set()
def insert(self, s):
self._d.add(s)
def find(self, s):
if s in self._d:
print("yes")
else:
print("no")
if __name__ == '__main__':
dd = dictionary()
n = int(input())
for _ in range(n):
args = input().split()
if args[0] == "insert":
dd.insert(args[1])
elif args[0] == "find":
dd.find(args[1])
|
n = int(input())
order = [''] * n
st = [''] * n
for i in range(n):
order[i], st[i] = map(str, input().split())
dic = {}
for i in range(n):
if order[i] == 'insert':
dic.setdefault(st[i], 0)
else:
if st[i] in dic:
print('yes')
else:
print('no')
| 1 | 76,956,730,240 | null | 23 | 23 |
N = int(input())
if N % 1000 != 0:
print(1000 - N % 1000)
elif N % 1000 == 0:
print(0)
|
l=list(map(int,input().split()))
a=l[0]
b=l[1]
if(a>9 or a<1 or b>9 or b<1):
print(-1)
else:
print(a*b)
| 0 | null | 83,105,053,629,724 | 108 | 286 |
X = int(input())
happy = X // 500 * 1000
happy += X % 500 // 5 * 5
print(happy)
|
index = int(input())
liststr = '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'
list = liststr.split(',')
print(int(list[index-1]))
| 0 | null | 46,400,915,032,274 | 185 | 195 |
h, w, k = list(map(int, input().split()))
choco = [list(map(int, list(input()) )) for i in range(h)]
choco_cumsum = [[0 for i in range(w)] for j in range(h)]
for i in range(h):
choco_cumsum[i][0] = choco[i][0]
for j in range(1, w):
choco_cumsum[i][j] = choco_cumsum[i][j-1] + choco[i][j]
ans = h + w + 1
for h_cut in range(2**(h-1)):
# 上位ビットが上側。1が切る、0が切らない
num_cut_init = bin(h_cut).count("1") # 立っているビットの個数
num_cut = num_cut_init
w_last_cot_pos = -1
valid = True
temp_list = [0] * (num_cut_init + 1)
temp_dict = {}
idx = 0
temp_dict[0] = idx
for i in range(1, h):
# print('idx', 2 ** (-i+h-1) )
if h_cut & (2 ** (-i+h-1) ):
idx += 1
# idx += h_cut & (2 ** (h-1) - i)
temp_dict[i] = idx
# print(temp_dict)
iw = 0
while iw < w:
for ih in range(h):
temp_list[temp_dict[ih]] += choco[ih][iw]
# print(iw, temp_list)
condition = max(temp_list) > k
if condition:
if w_last_cot_pos < iw-1:
# もしそこで切ってkを超えるなら、その手前で切る
num_cut += 1
w_last_cot_pos = iw - 1
temp_list = [0] * (num_cut_init + 1)
# print('iw: ', iw, 'last: ', w_last_cot_pos)
else:
# 1つしか動かしてない場合は土台無理なので次のh_cutに
valid = False
break
else:
iw += 1
if valid:
ans = min(ans, num_cut)
# print(num_cut)
print(ans)
|
def main():
x = int(input())
total = 100
for i in range(10**5):
if total >= x:
print(i)
return
total += total//100
if __name__ == "__main__":
main()
| 0 | null | 37,653,112,212,220 | 193 | 159 |
def main():
N = int(input())
d = dict()
for i in range(1, N+1):
u = int(str(i)[0])
v = int(str(i)[-1])
d[(u, v)] = d.get((u, v), 0) + 1
ans = 0
for u, v in d:
if (v, u) in d:
ans += d[(u, v)] * d[(v, u)]
return ans
if __name__ == '__main__':
print(main())
|
n = int(input())
aaa = [[0 for i in range(10)] for j in range(10)]
for i in range(1, n+1):
aaa[int(str(i)[0])][i%10] += 1
ans = 0
for i in range(1, 10):
for j in range(1, 10):
ans += aaa[i][j]*aaa[j][i]
print(ans)
| 1 | 86,783,175,533,320 | null | 234 | 234 |
import sys
n, k = map(int, input().split())
mod = 998244353
dp = [0] * (n+1)
dp[1] = 1
r = [tuple(map(int, input().split())) for _ in range(k)]
s = [0 for _ in range(k)]
for i in range(2, n + 1):
sums = 0
for j in range(k):
s[j] += dp[max(0, i - r[j][0])] - dp[max(0, i - r[j][1] - 1)]
s[j] %= mod
sums = (sums + s[j]) % mod
dp[i] = sums
print(dp[n])
|
import numpy as np
from numba import njit
from numba.types import i8
ni8 = np.int64
MOD = 998244353
@njit((i8[:,::-1], i8[:], i8, i8), cache=True)
def solve(lr, dp, n, k):
acc_dp = np.ones_like(dp)
for i in range(1, n):
val = 0
for j in range(k):
a = i - lr[j, 0]
if a < 0:
continue
b = i - lr[j, 1] - 1
val += acc_dp[a] - (acc_dp[b] if b >= 0 else 0)
dp[i] = val % MOD
acc_dp[i] = (acc_dp[i - 1] + dp[i]) % MOD
return dp[n - 1]
def main():
f = open(0)
n, k = [int(x) for x in f.readline().split()]
lr = np.fromstring(f.read(), ni8, sep=' ').reshape((-1, 2))
dp = np.zeros(n, ni8)
dp[0] = 1
ans = solve(lr, dp, n, k)
print(ans)
main()
| 1 | 2,687,156,264,882 | null | 74 | 74 |
cnt = 0
a, b, c = map(int, input().split())
if (a >= 1 and a <= 10000) and (b >= 1 and b <= 10000) and (c >= 1 and c <= 10000):
if a <= b:
for i in range(a, b+1):
if c % i == 0:
cnt += 1
print("{0}".format(str(cnt)))
else:
pass
else:
pass
|
def main():
n = int(input())
d = set([])
for i in range(n):
command, string = input().split()
if (command == 'insert'):
d.add(string)
elif (command == 'find'):
if string in d:
print('yes')
else:
print('no')
if __name__ == "__main__":
main()
| 0 | null | 315,958,581,038 | 44 | 23 |
N = int(input())
n = N%10
honList = [2, 4, 5, 7, 9]
ponList = [0, 1, 6, 8]
if n in honList:
print('hon')
elif n in ponList:
print('pon')
else :
print('bon')
|
n = int(input())
a = 100
time = 0
while a < n:
a += a // 100
time += 1
print(time)
| 0 | null | 23,189,470,284,298 | 142 | 159 |
a,b=input().split()
ans=int(a)*round(float(b)*100)//100
print(int(ans))
|
from collections import deque
N = int(input())
L = deque()
for i in range(N):
C= input().split()
if C[0] == "insert":
L.appendleft(C[1])
elif C[0] == "delete":
try:
L.remove(C[1])
except ValueError:
pass
elif C[0] == "deleteFirst":
L.popleft()
elif C[0] == "deleteLast":
L.pop()
print(" ".join(L))
| 0 | null | 8,216,617,855,798 | 135 | 20 |
import itertools,numpy as np,sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
A = LI()
sum_A = sum(A)
accumulate_A = np.array(list(itertools.accumulate(A)))
sub_A1 = sum_A-accumulate_A
sub_A2 = sum_A-sub_A1
print(np.abs(sub_A1-sub_A2).min())
|
n=int(input())
a=list(map(int,input().split()))
ans=10**20
p=sum(a)
q=0
for i in range(n-1):
q+=a[i]
ans=min(ans,abs(p-q-q))
print(ans)
| 1 | 141,540,913,856,428 | null | 276 | 276 |
import numpy as np
N = int(input())
X = [[] for _ in range(N)]
L = [[] for _ in range(N)]
for i in range(N):
X[i], L[i] = map(int, input().split())
def indexSort(L):
D = dict(zip(range(len(L)), L))
E = sorted(D.items(), key=lambda x: x[1])
F = [e[0] for e in E]
return F
L1 = [x-l for x, l in zip(X, L)]
L2 = [x+l for x, l in zip(X, L)]
Ind = np.argsort(L2)
Remain = [Ind[0]]
i = 0
while i < len(Ind)-1:
now = Remain[-1]
After = Ind[i+1:]
skip = 0
for after in After:
if L2[now] > L1[after]:
# print(L2[now], L1[after])
skip += 1
else:
# print(after)
Remain.append(after)
break
i += 1 + skip
print(len(Remain))
|
import sys
if __name__ == "__main__":
for i in sys.stdin:
a,b = list(map(int,i.strip().split()))
print(len(str(a+b)))
| 0 | null | 44,939,609,399,652 | 237 | 3 |
debt = 100000.0
a = int(input())
for i in range(a):
debt = debt * 1.05
if(debt % 1000):
debt = (debt // 1000) * 1000 + 1000
print(int(debt))
|
n = int(input())
list = [[0 for i in range(10)] for j in range(12)]
for i in range(n):
b,f,r,v = map(int,input().split())
list[3*(b - 1)+(f - 1)][r - 1] += v
for i in range(12):
if i % 3 == 0 and i != 0:
print('####################')
for j in range(10):
print(' {}'.format(list[i][j]),end = "")
if j == 9:
print('')
| 0 | null | 544,580,731,420 | 6 | 55 |
#!/usr/bin/env python3
s = input()
n = len(s)
t = s[:(n - 1) // 2]
u = s[(n + 1) // 2:]
print("YNeos"[any([s != s[::-1], t != t[::-1], u != u[::-1]])::2])
|
input()
A = [int(i) for i in input().split()]
c = 0
def bubble_sort(A):
global c
flag = True
while flag:
flag = False
for i in range(len(A)-1, 0, -1):
if A[i] < A[i -1]:
A[i], A[i -1] = A[i -1], A[i]
c += 1
flag = True
bubble_sort(A)
print(*A)
print(c)
| 0 | null | 22,977,442,501,960 | 190 | 14 |
N=int(input())
f=[0]*10000
for i in range(100):
for j in range(100):
for k in range(100):
n=(i+1)**2+(j+1)**2+(k+1)**2+(i+1)*(j+1)+(j+1)*(k+1)+(k+1)*(i+1)
if n<=10000:
f[n-1]+=1
for i in range(N):
print(f[i])
|
import math
n=int(input())
num=int(math.sqrt(n))
ans=[0]*(n+1)
for i in range(1,num+1):
for j in range(1,num+1):
for k in range(1,num+1):
v=i*i+j*j+k*k+i*j+i*k+j*k
if v<=n:
ans[v]+=1
for i in range(n):
print(ans[i+1])
| 1 | 8,023,597,893,828 | null | 106 | 106 |
# -*- coding:UTF-8 -*-
num = input().split()
print(int(num[0]) * int(num[1]), int(num[0])*2 + int(num[1])*2)
|
#coding:utf-8
import sys
ab=sys.stdin.readline()
rect=ab.split( ' ' )
for i in range(2):
rect[i]=int( rect[i])
print( "{} {}".format( rect[0]*rect[1], rect[0]*2+rect[1]*2) )
| 1 | 313,966,718,648 | null | 36 | 36 |
import itertools
H,W,N=[int(s) for s in input().split()]
hls=[0 for _ in range(H+1)]
wls=[0 for _ in range(W+1)]
bombs=[set() for _ in range(H+1)]
for _ in range(N):
h,w=[int(s) for s in input().split()]
hls[h]+=1
wls[w]+=1
bombs[h].add(w)
hmax=max(hls)
wmax=max(wls)
hmaxls=[i for i in range(H+1) if hls[i]==hmax]
wmaxls=[i for i in range(W+1) if wls[i]==wmax]
for h,w in itertools.product(hmaxls,wmaxls):
if not(w in bombs[h]):
print(hmax+wmax)
exit()
else:
print(hmax+wmax-1)
|
# E - Bomber
from collections import Counter
h, w, m = map(int, input().split())
hw = [tuple(map(int, input().split())) for i in range(m)]
ys, xs = zip(*hw)
ymax, = Counter(ys).most_common(1)
xmax, = Counter(xs).most_common(1)
bombed = max(ymax[1], xmax[1])
if bombed < m:
if ymax[1] > xmax[1]:
xs = [b for a, b in hw if a != ymax[0]]
xmax, = Counter(xs).most_common(1)
bombed += xmax[1]
else:
ys = [a for a, b in hw if b != xmax[0]]
ymax, = Counter(ys).most_common(1)
bombed += ymax[1]
print(bombed)
| 1 | 4,680,905,476,082 | null | 89 | 89 |
h, a = map(int, input().split(' '))
for i in range(10001):
if h <= a*i:
print(i)
exit(0)
|
a,b=map(int,input().split())
print((a//b)+1 if a%b!=0 else a//b)
| 1 | 76,606,883,888,002 | null | 225 | 225 |
n, m = map(int, input().split())
ab = []
for i in range (m):
ab.append(list(map(int, input().split())))
par = [-1] * (n+1)
#Union Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
tank = []
while par[x] >= 0:
tank.append(x)
x = par[x]
for elt in tank:
par[elt] = x
return x
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return
for j in range(m):
unite(ab[j][0], ab[j][1])
m = -1*min(par)
print(m)
|
N = int(input())
for x in range(50001):
y = int( x * 1.08 )
if y == N:
print(x)
exit()
print(":(")
| 0 | null | 65,037,153,109,818 | 84 | 265 |
a,b,c,k=[int(x) for x in input().split()]
ans=0
if a<=k:
ans+=a
k-=a
elif k>0:
ans+=k
k=0
if b<=k:
k-=b
elif k>0:
k=0
if k>0:
ans-=k
print(ans)
|
l,r,d=map(int,input().split())
if l%d!=0:
ans=(r//d)-(l//d)
else:
ans=(r//d)-(l//d)+1
print(ans)
| 0 | null | 14,589,682,873,568 | 148 | 104 |
N=int(input())
n500=N//500
n5=(N%500)//5
print(1000*n500+5*n5)
|
N = int(input())
R = [int(input()) for _ in range(N)]
maxv = -2000000000
minv = R[0]
for i in range(1,N):
maxv = max([maxv, R[i] - minv ])
minv = min([minv, R[i]])
print(maxv)
| 0 | null | 21,283,993,783,922 | 185 | 13 |
import collections
h,w,k = [int(x) for x in input().split()]
s = [list(input()) for _ in range(h)]
a = [[0]*w for _ in range(h)]
cnt= 1
for i in range(h):
for j in range(w):
if s[i][j]=="#":
a[i][j]=cnt
cnt+=1
for i in range(h):
for j in range(1,w):
if a[i][j]==0:
a[i][j]=a[i][j-1]
for i in range(h):
for j in range(w-2,-1,-1):
if a[i][j]==0:
a[i][j]=a[i][j+1]
for j in range(w):
for i in range(1,h):
if a[i][j]==0:
a[i][j]=a[i-1][j]
for j in range(w):
for i in range(h-2,-1,-1):
if a[i][j]==0:
a[i][j]=a[i+1][j]
for i in a:
print(*i)
|
def main():
h,w,_ = map(int,input().split())
ls = [list(input()) for _ in range(h)]
check = [False for _ in range(h)]
for i in range(h):
flg = False
for j in range(w):
if ls[i][j] == "#":
flg = True
if flg:
check[i] = True
ans = [[0 for _ in range(w)] for _ in range(h)]
now = 1
for i,flg in enumerate(check):
if flg:
ball = False
for j in range(w):
if ball == True and ls[i][j]=="#":
now +=1
ans[i][j]=now
elif ball == False and ls[i][j]=="#":
ans[i][j]=now
ball = True
else:
ans[i][j]=now
now += 1
else:
pass
for i,flg in enumerate(check):
if flg:
pass
else:
k = i
while 1:
if k == h-1 and check[h-1]==False:
break
if check[k]:
break
else:
k += 1
for j in range(w):
ans[i][j] = ans[k][j]
if check[-1]==False:
index = 0
for i in range(h):
if check[i]==True:
index = i
else:
pass
for i in range(index+1,h):
for j in range(w):
ans[i][j]=ans[index][j]
for i in range(h):
for j in range(w):
print(ans[i][j],end=" ")
print("\n")
if __name__ == "__main__":
main()
| 1 | 143,340,054,158,112 | null | 277 | 277 |
n, m ,l = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]
b = [list(map(int, input().split())) for j 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)
|
a,b,c = list(map(int,input().split(" ")))
div=0
for i in range(a,b+1):
if c % i == 0:
div += 1
print(div)
| 0 | null | 984,752,868,608 | 60 | 44 |
n = int(input())
a = list(map(int, input().split()))
ans = [""]*n
for i in range(n):
x = a[i]
b = ans[a[i] - 1]
c = str(i+1)
ans[a[i]-1] = str(i+1)
print(" ".join(ans))
|
n = int(input())
A = list(map(int, input().split()))
B = [(i+1, A[i]) for i in range(n)]
B.sort(key=lambda x: x[1])
print (" ".join(list(map(str, [B[i][0] for i in range(n)]))))
| 1 | 181,092,556,188,818 | null | 299 | 299 |
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)
|
ri = lambda S: [int(v) for v in S.split()]
def rii(): return ri(input())
a, b = rii()
print(min(str(a) * b, str(b) * a))
| 0 | null | 42,097,089,134,736 | 15 | 232 |
a, b = input().split()
ab = a*int(b)
ba = b*int(a)
if ab <= ba:
print(ab)
else:
print(ba)
|
def resolve():
a,b = map(int,input().split())
A = str(a)*b
B = str(b)*a
print(A if A<B else B)
resolve()
| 1 | 84,550,510,292,520 | null | 232 | 232 |
n = int(input())
ikeru = [[] for _ in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
ikeru[a-1].append((b-1, i))
settansaku = set([])
setmada = {0}
listmada = [(0, None)] #left: Vertex, right: Color
kouho = 1
num = [0 for _ in range(n-1)]
while kouho != 0:
for i, cnt in listmada[:]:
colors = {cnt}
settansaku.add(i)
setmada.remove(i)
listmada.remove((i, cnt))
kouho -= 1
c = 0
for k, j in ikeru[i]:
if not k in setmada:
if not k in settansaku:
setmada.add(k)
while True:
if c not in colors:
listmada.append((k, c))
colors.add(c)
num[j] = c
break
c += 1
kouho += 1
print(max(num)+1)
print("\n".join([str(i+1) for i in num]))
|
import collections
N = int(input())
edges = [[] for _ in range(N)]
for i in range(N-1):
a, b = map(int, input().split())
edges[a-1].append([b-1,i])
edges[b-1].append([a-1,i])
q = collections.deque()
q.append([0,-1,-1])
colors = [0]*(N-1)
while len(q) != 0:
v, color, num = q.popleft()
if colors[num] == 0 and color != -1:
colors[num] = color
next_color = 0
for w in edges[v]:
if colors[w[1]] != 0:
continue
next_color += 1
if next_color == colors[num]:
next_color += 1
q.append([w[0],next_color,w[1]])
print(len(set(colors)))
for i in colors:
print(i)
| 1 | 136,209,740,371,650 | null | 272 | 272 |
N, X, M = map(int, input().split())
tmp = X
seq = []
ans = 0
for i in range(N):
if X in seq:
break
seq.append(X)
X = (X ** 2) % M
ans = sum(seq[:min(N, len(seq))])
N -= len(seq)
if N < 1:
print(ans)
exit()
i = seq.index(X)
l = len(seq) - i
ans += sum(seq[i:]) * (N//l)
N %= l
ans += sum(seq[i:i+N])
print(ans)
|
x=int(input())
c=100
i=0
while True:
i+=1
c=c+c//100
if x<=c:
print(i)
exit()
| 0 | null | 14,969,701,827,080 | 75 | 159 |
n = int(input())
if n%2 == 0 :
ans = n//2
print(ans)
else :
ans = n//2 + 1
print(ans)
|
def solve():
N = int(input())
print((N+1)//2)
if __name__ == "__main__":
solve()
| 1 | 58,829,860,032,956 | null | 206 | 206 |
S = input()
s = ""
for i in range(0,len(S)):
s += "x"
print(s)
|
_, *a = map(int, open(0).read().split())
print(sum(b%2 for b in a[::2]))
| 0 | null | 40,250,695,486,052 | 221 | 105 |
N=int(input())
l = [[] for _ in range(9)]
for i in range(0,9):
for j in range(0,9):
l[i].append(0)
for i in range(N+1):
if (int(str(i)[0])!=0 and int(str(i)[-1])!=0):
l[int(str(i)[0])-1][int(str(i)[-1])-1]+=1
t=0
for i in range(9):
for j in range(9):
t+=l[i][j]*l[j][i]
print(t)
|
import math
import statistics
import collections
a=int(input())
#b,c=int(input()),int(input())
# c=[]
# for i in b:
# c.append(i)
#e1,e2 = map(int,input().split())
# f = list(map(int,input().split()))
g = [input() for _ in range(a)]
# h = []
# for i in range(e1):
# h.append(list(map(int,input().split())))
g.sort()
ma=0
count=1
#最大値求める
for i in range(a-1):
if g[i]==g[i+1]:
count+=1
else:
ma=max(ma,count)
count=1
ma=max(ma,count)
count=1
ans=[]
#最大値の位置
for i in range(a-1):
if g[i]==g[i+1]:
count+=1
else:
if count==ma:
ans.append(g[i])
count=1
if count==ma:
ans.append(g[-1])
for i in ans:
print(i)
| 0 | null | 78,415,888,483,240 | 234 | 218 |
#(身長)ー（番号）＝ー（身長）ー（番号）はありえない、身長=0にならないから
N = int(input())
A = list(map(int,input().split()))
from collections import defaultdict
AB = defaultdict(int)
_AB = defaultdict(int)
for i,a in enumerate(A):
AB[i+1+A[i]]+=1
_AB[-A[i]+i+1]+=1
ans = 0
for key,val in AB.items():
ans += val*_AB[key]
print(ans)
|
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
L = [-1 for _ in range(N)]
R = [-1 for _ in range(N)]
for i in range(N):
L[i] = A[i] - i-1
R[i] = A[i] + i+1
# L = -R となる物のうち、i>jになりゃいいんだけど、最後にいくつかで破れば良い気がす
# i > 0 なので、自分自身を２回選んでL＝Rみたいにはならない・・・？
LC = Counter(L)
RC = Counter(R)
ans = 0
for k,v in LC.items():
if (-1) * k in RC:
ans += v * RC[(-1)*k]
#print(k,v,(-1)*k,RC[(-1)*k], ans)
print(ans)
| 1 | 26,035,846,612,960 | null | 157 | 157 |
n = int(raw_input())
q = []
bottom = 0
for i in range(n):
cmd = raw_input()
if cmd[0] == 'i':
q.append(cmd[7:])
elif cmd[6] == ' ':
try:
q.pop(~q[::-1].index(cmd[7:]))
except:
pass
elif cmd[6] == 'F':
q.pop()
else:
bottom += 1
print(' '.join(q[bottom:][::-1]))
|
from collections import deque
n = int(input())
d = deque()
for _i in range(n):
line = input().split()
order = line[0]
if order in ('insert', 'delete'):
key = line[1]
if order == 'insert':
d.appendleft(key)
elif order == 'delete':
try:
d.remove(key)
except ValueError:
pass
elif order == 'deleteFirst':
d.popleft()
elif order == 'deleteLast':
d.pop()
else:
raise ValueError('Invalid order: {order}')
print(' '.join(d))
| 1 | 50,699,628,500 | null | 20 | 20 |
print(input()[0:3])
|
import sys
def main():
input = sys.stdin.buffer.readline
k = int(input())
a = [
1,
1,
1,
2,
1,
2,
1,
5,
2,
2,
1,
5,
1,
2,
1,
14,
1,
5,
1,
5,
2,
2,
1,
15,
2,
2,
5,
4,
1,
4,
1,
51,
]
print(a[k - 1])
if __name__ == "__main__":
main()
| 0 | null | 32,527,573,951,922 | 130 | 195 |
N=int(input())
D=[]
TF=[]
for i in range(N):
Input=list(map(int,input().split()))
D.append(Input)
if D[i][0]==D[i][1]:
TF.append(1)
else:
TF.append(0)
TF.append(0)
TF.append(0)
Q=[]
for i in range(N):
temp=TF[i]+TF[i+1]+TF[i+2]
Q.append(temp)
if max(Q)==3:
print("Yes")
else:
print("No")
|
n=int(input())
alist=[0]*n
for i in range(n):
a,b=map(int, input().split())
if a==b:
alist[i]=alist[max(i-1,0)]+1
if max(alist)>=3:
print('Yes')
else:
print('No')
| 1 | 2,491,568,125,760 | null | 72 | 72 |
L=list(map(int,input().split()))
L[2],L[0]=L[0],L[2]
L[1],L[2]=L[2],L[1]
print(*L)
|
n=list(map(str,input().split()));print(n[2]+' '+n[0]+' '+n[1])
| 1 | 38,038,433,522,948 | null | 178 | 178 |
print(f'A{["B","R"]["B"==input()[1]]}C')
|
while True:
num = list(map(int,input().split()))
if(num[0] == 0 and num[1] == 0): break
c = 0
for i in range(1,num[0] - 1):
for j in range(i+1,num[0]):
for k in range(j+1,num[0]+1):
if(i+j+k == num[1]): c += 1
print(c)
| 0 | null | 12,775,246,554,058 | 153 | 58 |
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)
|
i = 0
x = int(input())
while x != 0:
i += 1
print("Case ", i, ": ", x, sep="")
x = int(input())
| 0 | null | 20,635,094,377,700 | 182 | 42 |
# coding: utf-8
"""
aizu 0001
"""
import sys
# @profile
def main():
mountaines=[]
for line in sys.stdin:
mountaines.append(int( line ))
mountaines.sort(reverse=True)
for index,x in enumerate( mountaines ):
print x
if index >=2:
break
if __name__ == '__main__':
main()
|
if input()=="0":
print(1)
else:
print(0)
| 0 | null | 1,467,964,705,952 | 2 | 76 |
import sys
N,K = map(int,input().split())
H = sorted(list(map(int,input().split())),reverse = True)
for i in range(N):
if not H[i] >= K:
print(i)
sys.exit()
print(N)
|
n, k = map(int, input().split())
l = list(map(int, input().split()))
cnt = 0;
for i in l:
if i >= k:
cnt += 1;
print(cnt)
| 1 | 178,875,655,234,342 | null | 298 | 298 |
def main():
K, N = map(int, input().split())
A = list(map(int, input().split()))
dists = set([])
for idx in range(len(A) - 1):
dists.add(A[idx + 1] - A[idx])
dists.add(A[0] + K - A[-1])
print(K - max(list(dists)))
if __name__ == '__main__':
main()
|
K, N = map(int, input().split())
A = list(map(int, input().split()))
res = A[0] + (K - A[N-1])
for i in range(1, N):
dist = A[i] - A[i-1]
if res < dist:
res = dist
print(K - res)
| 1 | 43,225,586,714,790 | null | 186 | 186 |
import sys
from bisect import bisect_left,bisect_right
sys.setrecursionlimit(10**9)
INF=10**18
def input():
return sys.stdin.readline().rstrip()
def main():
N,M=map(int,input().split())
A=sorted(list(map(int,input().split())))
S=[0]*(N+1)
for i in range(N):
S[i+1]=S[i]+A[i]
def nibutan(ok,ng):
while abs(ok-ng) > 1:
mid = (ok + ng) // 2
if solve(mid):
ok = mid
else:
ng = mid
return ok
def solve(mid):
c=0
for i in range(N):
c+=N-bisect_left(A,mid-A[i])
if c>=M:
return True
else:
return False
x=nibutan(0,10**11)
ans=0
count=0
for i in range(N):
b_l=bisect_left(A,x-A[i])
count+=(N-b_l)
ans+=S[N]-S[b_l]+A[i]*(N-b_l)
if count==M:
print(ans)
else:
print(ans+(M-count)*x)
if __name__ == '__main__':
main()
|
# 二分探索を利用した
N, M = map(int, input().split())
tmp = input().split()
A = [int(tmp[i]) for i in range(N)]
A.sort()
cum_A = [None]*N
cum_A[N-1] = A[N-1]
for i in range(1,N):
cum_A[N-1-i] = cum_A[N-i] + A[N-1-i]
cum_A.append(0)
def geq(A, cum_A, X, N): # ある定数X以上になる握手の方法が何通りあるか,Aは昇順sort済み
sum = 0
val = 0
index = 0
for i in range(N):
while True:
if index != N and A[i] + A[N - 1 - index] >= X:
index += 1
else:
sum += index
val += A[i] * index + cum_A[N-index]
break
return sum, val
# 2<=X<=2*Nで二分探索をする
low = 2
high = 2*A[N-1]
while low <= high:
X = (low + high)//2
sum, val = geq(A, cum_A, X, N)
if sum == M:
break
elif sum > M:
low = X+1
else:
high = X-1
if sum < M:
X -= 1
sum, val = geq(A, cum_A, X, N)
ans = val - X*(sum-M)
print(ans)
| 1 | 108,080,637,016,198 | null | 252 | 252 |
def main():
import sys
n,s,_,*t=sys.stdin.buffer.read().split()
n=int(n)
d=[0]*n+[1<<c-97for c in s]
for i in range(n-1,0,-1):d[i]=d[i+i]|d[i-~i]
r=[]
for q,a,b in zip(*[iter(t)]*3):
i,s=int(a)+n-1,0
if q<b'2':
d[i]=1<<b[0]-97
while i:
i//=2
d[i]=d[i+i]|d[i-~i]
continue
j=int(b)+n
while i<j:
if i&1:
s|=d[i]
i+=1
if j&1:
j-=1
s|=d[j]
i//=2
j//=2
r+=bin(s).count('1'),
print(' '.join(map(str,r)))
main()
|
import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
# import heapq
import decimal
# import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
s = list(input())
q = ni()
alphabet_idx = {}
for i in range(26):
alphabet_idx[i] = []
for i, si in enumerate(s):
alphabet_idx[ord(si) - ord("a")].append(i)
for _ in range(q):
qi, a, b = input().split()
qi, a = int(qi), int(a)
if qi == 1:
a -= 1
if s[a] == b:
continue
del_char = ord(s[a]) - ord("a")
del_idx = bisect.bisect_left(alphabet_idx[del_char], a)
del alphabet_idx[del_char][del_idx]
insert_char = ord(b) - ord("a")
insert_idx = bisect.bisect_left(alphabet_idx[insert_char], a)
alphabet_idx[insert_char].insert(insert_idx, a)
s[a] = b
if qi == 2:
b = int(b)
a -= 1
b -= 1
ans = 0
for i in range(26):
a_idx = bisect.bisect_left(alphabet_idx[i], a)
if a_idx < len(alphabet_idx[i]):
if alphabet_idx[i][a_idx] <= b:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 1 | 62,651,866,167,370 | null | 210 | 210 |
from sys import setrecursionlimit
setrecursionlimit(10 ** 5)
def find(parent, i):
t = parent[i]
if t < 0:
return i
t = find(parent, t)
parent[i] = t
return t
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[j] += parent[i]
parent[i] = j
n, m, k = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
cd = [list(map(int, input().split())) for _ in range(k)]
parent = [-1] * n
friends = [[] for _ in range(n)]
for a, b in ab:
unite(parent, a-1, b-1)
friends[a-1].append(b-1)
friends[b-1].append(a-1)
blocks = [[] for _ in range(n)]
for c, d in cd:
blocks[c-1].append(d-1)
blocks[d-1].append(c-1)
result = []
for i in range(n):
p = find(parent, i)
t = -parent[p] - 1
t -= len(friends[i])
for b in blocks[i]:
if p == find(parent, b):
t -= 1
result.append(t)
print(*result)
|
from collections import Counter
import sys
n, m, k = map(int, input().split())
F = [[] for _ in range(n)]
B = [[0] for _ in range(n)]
sys.setrecursionlimit(10**9)
for _ in range(m):
a, b = map(int, input().split())
F[a-1].append(b)
F[b-1].append(a)
rks = [0]*(n)
def dfs(s,r):
if rks[s] == 0:
rks[s] = r
for i in F[s]:
if rks[i-1] != 0:
continue
dfs(i-1,r)
r = 0
for i in range(n):
if rks[i] == 0:
r += 1
dfs(i,r)
for _ in range(k):
c, d = map(int, input().split())
if rks[c-1] == rks[d-1]:
B[c-1][0] += 1
B[d-1][0] += 1
counter = Counter(rks)
for i in range(n):
print(counter[rks[i]] - len(F[i]) - (B[i][0]) - 1)
| 1 | 61,525,723,009,410 | null | 209 | 209 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.