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
|
|---|---|---|---|---|---|---|
A,B = (int(a) for a in input().split())
ans = A - B * 2
print(max(0,ans))
|
n,k_ = map(int,input().split())
a_li = list(map(int,input().split()))
a_li_o = [0]*n
for i in range(k_):
for l in range(n):
a_li_o[l] = a_li[l]
dum_li = [0]*n
for j in range(n):
left = j - a_li[j]
right = j + a_li[j] + 1
if left < 0:
left = 0
dum_li[left] += 1
if right > n-1:
continue
dum_li[right] -= 1
total = 0
for k in range(n):
total += dum_li[k]
dum_li[k] = total
for k in range(n):
a_li[k] = dum_li[k]
if a_li_o == a_li:
break
print(" ".join(map(str,a_li)))
| 0 | null | 90,724,875,525,008 | 291 | 132 |
n = int(input())
a = list(map(int,input().split()))
count = 0
for i in range(n-1):
flag = 0
min_j = i
for j in range(i,n):
if a[j] < a[min_j]:
min_j = j
flag = 1
if flag:
a[i], a[min_j] = a[min_j], a[i]
count += 1
print(" ".join(map(str,a)))
print(count)
|
N = int(input())
A = [int(x) for x in input().split()]
cnt = 0
for i in range(N):
mini = i
for j in range(i, N):
if A[j] < A[mini]:
mini = j
if i != mini:
A[i], A[mini] = A[mini], A[i]
cnt +=1
print(" ".join(map(str, A)))
print(cnt)
| 1 | 19,905,134,598 | null | 15 | 15 |
#ABC 171 E - Red Scarf
n = int(input())
A = list(map(int, input().split()))
S = 0
for i in A:
S ^= i
B = [S^i for i in A]
print(*B)
|
for i in range(1, 10):
for j in range(1, 10):
print u"%dx%d=%d" % (i, j, i*j)
| 0 | null | 6,203,135,496,988 | 123 | 1 |
N = int(input())
A = [int(i) for i in input().split()]
possess = 1000
for i in range(N-1):
if A[i] < A[i+1]:
stock = possess//A[i]
possess = possess % A[i] + A[i+1] * stock
print(possess)
|
x = input()
if x == "RRR":
print(3)
elif x == "RRS":
print(2)
elif x == "SRR":
print(2)
elif x == "SSS":
print(0)
else:
print(1)
| 0 | null | 6,125,692,400,508 | 103 | 90 |
late = input()
i = int(late)
if i >= 400 and i <= 599:
print("8")
if i >= 600 and i <= 799:
print("7")
if i >= 800 and i <= 999:
print("6")
if i >= 1000 and i <= 1199:
print("5")
if i >= 1200 and i <= 1399:
print("4")
if i >= 1400 and i <= 1599:
print("3")
if i >= 1600 and i <= 1799:
print("2")
if i >= 1800 and i <= 1999:
print("1")
|
k = int(input())
a, b = map(int, input().split())
check = False
for i in range(a, b + 1):
if i % k == 0:
check = True
print("OK" if check else "NG")
| 0 | null | 16,783,665,509,002 | 100 | 158 |
def solve():
s, t = input().split()
print(t+s)
if __name__ == '__main__':
solve()
|
t = int(input())
if t >= 30:
print('Yes')
else:
print('No')
| 0 | null | 54,497,985,216,708 | 248 | 95 |
n, a, b = map(int, input().split())
if abs(b-a)%2 == 0:
print(abs(b-a)//2)
else:
print(min((max(a,b)+min(a,b))//2, (2*n-max(a,b)-min(a,b)+1)//2))
|
n = int(input())
if n%2 == 1:
print(0)
exit()
num = 5
i = 1
ans = 0
while num**i < n:
ans += n//num**i//2
i += 1
print(ans)
| 0 | null | 113,146,109,816,580 | 253 | 258 |
B=[]
for i in range(3):
A=list(map(int,input().split()))
B.append(A[0])
B.append(A[1])
B.append(A[2])
N=int(input())
for j in range(N):
b=int(input())
if b in B:
B[B.index(b)]=0
if B[0]==0 and B[1]==0 and B[2]==0:
print('Yes')
elif B[3]==0 and B[4]==0 and B[5]==0:
print('Yes')
elif B[6]==0 and B[7]==0 and B[8]==0:
print('Yes')
elif B[0]==0 and B[3]==0 and B[6]==0:
print('Yes')
elif B[1]==0 and B[4]==0 and B[7]==0:
print('Yes')
elif B[2]==0 and B[5]==0 and B[8]==0:
print('Yes')
elif B[0]==0 and B[4]==0 and B[8]==0:
print('Yes')
elif B[2]==0 and B[4]==0 and B[6]==0:
print('Yes')
else:
print('No')
|
a=input()
b=input()
if (a=="1" and b=="2")or(a=="2" and b=="1"):
print("3")
if (a=="1" and b=="3")or(a=="3" and b=="1"):
print("2")
if (a=="3" and b=="2")or(a=="2" and b=="3"):
print("1")
| 0 | null | 85,514,939,251,720 | 207 | 254 |
H, W, K = map(int, input().split())
S = [list(map(int, input())) for _ in range(H)]
C = [[0 for w in range(W)] for h in range(H)] #各行のw列目までに1が何個あるか
#print(S)
for h in range(H):
for w in range(W):
#print(h,w)
C[h][w] = C[h][w-1] + S[h][w]
#print(C)
def settify(l):
set_label = set()
i = 0
while l > 0:
if l % 2 == 1:
set_label.add(i)
l //= 2
i += 1
return set_label
def set_label(s):
tmp = 0
for i in s:
tmp += 2**i
return tmp
def sum_set(s, w):
s_list = list(s)
s_list.sort()
s_list.append(H-1)
tmp = 0
it = 0
ans_list = []
for h in range(H):
tmp += C[h][w]
#print(w, tmp)
if h == s_list[it]:
ans_list.append(tmp)
tmp = 0
it += 1
return ans_list
#print(sum_set(set(), 0), sum_set(set(), 1))
ans = 10**8
for l in range(2**(H-1)):
s = settify(l)
lt_prv = [0 for _ in range(len(s)+1)]
lt_now = [0 for _ in range(len(s)+1)]
lt_1minus = [0 for _ in range(len(s)+1)]
tmp = len(s)
w = 0
w_prv = -1
imp = False
while w < W:
lt_now = sum_set(s, w)
flag = False
for j in range(len(s)+1):
if lt_now[j] - lt_prv[j] > K:
flag = True
break
if flag:
if w_prv == w-1:
imp = True
tmp += 1
lt_prv = lt_1minus
w_prv = w-1
w += 1
lt_1minus = lt_now
if imp:
break
#print(s, w-1)
#print(lt_prv, lt_1minus, lt_now)
if not imp:
ans = min(ans, tmp)
print(ans)
|
def generate_arr(a):
if len(a) == N:
arr.append(a)
return
for i in range(1,N+1):
if i not in a:
generate_arr(a+[i])
N = int(input())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
arr = []
generate_arr([])
arr.sort()
ans_p = 0
ans_q = 0
for i in range(len(arr)):
if arr[i] == P:
ans_p = i+1
if arr[i] == Q:
ans_q = i+1
print(abs(ans_p-ans_q))
| 0 | null | 74,366,435,246,620 | 193 | 246 |
mod = 1000000007
fact = []
fact_inv = []
pow_ = []
pow25_ = []
pow26_ = []
def pow_ini(nn):
global pow_
pow_.append(nn)
for j in range(62):
nxt = pow_[j] * pow_[j]
nxt %= mod
pow_.append(nxt)
return
def pow_ini25(nn):
global pow25_
pow25_.append(nn)
for j in range(62):
nxt = pow25_[j] * pow25_[j]
nxt %= mod
pow25_.append(nxt)
return
def pow_ini26(nn):
global pow26_
pow26_.append(nn)
for j in range(62):
nxt = pow26_[j] * pow26_[j]
nxt %= mod
pow26_.append(nxt)
return
def pow1(k):
ansk = 1
for ntmp in range(62):
if((k >> ntmp) % 2 == 1):
ansk *= pow_[ntmp]
ansk %= mod
return ansk
def pow25(k):
ansk = 1
for ntmp in range(31):
if((k >> ntmp) % 2 == 1):
ansk *= pow25_[ntmp]
ansk %= mod
return ansk
def pow26(k):
ansk = 1
for ntmp in range(31):
if((k >> ntmp) % 2 == 1):
ansk *= pow26_[ntmp]
ansk %= mod
return ansk
def fact_ini(n):
global fact
global fact_inv
global pow_
for i in range(n + 1):
fact.append(0)
fact_inv.append(0)
fact[0] = 1
for i in range(1, n + 1, 1):
fact_tmp = fact[i - 1] * i
fact_tmp %= mod
fact[i] = fact_tmp
pow_ini(fact[n])
fact_inv[n] = pow1(mod - 2)
for i in range(n - 1, -1, -1):
fact_inv[i] = fact_inv[i + 1] * (i + 1)
fact_inv[i] %= mod
return
def nCm(n, m):
assert(m >= 0)
assert(n >= m)
ans = fact[n] * fact_inv[m]
ans %= mod
ans *= fact_inv[n - m]
ans %= mod
return ans;
fact_ini(2200000)
pow_ini25(25)
pow_ini26(26)
K = int(input())
S = input()
N = len(S)
ans = 0
for k in range(0, K+1, 1):
n = N + K - k
anstmp = 1
anstmp *= pow26(k)
anstmp %= mod
anstmp *= nCm(n - 1, N - 1)
anstmp %= mod
anstmp *= pow25(n - N)
anstmp %= mod
ans += anstmp
ans %= mod
print(ans)
|
import sys
for index, line in enumerate(sys.stdin):
value = int(line.strip())
if value == 0:
break
print("Case {0}: {1}".format(index+1, value))
| 0 | null | 6,577,696,916,320 | 124 | 42 |
def digitSum(n):
s = str(bin(n))
s = s[2:]
array = list(map(int, s))
return sum(array)
N = int(input())
A = []
X = []
Y = []
res = 0
for i in range(N):
a = int(input())
A.append(a)
X_temp = []
Y_temp = []
for j in range(a):
x,y = map(int,input().split())
X_temp.append(x)
Y_temp.append(y)
X.append(X_temp)
Y.append(Y_temp)
for i in range(1 << N):
judge = True
for j in range(N):
if (i >> j) & 1:#もしAjが正直者だったら
for k in range(A[j]):
if (i >> X[j][k]-1) & 1 != Y[j][k]:
judge = False
"""else:#もしAjが不親切ものだったら。不親切者も正しいことをいうこともある。
for k in range(A[j]):#
if (i >> X[j][k]-1) & 1 == Y[j][k]:
judge = False"""
if judge:
res = max(res,digitSum(i))
print(res)
|
N = int(input())
X = []
Y = []
for _ in range(N):
a = int(input())
tmp = []
for _ in range(a):
tmp.append(list(map(int, input().split())))
X.append(a)
Y.append(tmp)
ans = 0
for bit in range(2 ** N):
flag = True
for i in range(N):
if bit >> i & 1:
for x, y in Y[i]:
flag &= (bit >> (x - 1) & 1) == y
if flag:
ans = max(ans, bin(bit).count("1"))
print(ans)
| 1 | 121,647,387,781,020 | null | 262 | 262 |
import numpy as np
a,b,h,m = list(map(int,input().split()))
theta = abs(h/12-11*m/720)*2*np.pi
print(np.sqrt((a*a+b*b-2*a*b*np.cos(theta))))
|
x = int(input())
x //= 200
print(10 - x)
| 0 | null | 13,256,700,521,952 | 144 | 100 |
def main():
global s,ide_ele,num,seg
n = int(input())
s = list(input())
for i in range(n):
s[i] = ord(s[i])-97
ide_ele = 0
num = 2**(n-1).bit_length()
seg = [[ide_ele for _ in range(2*num)] for _ in range(26)]
for i in range(n):
seg[s[i]][i+num-1] = 1
for a in range(26):
for i in range(num-2,-1,-1) :
seg[a][i] = max(seg[a][2*i+1],seg[a][2*i+2])
q = int(input())
for _ in range(q):
QUERY = list(input().split())
QUERY[0], QUERY[1] = int(QUERY[0]), int(QUERY[1])
if QUERY[0] == 1:
x = ord(QUERY[2])-97
k = QUERY[1]-1
pre = s[k]
s[k] = x
k += num-1
seg[pre][k] = 0
seg[x][k] = 1
while k:
k = (k-1)//2
seg[pre][k] = max(seg[pre][k*2+1],seg[pre][k*2+2])
seg[x][k] = max(seg[x][k*2+1],seg[x][k*2+2])
if QUERY[0] == 2:
P, Q = QUERY[1]-1, int(QUERY[2])
if Q <= P:
print(ide_ele)
break
P += num-1
Q += num-2
ans = ide_ele
for i in range(26):
res = ide_ele
p,q = P,Q
while q-p > 1:
if p&1 == 0:
res = max(res,seg[i][p])
if q&1 == 1:
res = max(res,seg[i][q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = max(res,seg[i][p])
else:
res = max(max(res,seg[i][p]),seg[i][q])
ans += res
print(ans)
if __name__ == "__main__":
main()
|
def main():
s = input()
print(s[:3])
if __name__ == '__main__':
main()
| 0 | null | 38,472,873,992,870 | 210 | 130 |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(H: int, A: int):
return H//A+(H % A > 0)
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
H = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
print(f'{solve(H, A)}')
if __name__ == '__main__':
main()
|
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 | 52,223,737,665,042 | 225 | 159 |
#!/usr/bin/env python
from __future__ import division, print_function
from sys import stdin
from Queue import Queue
def main():
num = int(stdin.readline())
L = []
for _ in xrange(num):
L.append([int(s) for s in stdin.readline().split()[2:]])
d = [-1] * num
d[0] = 0
q = Queue(100)
q.put(0)
while not q.empty():
u = q.get()
for v in L[u]:
if d[v-1] < 0:
d[v-1] = d[u] + 1
q.put(v-1)
for i, v in enumerate(d):
print(i+1, v)
main()
|
N, M = map(int, input().split())
edge = [[] for _ in range(N)]
for i in range(M):
a,b = map(int, input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
from collections import deque
def solve():
prev = [-1]*N
prev[0]='Yes'
d = deque([(0,0)])
while len(d):
v,cnt = d.popleft()
for u in edge[v]:
if prev[u]==-1:
prev[u]=v+1
d.append((u,cnt+1))
if -1 in prev:
return ['No']
return prev
print(*solve(),sep='\n')
| 0 | null | 10,292,923,997,312 | 9 | 145 |
N = int(input())
A = list(map(int, input().split()))
manzoku = 1
hakai = 0
for i in range(N):
if A[i] == manzoku:
manzoku += 1
else:
hakai += 1
if hakai == N:
print(-1)
else:
print(hakai)
|
N = int(input())
A = list(map(int, input().split()))
cnt = 0
now = 0
for a in A:
if a == now + 1:
now += 1
else:
cnt += 1
if now == 0:
print(-1)
else:
print(cnt)
| 1 | 114,810,492,136,928 | null | 257 | 257 |
x = int(input())
n = x//100
if x%100 <= 5*n:
print(1)
else:
print(0)
|
x = int(input())
a = x-x//100*100
print(1) if a//5 + (a%5!=0) <= x//100 else print(0)
| 1 | 127,314,833,535,828 | null | 266 | 266 |
def solve_145e():
from collections import namedtuple
from operator import attrgetter
import sys
input = sys.stdin.readline
Food = namedtuple('Food', 'time_to_eat deliciousness')
N, T = map(int, input().split())
foods = []
for _ in range(N):
row = map(int, input().split())
foods.append(Food(*row))
foods.sort(key=attrgetter('time_to_eat'))
# 同じ料理の組を食べるなら時間のかかるものを後回しにしても結果は悪くならない
dp = [-1] * T
dp[0] = 0
# dp[time]:=timeに食べ終わる注文の仕方で得られる最大満足度
ma = 0 # 回答候補
ca = 0 # フィニッシュ前候補
for food in foods:
# これでフィニッシュの場合
ma = max(ma, ca + food.deliciousness)
# まだ食べる場合
for time in range(T - 1 - food.time_to_eat, -1, -1):
if ~dp[time]:
when_eat = dp[time] + food.deliciousness
if dp[time + food.time_to_eat] < when_eat:
dp[time + food.time_to_eat] = when_eat
ca = max(ca, when_eat)
print(ma)
return
if __name__ == '__main__':
solve_145e()
|
N,T = map(int,input().split())
A = sorted([list(map(int,input().split())) for _ in range(N)],key=lambda x:x[0])
A.insert(0,[-1,-1])
dp = [[0 for _ in range(T+1)] for _ in range(N)]
for i in range(1,N):
for j in range(1,T+1):
dp[i][j] = dp[i-1][j]
if j>A[i][0]:
dp[i][j] = max(dp[i][j],dp[i-1][j-A[i][0]]+A[i][1])
dmax = 0
for i in range(1,N+1):
dmax = max(dmax,dp[i-1][T]+A[i][1])
print(dmax)
| 1 | 151,900,707,009,250 | null | 282 | 282 |
m, d = input().split(' ')
M, D = input().split(' ')
if D == '1':
print(1)
else:
print(0)
|
MD1 = list(map(int, input().split()))
MD2 = list(map(int, input().split()))
if MD1[0] == MD2[0]:
print(0)
else:
print(1)
| 1 | 124,961,986,604,250 | null | 264 | 264 |
A,B=map(int,input().split())
if (A>9)|(B>9):
print(-1)
else:
print(A*B)
|
N=int(input());
print((N-1)//2);
| 0 | null | 155,541,310,410,720 | 286 | 283 |
n = int(input())
list_s = [1,2,3,4,5,6,7,8,9,10,11,12,13]
list_h = [1,2,3,4,5,6,7,8,9,10,11,12,13]
list_c = [1,2,3,4,5,6,7,8,9,10,11,12,13]
list_d = [1,2,3,4,5,6,7,8,9,10,11,12,13]
for i in range(n):
zugara, num = input().split()
#print(zugara)
#print(num)
#print(list_s)
if zugara == 'S':
list_s.remove(int(num))
elif zugara == 'H':
list_h.remove(int(num))
elif zugara == 'C':
list_c.remove(int(num))
else:
list_d.remove(int(num))
for i in list_s:
print('S', i)
for i in list_h:
print('H', i)
for i in list_c:
print('C', i)
for i in list_d:
print('D', i)
|
import sys
SUITS = ('S', 'H', 'C', 'D')
cards = {suit:{i for i in range(1, 14)} for suit in SUITS}
n = input() # 読み捨て
for line in sys.stdin:
suit, number = line.split()
cards[suit].discard(int(number))
for suit in SUITS:
for i in cards[suit]:
print(suit, i)
| 1 | 1,036,002,678,198 | null | 54 | 54 |
N, M, K = map(int, input().split())
MOD = 998244353
# 階乗 & 逆元計算
factorial = [1]
inverse = [1]
for i in range(1, N+2):
factorial.append(factorial[-1] * i % MOD)
inverse.append(pow(factorial[-1], MOD - 2, MOD))
# 組み合わせ計算
def nCr(n, r):
if n < r or r < 0:
return 0
elif r == 0:
return 1
return factorial[n] * inverse[r] * inverse[n - r] % MOD
ans = 0
for k in range(K + 1):
ans += M * nCr(N - 1, k) * pow(M - 1, N - 1 - k, MOD) % MOD
ans %= MOD
print(ans % MOD)
|
N = int(input())
S = input()
print('Yes' if S[:N//2] == S[N//2:] else 'No')
| 0 | null | 85,084,544,367,778 | 151 | 279 |
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
l ,r, d = map(int,input().split())
ans=0
for i in range(l,r+1):
if i % d ==0:
ans+=1
print(ans)
if __name__=='__main__':
main()
|
N = int(input())
xyp = []
xym = []
for _ in range(N):
x, y = map(int, input().split())
xyp.append(x+y)
xym.append(x-y)
xyp.sort()
xym.sort()
print(max(xyp[-1] - xyp[0], xym[-1] - xym[0]))
| 0 | null | 5,410,685,200,530 | 104 | 80 |
if sum(list(map(int,input().split())))>21:
print("bust")
else:
print("win")
|
# Problem E - Colorful Blocks
# input
N, M, K = map(int, input().split())
# initialization
MOD = 998244353
fact = [1, 1]
fact_inv = [1, 1]
inv = [0, 1]
pow_list = [1, M-1]
for i in range(2, N+1):
fact.append((fact[-1] * i)%MOD)
inv.append((-inv[MOD%i] * (MOD//i))%MOD)
fact_inv.append((fact_inv[-1] * inv[-1])%MOD)
pow_list.append(pow_list[i-1]*(M-1)%MOD)
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n-r)
return fact[n] * fact_inv[r] * fact_inv[n-r] % p
ans = 0
# calc
for i in range(K+1):
tmp = ((M * cmb(N-1, i, MOD))%MOD * pow_list[N-(i+1)])%MOD
ans = (ans + tmp)%MOD
# output
print(ans)
| 0 | null | 70,695,597,455,098 | 260 | 151 |
from __future__ import division, print_function
import sys
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
#from functools import lru_cache #use @lru_cache(None)
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
#
def input(): return sys.stdin.readline()
def mapi(arg=0): return map(int if arg==0 else str,input().split())
#------------------------------------------------------------------
s,w = mapi()
if w>=s:
print("unsafe")
else:
print("safe")
|
N,K = map(int,input().split())
H = list(map(int,input().split()))
res = 0
for i in range(N):
if H[i]>=K:
res += 1
print(res)
| 0 | null | 103,732,522,794,384 | 163 | 298 |
n,*a=map(int,open(0).read().split())
dp=[[0]*n for _ in range(3)]
for i in range(n):
if i%2:
dp[1][i]=max(dp[2][i-3]+a[i],dp[1][i-2]+a[i])
elif i>1:
dp[0][i]=max(dp[0][i-2]+a[i],dp[1][i-3]+a[i],dp[2][i-4]+a[i])
dp[2][i]=dp[2][i-2]+a[i]
else:
dp[2][i]=dp[2][i-2]+a[i]
print(max(dp[2][-3],dp[1][-2],dp[0][-1]) if n%2 else max(dp[1][-1],dp[2][-2]))
|
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def s(x): #圧縮
a = []
if len(x) == 0:
return []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(map(max,x))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
def pow_k(x, n):
ans = 1
while n:
if n % 2:
ans *= x
x *= x
n >>= 1
return ans
"""
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if (ここに評価入れる):
rr = mid
else:
ll = mid+1
"""
n = onem()
a = l()
if n % 2 == 0:
po = [a[i] for i in range(n)]
for i in range(n-3,-1,-1):
po[i] += po[i+2]
ans = sum(a[0::2])
ans = max(ans,sum(a[1::2]))
co = 0
for i in range(0,n,2):
if i+1 <= n-1:
ans = max(ans,co+po[i+1])
else:
ans = max(ans,co)
co += a[i]
print(ans)
else:
po = [a[i] for i in range(n)]
mi = [-Max for i in range(n)]
for i in range(n-3,-1,-1):
po[i] += po[i+2]
ans = sum(a[1::2])
ans = max(ans,sum(a[0::2]) - a[-1])
#print(ans)
l1 = [-Max for i in range(n)]
for i in range(n):
if i != n-1:
l1[i] = po[i+1]
"""
co = 0
for i in range(0,n,2):
if i != n-1:
l1[i] = co + po[i+1]
else:
l1[i] = co
co += a[i]
co = 0
for i in range(1,n,2):
if i != n-1:
l1[i] = co + po[i+1]
else:
l1[i] = co
co += a[i]
"""
for i in range(n-1,-1,-1):
if i == n-1:
continue
elif i == n-2:
mi[i] = l1[i]
else:
mi[i] = max(mi[i+2]+a[i],l1[i])
l1 = mi
"""
for i in range(n-1,-1,-1):
if i <= n-3:
mi[i] = min(mi[i+2],a[i])
else:
mi[i] = a[i]
print(mi)
"""
l2 = [-Max for i in range(n)]
for i in range(n-1,-1,-1):
l2[i] = po[i]
#print(l1)
#print(l2)
co = 0
for i in range(0,n,2):
if i + 2 <= n-1:
#print(ans,co+l1[i+1],co+l2[i+2])
ans = max(ans,co+l1[i+1],co+l2[i+2])
elif i+1 <= n-1:
ans = max(ans,co+l1[i+1])
else:
ans = max(ans,co)
co += a[i]
co = 0
#print(ans)
for i in range(1,n,2):
#print(ans,co+l1[i+1])
ans = max(ans,co+po[i+1])
#ans = max(ans,co+l1[i+1])
co += a[i]
#print("po:"+str(mi[1]))
print(ans)
| 1 | 37,154,007,956,072 | null | 177 | 177 |
#設定
import sys
input = sys.stdin.buffer.readline
#ライブラリインポート
from collections import defaultdict
con = 10 ** 9 + 7
#入力受け取り
def getlist():
return list(map(int, input().split()))
class Combination(object):
def __init__(self, N, con):
self.fac = [0] * (N + 1)
self.inv = [0] * (N + 1)
self.finv = [0] * (N + 1)
self.fac[0], self.fac[1] = 1, 1
self.inv[1] = 1
self.finv[0], self.finv[1] = 1, 1
# 前計算
for i in range(2, N + 1):
self.fac[i] = self.fac[i - 1] * i % con
self.inv[i] = self.inv[con % i] * (con - (con // i)) % con
self.finv[i] = self.finv[i - 1] * self.inv[i] % con
def com(self, N, k):
return (self.fac[N] * self.finv[k] * self.finv[N - k]) % con
#処理内容
def main():
N, K = getlist()
if K >= N:
Com = Combination(2 * N - 1, con)
ans = Com.com(2 * N - 1, N)
print(ans)
else:
Com1 = Combination(N, con)
Com2 = Combination(N - 1, con)
ans = 0
for i in range(1, K + 1):
ans += Com1.com(N, i) * Com2.com(N - 1, i)
ans %= con
ans = (ans + 1) % con
print(ans)
if __name__ == '__main__':
main()
|
N,K = map(int,input().split())
ps = list(map(int,input().split()))
su = sum(ps[0:K])
ksum = su
ind = 0
for i in range(1,N-K+1):
ksum -= ps[i-1]
ksum += ps[i+K-1]
if ksum > su:
ind = i
su = ksum
ki = 0
for i in range(ind, ind+K):
ki += (ps[i]*(ps[i]+1))/2/ps[i]
print(ki)
| 0 | null | 70,647,853,940,800 | 215 | 223 |
import math
i = float(input())
area = float(math.pi * i * i)
length = float(2 * math.pi * i)
print('{0:.6f} {1:.6f}'.format(area, length))
|
import math
r=input()
print "%.9f"%(math.pi*r*r), math.pi*r*2
| 1 | 635,306,082,598 | null | 46 | 46 |
def fibonacci(n):
if n == 0 or n == 1:
F[n] = 1
return F[n]
if F[n] is not None:
return F[n]
F[n] = fibonacci(n - 1) + fibonacci(n - 2)
return F[n]
n = int(input())
F = [None]*(n + 1)
print(fibonacci(n))
|
n = input()
if n == 0:
print(1)
elif n == 1:
print(1)
else:
fib = [0 for i in range(n + 1)]
fib[0] = 1
fib[1] = 1
for i in range(2, n + 1):
fib[i] = fib[i - 1] + fib[i - 2]
print(fib[n])
| 1 | 1,910,488,090 | null | 7 | 7 |
S, T = map(str, input().split())
print(T+S)
|
ST = list(map(str, input().split()))
word = ST[::-1]
print("".join(word))
| 1 | 103,065,723,557,170 | null | 248 | 248 |
S,T = input().split()
A,B = map(int, input().split())
U = input()
ans=0
if U==S:
ans=A-1,B
else:
ans=A,B-1
print(' '.join(map(str,ans)))
|
S,T=map(str, input().split())
a,b=map(int, input().split())
U = str(input())
if S == U :
a -= 1
if T == U:
b -= 1
print(a,b)
| 1 | 71,891,185,837,390 | null | 220 | 220 |
import math
p = 100
for i in range(int(input())):
p = math.ceil(p * 1.05)
print(p * 1000)
|
N, A, B = map(int, input().split())
r = (N//(A+B))*A
N = N%(A+B)
print(r+N if N<=A else r+A)
| 0 | null | 27,848,882,698,432 | 6 | 202 |
import bisect
from math import ceil
class BinaryIndexedTree():
def __init__(self, max_n):
self.size = max_n + 1
self.tree = [0] * self.size
self.depth = self.size.bit_length()
def initialize(self, seq):
for i, x in enumerate(seq[1:], 1):
self.tree[i] += x
j = i + (i & (-i))
if j < self.size:
self.tree[j] += self.tree[i]
def __repr__(self):
return self.tree.__repr__()
def get_sum(self, i):
s = 0
while i:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i < self.size:
self.tree[i] += x
i += i & -i
def find_kth_element(self, k):
x, sx = 0, 0
dx = (1 << self.depth)
for i in range(self.depth - 1, -1, -1):
dx = (1 << i)
if x + dx >= self.size:
continue
y = x + dx
sy = sx + self.tree[y]
if sy < k:
x, sx = y, sy
return x + 1
n,d,a = map(int,input().split())
monster = sorted([list(map(int,input().split())) for _ in range(n)],key=lambda x:x[0])
x_list = [0]+[monster[i][0] for i in range(n)]+[float("inf")]
h_list = [0]+[monster[i][1] for i in range(n)]+[float("inf")]
bit = BinaryIndexedTree(n+2)
ans = 0
for i in range(1,n+1):
hp = h_list[i] - bit.get_sum(i)
if hp < 0:
continue
atk_time = ceil(hp/a)
ans += atk_time
top = bisect.bisect_right(x_list, x_list[i]+2*d)
bit.add(i, atk_time*a)
bit.add(top, -atk_time*a)
print(ans)
|
N, A, B = map(int, input().split())
if (B-A) % 2 == 0: print((B-A)//2)
else: print(min((A-1+B-1+1)//2, (N-A+N-B+1)//2))
| 0 | null | 95,805,013,450,180 | 230 | 253 |
a,b = map(int, raw_input().split())
s = a*b
l = 2*a + 2*b
print s, l
|
n, k = map(int, input().split())
mod = 10 ** 9 + 7
class ModInt:
def __init__(self, num, mod):
self.num = num
self.mod = mod
def __str__(self):
return str(self.num)
def __repr__(self):
return "ModInt(num: {}, mod: {}".format(self.num, self.mod)
def __add__(self, other):
ret = self.num + other.num
ret %= self.mod
return ModInt(ret, self.mod)
def __sub__(self, other):
ret = self.num - other.num
ret %= self.mod
return ModInt(ret, self.mod)
def __mul__(self, other):
ret = self.num * other.num
ret %= self.mod
return ModInt(ret, self.mod)
def pow(self, times):
pw = pow(self.num, times, self.mod)
return ModInt(pw, self.mod)
def inverse(self):
return self.pow(self.mod - 2)
def __truediv__(self, other):
num = self * other.inverse()
return ModInt(num, self.mod)
class Combination:
def __init__(self, n, mod):
self.mod = mod
self.fact = [ModInt(1, mod)]
self.inverse = [ModInt(1, mod)]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * ModInt(i, mod))
self.inverse.append(self.inverse[-1] * ModInt(i, mod).inverse())
def comb(self, n, k):
if k < 0 or n < k:
return ModInt(0, self.mod)
return self.fact[n] * self.inverse[k] * self.inverse[n-k]
mx = min(k, n - 1)
comb = Combination(n, mod)
ans = ModInt(0, mod)
for i in range(mx + 1):
ans += comb.comb(n, i) * comb.comb(n - 1, i)
print(ans)
| 0 | null | 33,859,076,956,760 | 36 | 215 |
import sys
sys.setrecursionlimit(10**6)
a,b = map(int, input().split())
if 2*b > a:
print(0)
else:
print(a-2*b)
|
def main():
N = int(input())
S = input()
dict = {'R':0, 'B':0, 'G':0}
for i in range(N):
dict[S[i]] += 1
ans = dict['R']*dict['B']*dict['G']
for i in range(N-2):
if (N-i)%2 == 0:
tmp = int((N-i)/2)-1
else:
tmp = (N-i)//2
for j in range(1,tmp+1):
if S[i]!=S[i+j] and S[i]!=S[i+2*j] and S[i+j]!=S[i+2*j]:
ans = ans - 1
return ans
print(main())
| 0 | null | 101,726,225,378,082 | 291 | 175 |
N = list(input())
inN = [int(s) for s in N]
if sum(inN) % 9 == 0:
print('Yes')
else:
print('No')
|
n = input()
sum_of_digits = 0
for d in n:
sum_of_digits += int(d)
print('Yes' if sum_of_digits%9 == 0 else 'No')
| 1 | 4,432,719,944,928 | null | 87 | 87 |
from collections import deque
from sys import stdin
n = int(input())
line = stdin.readlines()
ddl = deque()
for i in range(n):
inp = line[i].split()
if len(inp) == 2:
op, data = inp
data = int(data)
else: op, data = inp[0], None
if op == 'insert':
ddl.appendleft(data,)
elif op == 'delete':
try:
ddl.remove(data)
except ValueError:
pass
elif op == 'deleteFirst':
ddl.popleft()
elif op == 'deleteLast':
ddl.pop()
print(' '.join([str(item) for item in ddl]))
|
from collections import deque
d = deque()
for _ in range(int(input())):
a = input()
if "i" == a[0]: d.appendleft(int(a[7:]))
elif "F" == a[6]: d.popleft()
elif "L" == a[6]: d.pop()
else:
try: d.remove(int(a[7:]))
except: pass
print(*d)
| 1 | 52,125,562,412 | null | 20 | 20 |
N = int(input())
A = [input() for _ in range(N)]
count = [0] * 4
for a in A:
if a == 'AC':
count[0] += 1
elif a == 'WA':
count[1] += 1
elif a == 'TLE':
count[2] += 1
else:
count[3] += 1
print(f"AC x {count[0]}")
print(f"WA x {count[1]}")
print(f"TLE x {count[2]}")
print(f"RE x {count[3]}")
|
import sys
def input(): return sys.stdin.readline().rstrip()
from bisect import bisect_left,bisect
def main():
n=int(input())
S=list(input())
q=int(input())
set_s={chr(ord('a')+i):[] for i in range(26)}
for i,s in enumerate(S):
set_s[s].append(i)
for _ in range(q):
query=input().split()
if query[0]=="1":
i,c=int(query[1])-1,query[2]
if S[i]==c:continue
set_s[S[i]].remove(i)
set_s[c].insert(bisect_left(set_s[c],i),i)
S[i]=c
else:
l,r=int(query[1])-1,int(query[2])-1
ans=0
for i in range(26):
ss=chr(ord('a')+i)
if bisect(set_s[ss],r)>bisect_left(set_s[ss],l):
ans+=1
print(ans)
if __name__=='__main__':
main()
| 0 | null | 35,669,234,242,888 | 109 | 210 |
import math
a, b, deg = map(float, raw_input().split(" "))
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(deg)))
L = a + b + c
s = (a + b + c) / 2.0
S = math.sqrt(s*(s-a)*(s-b)*(s-c))
h = 2 * S / a
print(str(S) + " " + str(L) + " " + str(h))
|
import itertools
N = int(input())
cities = [list(map(int, input().split())) for _ in range(N)]
patterns = itertools.permutations(cities, N)
result = 0
count = 0
for ptn in patterns:
count += 1
dis = 0
for i in range(N-1):
dis += ((ptn[i][0]-ptn[i+1][0])**2 + (ptn[i][1]-ptn[i+1][1])**2)**0.5
result += dis
print(result/count)
| 0 | null | 74,001,952,364,690 | 30 | 280 |
# coding: utf-8
import codecs
import sys
sys.stdout = codecs.getwriter("shift_jis")(sys.stdout) # ??????
sys.stdin = codecs.getreader("shift_jis")(sys.stdin) # ??\???
# ??\??¬?????????print??????????????´?????? print(u'?????????') ??¨??????
# ??\??¬?????????input??? input(u'?????????') ??§OK
# ??°?¢???????????????????????????´??????6,7???????????????????????¢??????
"""
DEBUG = 0
if DEBUG == 0:
a = []
for i in range(200):
deglist=[int(x) for x in input().split(" ")]
a.append(deglist)
else:
a = [[5,7],[1,99],[1000,999]]
for i in range(len(a)):
wa = a[i][0] + a[i][1]
print len(str(wa))
"""
while True:
try:
a,b = map(int, raw_input().split())
print len(str(a+b))
except EOFError:
break
|
import sys
from math import log10
for line in sys.stdin:
a, b = map(int, line.split())
digitNumber = int(log10((a + b))) + 1
print(digitNumber)
| 1 | 120,475,712 | null | 3 | 3 |
print((1999-int(input()))//200+1)
|
X = int(input())
print(10 - X // 200)
| 1 | 6,715,920,333,372 | null | 100 | 100 |
a = int(input())
print('YNeos'[a<30::2])
|
import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
t = int(input())
if t >= 30:
print("Yes")
else:
print("No")
| 1 | 5,738,109,618,408 | null | 95 | 95 |
N = int(input())
tmp = 1000
while N > tmp:
tmp += 1000
print(tmp - N)
|
n = int(input())
rem = n%1000
if rem!=0:rem = 1000 - rem
print(rem)
| 1 | 8,448,074,352,370 | null | 108 | 108 |
def main():
N = input()
len_N = len(N)
K = int(input())
dp = [[[0] * 2 for _ in range(K + 5)] for _ in range(len_N + 5)]
dp[0][0][0] = 1
for i in range(len_N):
tmp = int(N[i])
for j in range(K+1):
# l : 1 => N より小さいことが確定
for l in range(2):
for x in range(10):
if l == 0:
if x > tmp:
continue
elif x == tmp:
if x == 0:
dp[i+1][j][0] += dp[i][j][0]
else:
dp[i+1][j+1][0] += dp[i][j][0]
else:
if x == 0:
dp[i+1][j][1] += dp[i][j][0]
else:
dp[i+1][j+1][1] += dp[i][j][0]
if l == 1:
if x == 0:
dp[i+1][j][1] += dp[i][j][1]
else:
dp[i+1][j+1][1] += dp[i][j][1]
print(dp[len_N][K][0] + dp[len_N][K][1])
if __name__ == "__main__":
main()
|
N,K = map(int,input().split())
A = list(map(int,input().split()))
A = [(a-1) % K for a in A]
S = [0 for i in range(N+1)]
for i in range(1, N+1):
S[i] = (S[i-1] + A[i-1]) % K
kinds = set(S)
counts = {}
ans = 0
for k in kinds:
counts[k] = 0
for i in range(N+1):
counts[S[i]] += 1
if i >= K:
counts[S[i-K]] -= 1
ans += (counts[S[i]] - 1)
print(ans)
| 0 | null | 106,921,814,700,140 | 224 | 273 |
H, N = map(int, input().split())
list_A = list(map(int,input().split()))
sum_list_A = sum(list_A)
if sum_list_A >= H:
print("Yes")
else:
print("No")
|
a = int(input())
b = int(input())
l = [a, b]
if not 1 in l:
print('1')
elif not 2 in l:
print('2')
else:
print('3')
| 0 | null | 94,572,820,857,660 | 226 | 254 |
N = int(input())
A = list(map(int, input().split()))
A_sum = sum(A)
A_squaresum = sum([a ** 2 for a in A])
answer = ((A_sum ** 2 - A_squaresum) // 2) % (10 ** 9 + 7)
print(answer)
|
from collections import defaultdict
import numpy as np
def main():
s = input()
n = len(s)
d = np.zeros(2019,np.int64)
ans = 0
num = 0
pow10 = 1
d[0] = 1
for i in reversed(range(n)):
pow10 = pow10 * 10 % 2019
num += int(s[i]) * pow10
#print(num, num % 2019, i)
mod = num % 2019
ans += d[mod]
d[mod] += 1
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 17,232,643,210,792 | 83 | 166 |
n, k = map(int, input().split())
for i in range(1, 100):
if k ** (i - 1) <= n < k ** i:
print(i)
exit()
|
mod = 998244353
n = int(input())
d = list(map(int,input().split()))
if d[0]!=0 or d[1:].count(0)!=0:
print(0)
exit()
l = [0 for i in range(n)]
for i in d:
l[i] += 1
cou = 1
if 0 in l:
a = l.index(0)
if sum(l[a:])!=0:
print(0)
exit()
for i in range(n-2):
if l[i+1]!=0:
a = l[i]
b = l[i+1]
cou *= (a**b)%mod
print(cou%mod)
| 0 | null | 109,792,147,127,418 | 212 | 284 |
# https://atcoder.jp/contests/abc157/tasks/abc157_e
from string import ascii_lowercase
from bisect import bisect_left, insort
from collections import defaultdict
N = int(input())
S = list(input())
Q = int(input())
locs = {c: [] for c in ascii_lowercase}
for i in range(N):
locs[S[i]].append(i + 1)
for _ in range(Q):
qt, l, r = input().split()
l = int(l)
if int(qt) == 1:
if S[l - 1] != r:
locs[S[l - 1]].remove(l)
S[l - 1] = r
insort(locs[r], l)
else:
count = 0
r = int(r)
for ch in ascii_lowercase:
if len(locs[ch]) > 0:
left = bisect_left(locs[ch], l)
if left != len(locs[ch]):
if locs[ch][left] <= r:
count += 1
print(count)
|
#!python3
import sys
from bisect import bisect, insort_left
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
S = list(input())
Q = int(input())
c0 = ord('a')
S1 = [[] for i in range(26)]
for i, c1 in enumerate(S):
ci = ord(c1) - c0
S1[ci].append(i)
ans = []
for cmd, i, j in (line.split() for line in sys.stdin):
i = int(i) - 1
if cmd == "1":
if S[i] == j:
continue
c1 = ord(S[i]) - c0
s1 = S1[c1]
s1.pop(bisect(s1, i)-1)
S[i] = j
c1 = ord(j) - c0
insort_left(S1[c1], i)
elif cmd == "2":
j = int(j) - 1
num = 0
for s1 in S1:
ls = len(s1)
k = bisect(s1, i-1, 0, ls)
if k == ls:
continue
if i <= s1[k] <= j:
num += 1
ans.append(num)
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| 1 | 62,449,284,134,832 | null | 210 | 210 |
n=int(input())
list=[[0]*n]
list=input().split()
for i in range(n):
list[i]=int(list[i])
yen=1000
stock=0
keikou=0
for i in range(1,n):
if list[i]-list[i-1]<=0:
keikou+=1
if keikou!=n-1:
for t in range(1,n):
if list[t]-list[t-1]>=0:
stock+=int(yen/list[t-1])
yen-=list[t-1]*int(yen/list[t-1])
yen+=list[t]*stock
stock=0
print(yen)
|
import sys
input = sys.stdin.readline
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
n,m,l=map(int,input().split())
ans=[[0]*n for i in range(n)]
for i in range(m):
a,b,c=[int(j) for j in input().split()]
ans[a-1][b-1]=c
ans[b-1][a-1]=c
q=int(input())
st=[]
for i in range(q):
st.append([int(j)-1 for j in input().split()])
ans=floyd_warshall(ans)
for i in range(n):
for j in range(n):
if ans[i][j]<=l:
ans[i][j]=1
else:
ans[i][j]=0
ans=floyd_warshall(ans)
for i,j in st:
if ans[i][j]==float("inf"):
print(-1)
else:
print(int(ans[i][j])-1)
| 0 | null | 90,124,250,527,922 | 103 | 295 |
from collections import deque
k=int(input())
ans=deque([1,2,3,4,5,6,7,8,9])
for i in range(k):
p=ans.popleft()
if i==k-1:
print(p)
q=p%10
if q==0:
ans.append(10*p+0)
ans.append(10*p+1)
elif q==9:
ans.append(10*p+8)
ans.append(10*p+9)
else:
ans.append(10*p+q-1)
ans.append(10*p+q)
ans.append(10*p+q+1)
|
s = input()
h = 'hi'
if s == h or s == h * 2 or s == h * 3 or s == h * 4 or s == h * 5:
print('Yes')
else:
print('No')
| 0 | null | 46,672,413,832,254 | 181 | 199 |
n = int(input())
lst = [ int(i) for i in input().split() ]
visited = {}
for d in lst:
if d in visited.keys():
visited[d] += 1
else:
visited[d] = 1
count = 0
for d in visited.keys():
count += int(visited[d]*(visited[d]-1)/2)
for d in lst:
v = visited[d] - 1
ans = count - v
print(ans)
|
N = int(input())
D = list(map(int, input().split()))
DL = [0] * N
mod = 998244353
if D[0] != 0:
print(0)
exit()
for d in D:
DL[d] += 1
if DL[0] != 1:
print(0)
exit()
ans = 1
for i in range(1, N):
if DL[i] == 0:
if sum(DL[i:]) != 0:
print(0)
exit()
else:
print(ans%mod)
exit()
ans *= pow(DL[i-1], DL[i], mod)
ans %= mod
print(ans % mod)
| 0 | null | 101,131,183,306,308 | 192 | 284 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = map(int, input().split())
C = list(map(int, input().split()))
dp = [f_inf] * (n + 1)
dp[0] = 0
for c in C:
for i in range(1, n + 1):
if i - c >= 0:
dp[i] = min(dp[i], dp[i - c] + 1)
print(dp[-1])
if __name__ == '__main__':
resolve()
|
N,M=list(map(int,input().split()))
C=list(map(int,input().split()))
dp = [[0]*len(C) for n in range(N+1)] #dp[n][c]
for n in range(1,N+1):
dp[n][0] = n
for n in range(1,N+1):
for c in range(1,len(C)):
if C[c] > n:
dp[n][c]=dp[n][c-1]
else:
dp[n][c]=min(dp[n][c-1],dp[n-C[c]][c]+1)
print(dp[-1][-1])
| 1 | 145,008,355,342 | null | 28 | 28 |
from copy import copy
n = int(input())
a_ls = list(map(int, input().split()))
c_bin = [[0]*60 for _ in range(n)]
a_bin_ls = [[0]*60 for _ in range(n)]
now_bin = [0] * 60
for i in range(n-1,-1,-1):
a = a_ls[i]
j = 0
while True:
if a == 1:
now_bin[j] += 1
a_bin_ls[i][j] = 1
break
elif a == 0:
break
a,r = divmod(a,2)
now_bin[j] += r
a_bin_ls[i][j] = r
j += 1
c_bin[i] = copy(now_bin)
ans_bin = [0]*60
for i in range(n-1):
a_bin = a_bin_ls[i]
for j in range(60):
if a_bin[j] == 0:
times = c_bin[i+1][j]
else:
times = n - (i+1) - c_bin[i+1][j]
ans_bin[j] += times
ans = 0
mod = 10**9+7
for i in range(60):
ans += 2**i * (ans_bin[i]%mod)
ans %= mod
print(ans)
|
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(input())
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
x = 1
ans = 0
for i in range(60):
ones = 0
zeros = 0
for a in A:
if a & (1 << i) > 0:
ones += 1
else:
zeros += 1
ans += (ones * zeros * x) % MOD
x *= 2
print(ans % MOD)
| 1 | 123,012,135,203,848 | null | 263 | 263 |
def main():
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
l = ["" for i in range(K)]
s = 0
for i in range(N):
# print(l)
if l[i%K] == T[i]:
l[i%K]=""
continue
if l[i%K] == "":
if T[i] == "r":
s = s+P
l[i%K] = "r"
elif T[i] == "s":
s = s+R
l[i%K] = "s"
else:
s = s+S
l[i%K] = "p"
elif T[i]=="r":
s = s+P
l[i%K] = "r"
elif T[i]=="s":
s = s+R
l[i%K] = "s"
else:
s = s+S
l[i%K] = "p"
print(s)
if __name__ == "__main__":
main()
|
from collections import deque
area = input()
S1 = deque()
S2 = deque()
total = 0
for i, v in enumerate(area):
if v == '\\':
S1.append(i)
elif v == '/' and S1:
j = S1.pop()
subtotal = i - j
total += i - j
while S2 and S2[-1][0] > j:
subtotal += S2.pop()[1]
S2.append([j, subtotal])
print(total)
print(len(S2), *(subtotal for j, subtotal in S2))
| 0 | null | 53,304,370,287,910 | 251 | 21 |
# import numpy as np
import sys, math, heapq
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
H, W, M = map(int, input().split())
hw = [list(map(int, input().split())) for _ in range(M)]
hb = defaultdict(int)
wb = defaultdict(int)
bomb = defaultdict(int)
for hwi in hw:
h, w = hwi
hb[h] += 1
wb[w] += 1
bomb[(h, w)] += 1
# print(hb, wb)
mhb = max(hb.values())
mwb = max(wb.values())
maxh = [key for key, val in hb.items() if val == mhb]
maxw = [key for key, val in wb.items() if val == mwb]
# print(maxh, maxw)
for h in maxh:
for w in maxw:
if bomb[(h, w)] == 0:
print(mhb + mwb)
exit()
print(mhb + mwb - 1)
|
import sys
H,W,M = map(int,input().split())
s = [[int(item) -1 for item in input().split()] for _ in range(M)]
# print(s)
col = [0 for _ in range(H)]
row = [0 for _ in range(W)]
bomb_set = set()
# 各列と行で個数を配列
for i,j in s:
col[i] += 1
row[j] += 1
bomb_set.add((i,j)) # 爆弾のある位置
# print(col)
# print(row)
# print(bomb_set)
max_col = max(col)
max_row = max(row)
# 最大の行と列を配列
max_col_index = []
max_row_index = []
# 最大の行を探す
for i in range(H):
if col[i] == max_col:
max_col_index.append(i)
# 最大の列を探す
for j in range(W):
if row[j] == max_row:
max_row_index.append(j)
# 最大の行と列の組み合わせが爆弾の位置と被っているか確認
for r in max_row_index:
for c in max_col_index:
if (c,r) not in bomb_set:
ans = max_col + max_row
print(ans)
sys.exit()
ans = max_col + max_row -1
print(ans)
| 1 | 4,677,842,128,832 | null | 89 | 89 |
X = int(input())
G = 100
after_year = 0
while X > G:
G += G // 100
after_year += 1
print(after_year)
|
X = int(input())
money = 100
time = 0
while money < X:
time += 1
money = money * 101 // 100
print(time)
| 1 | 27,079,970,073,388 | null | 159 | 159 |
import math
n = int(input())
# 1以外のNの約数
divisors = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
divisors.append(i)
if i ** 2 != n:
divisors.append(n // i)
divisors.sort()
candidates = set()
for k in divisors[1:]:
tmp = n
while True:
if tmp % k != 0:
break
tmp = tmp // k
if (tmp - 1) % k == 0:
candidates.add(k)
# N-1の約数
divisors = []
for i in range(1, int(math.sqrt(n-1)) + 1):
if (n-1) % i == 0:
divisors.append(i)
if i ** 2 != n-1:
divisors.append((n-1) // i)
for k in divisors[1:]:
candidates.add(k)
print(len(candidates))
|
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
s = s()
a = ["SAT", "FRI", "THU","WED","TUE","MON","SUN"]
x = a.index(s) + 1
print(x)
| 0 | null | 87,377,583,219,316 | 183 | 270 |
X= int(input())
if(X>=400 and X<=599):
print(8)
elif(X>599 and X<800):
print(7)
elif(X>=800 and X<1000):
print(6)
elif(X>=1000 and X<1200):
print(5)
elif(X>=1200 and X<1400):
print(4)
elif(X>=1400 and X<1600):
print(3)
elif(X>=1600 and X<1800):
print(2)
elif(X>=1800 and X<2000):
print(1)
|
N, M = map(int, input().split())
S = input()
ans = []
now_pos = N
while now_pos > 0:
next_pos = max(0, now_pos - M)
for i in range(M):
if S[next_pos + i] == "0":
ans.append(now_pos - (next_pos + i))
now_pos = next_pos + i
break
else:
print(-1)
exit()
print(" ".join(map(str, ans[::-1])))
| 0 | null | 72,799,577,517,998 | 100 | 274 |
n = int(input())
c = input()
d = c.count('R')
e = c[:d].count('R')
print(d-e)
|
S = input()
def is_kaibun(s):
l = len(s)
# print('former', s[:int(l/2)])
# print('latter', s[:-(int(l/2))-1:-1])
if s[:int(l/2)] == s[:-(int(l/2))-1:-1]:
return True
else:
return False
if is_kaibun(S):
if is_kaibun(S[:int((len(S)-1)/2)]):
if is_kaibun(S[int((len(S)+3)/2)-1:]):
print('Yes')
exit()
print('No')
| 0 | null | 26,334,440,520,130 | 98 | 190 |
K,N,*A = map(int, open(0).read().split())
ans = []
for i in range(N-1):
ans.append(abs(A[i+1] - A[i]))
ans.append(A[0] + K - A[-1])
ans.sort()
ans.pop()
print(sum(ans))
|
k, n = map(int, input().split())
a = sorted(list(map(int, input().split())))
x = [(a[i]-a[i-1]) for i in range(1,n)]
x.append(k-a[n-1]+a[0])
y=sorted(x)
print(sum(y[:-1]))
| 1 | 43,596,785,290,740 | null | 186 | 186 |
S = list(map(str, input()))
T = list(map(str, input()))
ans = 0
for i in range(len(S)):
if S[i]!=T[i]:
ans += 1
print(ans)
|
s = input()
t = input()
cnt = 0
word = list(s)
answer = list(t)
for i in range(len(s)):
if word[i] != answer[i]:
cnt+=1
print(cnt)
| 1 | 10,472,152,376,312 | null | 116 | 116 |
import sys
import time
import math
import itertools as it
def inpl():
return list(map(int, input().split()))
st = time.perf_counter()
# ------------------------------
N, M = inpl()
H = inpl()
dp = [True] * N
for _ in range(M):
A, B = inpl()
if H[A-1] > H[B-1]:
dp[B-1] = False
elif H[A-1] < H[B-1]:
dp[A-1] = False
else:
dp[A-1] = False
dp[B-1] = False
ans = 0
for i in dp:
if i:
ans += 1
print(ans)
# ------------------------------
ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)
|
n,m=map(int,input().split())
h =list(map(int,input().split()))
cnt = 0
l = [[] for i in range(n)]
for i in range(m):
a,b=map(int,input().split())
l[a-1].append(h[b-1])
l[b-1].append(h[a-1])
for i in range(n):
if l[i] == []:
cnt+=1
elif h[i] > max(l[i]):
cnt +=1
print(cnt)
| 1 | 25,204,332,200,214 | null | 155 | 155 |
def baseConv(n,ro,ri=10):
n = int(str(n),base=ri)
s = ""
nums = "0123456789abcdefghijklmnopqrstuvwxyz"
while n:
s += nums[n%ro]
n //= ro
return s[::-1]
n,k = map(int,input().split())
print(len(baseConv(n,k)))
|
a = [int(s) for s in input().split()]
b = int(a[0] // (a[1] + a[2]))
c = int(a[0] % (a[1] + a[2]))
d = b * a[1]
if c >= a[1]:
d = d + a[1]
else:
d = d + c
print(d)
| 0 | null | 59,949,565,868,068 | 212 | 202 |
S,T = input().split()
print(T,S, sep='')
|
s,t = map(str,input().split())
ts = [t,s]
print("".join(ts))
| 1 | 102,953,678,584,198 | null | 248 | 248 |
def main():
H, W, K = [int(k) for k in input().split(" ")]
C = []
black_in_row = []
black_in_col = [0] * W
for i in range(H):
C.append(list(input()))
black_in_row.append(C[i].count("#"))
for j in range(W):
if C[i][j] == "#":
black_in_col[j] += 1
black = sum(black_in_row)
if black < K:
print(0)
return 0
cnt = 0
for i in range(2 ** H):
row_bit = [f for f, b in enumerate(list(pad_zero(format(i, 'b'), H))) if b == "1"]
r = sum([black_in_row[y] for y in row_bit])
for j in range(2 ** W):
col_bit = [f for f, b in enumerate(list(pad_zero(format(j, 'b'), W))) if b == "1"]
c = sum([black_in_col[x] for x in col_bit])
bl = black - r - c + sum([1 for p in row_bit for q in col_bit if C[p][q] == "#"])
if bl == K:
cnt += 1
print(cnt)
def pad_zero(s, n):
s = str(s)
return ("0" * n + s)[-n:]
main()
|
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
def main():
l,r,d=MI()
ans=(r-l)//d
a=l+ans*d
if r//d*d==-(-a//d)*d:
ans+=1
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 8,296,406,681,500 | 110 | 104 |
from sys import stdin
rs = stdin.readline
ri = lambda : int(rs())
ril = lambda : list(map(int, rs().split()))
def main():
N = ri()
c = rs()
x = 0
y = c.count('R')
for e in c:
if x == y:
break
elif e == 'W':
x += 1
else:
y -= 1
print(y)
if __name__ == '__main__':
main()
|
N = int(input())
ary = [int(_) for _ in input().split()]
def selection_sort(ary, verbose=True):
count = 0
for i in range(0, N):
minj = i
for j in range(i, N):
if ary[j] < ary[minj]:
minj = j
if i != minj:
ary[i], ary[minj] = ary[minj], ary[i]
count += 1
print(' '.join([str(_) for _ in ary]))
if verbose:
print(count)
selection_sort(ary)
| 0 | null | 3,206,407,288,214 | 98 | 15 |
from sys import stdin, maxsize
def stdinput():
return stdin.readline().strip()
def main():
n = int(stdinput())
*A, = map(int, stdinput().split(' '))
o = mergeSort(A, 0, n)
print(*A)
print(o)
def merge(A, left, mid, right):
L = A[left:mid]
R = A[mid:right]
cap = maxsize
L.append(cap)
R.append(cap)
i = j = 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
return i + j
def mergeSort(A, left, right):
o = 0
if left + 1 < right:
mid = (left + right) // 2
o += mergeSort(A, left, mid)
o += mergeSort(A, mid, right)
o += merge(A, left, mid, right)
return o
if __name__ == '__main__':
main()
# import cProfile
# cProfile.run('main()')
|
W,H,x,y,r=[int(x) for x in input().split()]
print("No" if x < r or y < r or (x+r) > W or (y+r) > H else "Yes")
| 0 | null | 275,177,565,238 | 26 | 41 |
import math
shuu = input()
num = int(shuu)
ganpon = 100000
i = 1
while i <= num:
ganpon *= 1.05
ganpon /= 1000
ganpon = math.ceil(ganpon)
ganpon *= 1000
i += 1
pass
#ganpon /= 1000
#ganpon = math.ceil(ganpon)
#ganpon *= 100000
print(ganpon)
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def main():
week = int(input())
base = 100000
x = base
for i in range(week):
x = round(x * 1.05)
if x % 1000 > 0:
x = (x // 1000) *1000 +1000
print(x)
if __name__ == '__main__':
main()
| 1 | 941,129,540 | null | 6 | 6 |
n=int(input())
num=[0]*60001
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
i=x*x+y*y+z*z+x*y+y*z+z*x
if i <= n:
num[i]+=1
for i in range(n):
print(num[i+1])
|
from collections import deque
import sys
input = sys.stdin.readline
n = int(input())
doubly_linked_list = deque()
for _ in range(n):
command = input().split()
if command[0] == "insert":
doubly_linked_list.appendleft(command[1])
elif command[0] == "delete":
try:
doubly_linked_list.remove(command[1])
except:
pass
elif command[0] == "deleteFirst":
doubly_linked_list.popleft()
elif command[0] == "deleteLast":
doubly_linked_list.pop()
print(" ".join(doubly_linked_list))
| 0 | null | 4,073,019,758,678 | 106 | 20 |
n = int(input())
a = list(map(int, input().split()))
dic = {}
ans = ''
for i in range(n):
dic[a[i]] = i+1
for i in range(n):
ans = ans + str(dic[i+1]) + ' '
print(ans)
|
if __name__ == '__main__':
N = int(input())
A = list(map(int, input().split()))
D = [0]*(N)
for i, a in enumerate(A):
D[a-1] = i+1
print(*D)
| 1 | 180,747,744,084,128 | null | 299 | 299 |
h1, m1, h2, m2, k = map(int, input().split())
if m1 <= m2:
h = h2 - h1
m = m2 - m1
else:
h = h2 - h1 - 1
m = m2 - m1 + 60
m += 60 * h
print(m - k)
|
N = int(input())
A = [int(x) for x in input().split()]
B = [0]*(N+1)
if N == 0:
if A[0] != 1:
print(-1)
exit()
else:
print(1)
exit()
if A[0] != 0:
print(-1)
exit()
else:
B[0] = 1
C = [0]*(N+1)
C[0] = 1
for i in range(1,N+1):
C[i] = 2*(C[i-1] - A[i-1])
if C[i] < A[i]:
print(-1)
exit()
#print(C)
for i in range(N, 0, -1):
if i == N:
B[i] = A[i]
else:
B[i] = min(A[i]+B[i+1], C[i])
print(sum(B))
| 0 | null | 18,498,569,263,012 | 139 | 141 |
S = input()
l1 = []
l2 = []
total_area = 0
for i, j in enumerate(S):
if j == '\\':
l1.append(i)
elif j == '/' and l1:
i_p = l1.pop()
v = i -i_p
total_area += v
while l2 and l2[-1][0] > i_p:
v += l2.pop()[1]
l2.append([i_p, v])
ans = [str(len(l2))] + [str(k[1]) for k in l2]
print(total_area)
print(' '.join(ans))
|
import collections
import sys
S1 = collections.deque()
S2 = collections.deque()
S3 = collections.deque()
for i, j in enumerate(sys.stdin.readline()):
if j == '\\':
S1.append(i)
elif j == '/':
if S1:
left_edge = S1.pop()
new_puddle = i - left_edge
while True:
if S2:
if S2[-1] > left_edge:
S2.pop()
new_puddle += S3.pop()
else:
break
else:
break
S2.append(left_edge)
S3.append(new_puddle)
else:
pass
print(sum(S3))
print(len(S3), *S3)
| 1 | 60,106,651,426 | null | 21 | 21 |
k = int(input())
score = list(map(int,input().split()))
answer = k - (score[0] % k)
if score[0]%k == 0:
print('OK')
elif answer + score[0] <= score[1]:
print('OK')
else:
print('NG')
|
K = int(input())
A, B = map(int, input().split())
check = A
#print(check%K)
while check <= B:
if check%K == 0:
print("OK")
exit()
else:
check += 1
print("NG")
| 1 | 26,582,007,517,000 | null | 158 | 158 |
h,a = map(int,input().split())
h -= 1
print(1 + h // a)
|
from decimal import Decimal
A,B=input().split()
A=int(A)
B=Decimal(B)
Bint=int(B)
B1=int((B-Bint)*100)
result=A*Bint+A*B1//100
print(result)
| 0 | null | 46,625,944,773,720 | 225 | 135 |
x,k,d = map(int, input().split())
lists = []
x = abs(x)
step = int(x/d)
if step >= k:
answer = x - k * d
elif step < k:
k_left = k - int(step)
if k_left % 2 == 0:
answer = x % d
if k_left % 2 == 1:
answer = min(abs(x % d - d), abs(x % d + d))
print(answer)
|
import sys
from copy import copy, deepcopy
input = sys.stdin.readline
'''
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
for CASES in range(int(input())):
'''
inf = 100000000000000000 # 1e17
mod = 998244353
'''
# example input
'''
def replace(pos, char):
x = pos
old_char = A[x]
while x <= n:
tr[x][old_char] -= 1
x += x & (-x)
x = pos
while x <= n:
tr[x][char] += 1
x += x & (-x)
A[pos] = char
def query(pos, char):
x = pos
sum = 0
while x != 0:
sum += tr[x][char]
x -= x & (-x)
return sum
n = int(input())
S = input().strip()
A = [27] * (n + 1)
'''
for i in range(len(S)):
A.append(ord(S[i])-ord('a'))
'''
tr = [[0] * 30 for i in range(len(S) + 10)]
for i in range(len(S)):
replace(i + 1, ord(S[i]) - ord('a'))
q = int(input())
for i in range(q):
QUERY = list((input().split()))
if int(QUERY[0]) == 1:
replace(int(QUERY[1]), ord(QUERY[2]) - ord('a'))
else:
sum = 0
for char in range(ord('a'), ord('z') + 1):
num = query(int(QUERY[2]), char - ord('a')) - \
query(int(QUERY[1]) - 1, char - ord('a'))
if num >= 1:
sum += 1
print(sum)
| 0 | null | 33,825,299,683,790 | 92 | 210 |
n = int(raw_input())
C = {'S':range(13), 'H':range(13), 'C':range(13), 'D':range(13)}
for i in range(n):
suit, num = raw_input().split()
num = int(num)
C[suit][num-1] = 14
for i in ['S', 'H', 'C', 'D']:
for j in range(13):
if C[i][j] != 14:
print "%s %d" %(i, j+1)
|
from collections import OrderedDict
d = OrderedDict()
d['S'] = set()
d['H'] = set()
d['C'] = set()
d['D'] = set()
a = frozenset(range(1,14))
n = int(input())
for i in range(n):
s, r = input().split()
d[s].add(int(r))
for k, v in d.items():
racks = a.difference(v)
for rack in racks:
print(k, rack)
| 1 | 1,058,186,491,968 | null | 54 | 54 |
import sys
input = sys.stdin.readline
n, m, l = map(int, input().split())
INF = float("INF")
d = [[INF] * n for _ in range(n)]
for i in range(n):
d[i][i] = 0
for i in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
d[a][b] = c
d[b][a] = c
for k in range(n):
for i in range(n):
for j in range(n):
if d[i][j] > d[i][k] + d[k][j]:
d[i][j] = d[i][k] + d[k][j]
# print()
# print(*d, sep='\n')
for i in range(n):
for j in range(n):
if i == j:
continue
if d[i][j] <= l:
d[i][j] = 1
else:
d[i][j] = INF
for k in range(n):
for i in range(n):
for j in range(n):
if d[i][j] > d[i][k] + d[k][j]:
d[i][j] = d[i][k] + d[k][j]
# print()
# print(*d, sep='\n')
q = int(input())
for i in range(q):
s, t = map(int, input().split())
s -= 1
t -= 1
if d[s][t] == INF:
print(-1)
else:
print(d[s][t]-1)
|
N = int(input())
A = list(map(int,input().split()))
count = 0
for i in range(0,N,2):
if A[i]%2 != 0:
count += 1
print(count)
| 0 | null | 90,634,185,747,040 | 295 | 105 |
import math
n = int(input())
A = list(map(int, input().split()))
cnt = 0
inf = 10**9
def merge(A,left,mid,right):
global cnt
L = A[left:mid] + [inf]
R = A[mid:right] + [inf]
i = 0
j = 0
for k in range(left,right):
cnt += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
def mergeSort(A,left,right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A,left,mid)
mergeSort(A,mid,right)
merge(A,left,mid,right)
mergeSort(A,0,n)
print(*A)
print(cnt)
|
def merge(a, left, mid, right):
L = a[left:mid] + [INF]
R = a[mid:right] + [INF]
i = 0
j = 0
for k in range(left, right):
global idx
idx += 1
if( L[i] <= R[j] ):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def merge_sort(a, left, right):
if( left + 1 < right ):
mid = (left + right) // 2
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
INF = 1000000000
idx = 0
n = int(input())
a = [int(i) for i in input().split()]
merge_sort(a,0,len(a))
print(*a)
print(idx)
| 1 | 114,109,216,842 | null | 26 | 26 |
c,d = list(map(int,input().split()))
if d>c:
a = d
b = c
else:
a = c
b = d
def gcd(x,y):
if y == 0:
return x
else:
r = x%y
return gcd(y,r)
print(gcd(a,b))
|
# ABC 148 D
N=int(input())
A=list(map(int,input().split()))
K=1
dest=0
for a in A:
if a==K:
K+=1
else:
dest+=1
print(dest if K>1 else -1)
| 0 | null | 57,386,976,976,160 | 11 | 257 |
########関数部分##############
def Base_10_to_n(X, n):
if (int(X/n)):
return Base_10_to_n(int(X/n), n)+str(X%n)
return str(X%n)
############################
#####関数をつかってみる．#####
######今回は二進数に変換######
n, k = map(int, input().split())
x10 = n
x2 = Base_10_to_n(x10, k)
ans = str(x2)
print(len(ans))
|
import sys
#fin = open("test.txt", "r")
fin = sys.stdin
while True:
[m, f, r] = list(map(int, fin.readline().split()))
if m == -1 and f == -1 and r == -1:
break
sum_mf = m + f
if m == -1 or f == -1:
print("F")
elif sum_mf >= 80:
print("A")
elif sum_mf >= 65:
print("B")
elif sum_mf >= 50:
print("C")
elif sum_mf >= 30:
if r >= 50:
print("C")
else:
print("D")
else:
print("F")
| 0 | null | 32,956,832,960,858 | 212 | 57 |
INFTY=1000000000
n=int(input())
A=list(map(int,input().split()))
def merge(A,left,mid,right):
cnt=0
n1=mid-left
n2=right-mid
L=[A[left+i] for i in range(n1)]
R=[A[mid+i] for i in range(n2)]
L.append(INFTY)
R.append(INFTY)
i=0
j=0
for k in range(left,right):
cnt+=1
if L[i]<=R[j]:
A[k]=L[i]
i+=1
else:
A[k]=R[j]
j+=1
return cnt
def mergeSort(A,left,right):
if left+1<right:
mid=(left+right)//2
cnt1=mergeSort(A,left,mid)
cnt2=mergeSort(A,mid,right)
return merge(A,left,mid,right)+cnt1+cnt2
return 0
cnt=mergeSort(A,0,n)
print(' '.join(map(str,A)))
print(cnt)
|
import sys
input = sys.stdin.readline
MAX = 500000
SENTINEL = 2000000000
L = [0]*(MAX//2 + 2)
R = [0]*(MAX//2 + 2)
cnt = 0
def Merge(A,n,left,mid,right,cnt):
n1 = mid - left
n2 = right - mid
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = SENTINEL
R[n2] = SENTINEL
L_i = 0
R_i = 0
for k in range(left,right):
cnt += 1
if L[L_i] <= R[R_i]:
A[k] = L[L_i]
L_i += 1
else:
A[k] = R[R_i]
R_i += 1
return cnt
def MergeSort(A,n,left,right,cnt):
if left + 1 < right:
mid = (left + right)//2
cnt = MergeSort(A,n,left,mid,cnt)
cnt = MergeSort(A,n,mid,right,cnt)
cnt = Merge(A,n,left,mid,right,cnt)
return cnt
if __name__ == "__main__":
n = int(input())
array = list(map(int,input().split()))
cnt = 0
SENTINEL = 2*10**9
cnt = MergeSort(array,n,0,n,cnt)
print(" ".join(map(str,array)))
print(cnt)
| 1 | 116,644,407,488 | null | 26 | 26 |
N = int(input())
b = list(map(int, input().split()))
MOD = 1000000007
sum_n = 0
a = []
for i in b:
a.append(i%MOD)
sum_sum = sum(a[1:])
for i in range(N):
sum_n = (sum_n + (a[i] * sum_sum) % MOD) % MOD
if i+1 < N:
sum_sum = sum_sum - a[i+1]
print(sum_n % MOD)
|
import itertools
N = int(input())
A = list(map(int, input().split()))
MOD = 10**9+7
A.sort()
ac = list(itertools.accumulate(A))
ans = 0
for i in range(N):
ans += A[i]*(ac[-1]-ac[i])
print(ans % MOD)
| 1 | 3,832,207,457,132 | null | 83 | 83 |
s=input()
print("Yes"if s==input()[:-1]else"No")
|
#A
S=input()
T=input()
ans='No'
if S != T:
if S==T[:(len(S))]:
if T[-1].islower():
ans='Yes'
print(ans)
| 1 | 21,501,455,857,090 | null | 147 | 147 |
def main():
S = input()
T = input()
l_s = len(S)
l_t = len(T)
cnt_list = []
for i in range(l_s - l_t + 1):
cnt = 0
S_ = S[i: i+l_t]
for j in range(l_t):
if S_[j] != T[j]:
cnt += 1
cnt_list.append(cnt)
ans = min(cnt_list)
print(ans)
return
if __name__ == '__main__':
main()
|
n = int(input())
lis = list(map(int, input().split()))
m = 0
for a in lis:
m = m ^ a
for a in lis:
print(m ^ a, end=" ")
| 0 | null | 8,052,239,822,596 | 82 | 123 |
n = int(input())
tenant = [
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ]
]
for i in range(n):
b,f,r,nu = map(int, input().split())
tenant[b-1][f-1][r-1] += nu
for b in range(4):
for f in range(3):
print(' ', end='')
print(' '.join(map(str,tenant[b][f])))
if b < 3:
print('#'*20)
|
A = [[[0 for i in range(10)] for i in range(3)] for i in range(4)]
info = int(input())
for i in range(info):
b,f,r,v = [int(i) for i in input().split()]
A[b-1][f-1][r-1] += v
if A[b-1][f-1][r-1] < 0:
A[b-1][f-1][r-1] = 0
elif A[b-1][f-1][r-1] > 9:
A[b-1][f-1][r-1] = 9
for i in range(3):
print(' '+' '.join([str(i) for i in A[0][i]]))
print('#'*20)
for i in range(3):
print(' '+' '.join([str(i) for i in A[1][i]]))
print('#'*20)
for i in range(3):
print(' '+' '.join([str(i) for i in A[2][i]]))
print('#'*20)
for i in range(3):
print(' '+' '.join([str(i) for i in A[3][i]]))
| 1 | 1,077,328,741,850 | null | 55 | 55 |
n = int(input())
m = (n + 1) // 2
print(m)
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
h1,m1,h2,m2,K = map(int, readline().split())
wakeup = h1 * 60 + m1
sleep = h2 * 60 + m2
ans = sleep - K - wakeup
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 38,489,886,268,252 | 206 | 139 |
import sys
input = sys.stdin.readline
# B - An Odd Problem
N = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(N):
if i % 2 == 0:
if a[i] % 2 == 1:
ans += 1
print(ans)
|
import sys
#DEBUG=True
DEBUG=False
if DEBUG:
f=open("202007_2nd/B_input.txt")
else:
f=sys.stdin
N=int(f.readline().strip())
A=list(map(int,f.readline().split()))
ans=0
for _ in range(N):
ans=ans+1 if (_+1)%2 and (A[_]%2) else ans
print(ans)
f.close()
| 1 | 7,776,356,868,588 | null | 105 | 105 |
N = int(input())
a = list(map(int, input().split()))
num0 = 0
num1 = sum(a)
ans = 10**10
for i in range(0, N):
num0 += a[i]
num1 -= a[i]
if ans > abs(num1-num0):
ans = abs(num1-num0)
print(ans)
|
import queue
from collections import namedtuple
T = namedtuple("T", "u d")
n = int(input())
path = dict()
ans = [-1] * (n + 1)
for i in range(n):
a = [int(x) for x in input().split()]
a.reverse()
u, k = a.pop(), a.pop()
path[u] = set()
for j in range(k):
path[u].add(a.pop())
def bfs(s):
q = queue.Queue()
q.put(s)
while q.qsize() != 0:
p = q.get()
if p.d < ans[p.u] or ans[p.u] < 0:
ans[p.u] = p.d
for r in path[p.u]:
q.put(T(r, p.d + 1))
bfs(T(1, 0))
for i in range(1, n + 1):
print(i, ans[i])
| 0 | null | 70,795,672,731,258 | 276 | 9 |
def read_a(n, m):
A = []
for _ in range(0, n):
A.append([int(x) for x in input().split()])
return A
def read_b(m):
B = []
for _ in range(0, m):
B.append(int(input()))
return B
def multiply(A, B):
C = []
for a in A:
C.append(sum(map(lambda x, y:x*y, a, B)))
return C
def main():
n, m = [int(x) for x in input().split()]
A = read_a(n, m)
B = read_b(m)
C = multiply(A, B)
print("\n".join([str(x) for x in C]))
if __name__ == '__main__':
main()
|
n,m = map(int,input().split())
mat = list()
vec = list()
ans = [0 for _ in range(n)]
for _ in range(n):
mat.append(list(map(int,input().split())))
for _ in range(m):
vec.append(int(input()))
for i in range(n):
for j in range(m):
ans[i] += mat[i][j]*vec[j]
for k in ans :
print(k)
| 1 | 1,158,550,150,784 | null | 56 | 56 |
n=int(input())
cnt=0
ans=0
for i in range(1,n+1):
cnt+=1
if i%2==1:
ans+=1
print(ans/cnt)
|
n = int(input())
if n%2 == 0:
print(float((n//2)/n))
elif n == 1:
print(float(1))
else:
print(float((n//2 + 1)/n))
| 1 | 177,070,487,272,122 | null | 297 | 297 |
n = int(input())
s = list(input())
s = [ord(i)-97 for i in s]
dic = {}
for i in range(26):
dic[i] = []
for i in range(n):
dic[s[i]].append(i)
for i in range(26):
dic[i].append(float('inf'))
from bisect import bisect_left
q = int(input())
for i in range(q):
x, y, z = input().split()
if x == '1':
y, z = int(y) - 1, ord(z) - 97
p = bisect_left(dic[s[y]], y)
dic[s[y]].pop(p)
dic[z].insert(bisect_left(dic[z], y), y)
s[y] = z
else:
res = 0
y, z = int(y) - 1, int(z) - 1
for i in range(26):
p = dic[i][bisect_left(dic[i], y)]
if p <= z:
res += 1
print(res)
|
class SegmentTree():
"""一点更新、区間取得クエリをそれぞれO(logN)で答えるデータ構造を構築する。
built(array) := arrayを初期値とするセグメント木を構築する O(N)。
update(i, val) := i番目の要素をvalに変更する。
get_val(l, r) := 区間[l, r)に対する二項演算の畳み込みの結果を返す。
"""
def __init__(self, n, op, e):
"""要素数、二項演算、単位元を引数として渡す
例) 区間最小値 SegmentTree(n, min, 10 ** 18)
区間和 SegmentTree(n, lambda a, b : a + b, 0)
"""
self.n = n
self.op = op
self.e = e
self.size = 2 ** ((n - 1).bit_length())
self.node = [self.e] * (2 * self.size)
def build(self, array):
"""arrayを初期値とするセグメント木を構築する"""
for i in range(self.n):
self.node[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.node[i] = self.op(self.node[i << 1], self.node[(i << 1) + 1])
def update(self, i, val):
"""i番目の要素をvalに変更する"""
i += self.size
self.node[i] = val
while i > 1:
i >>= 1
self.node[i] = self.op(self.node[i << 1], self.node[(i << 1) + 1])
def get_val(self, l, r):
"""[l, r)の畳み込みの結果を返す"""
l, r = l + self.size, r + self.size
res_l, res_r = self.e, self.e
while l < r:
if l & 1:
res_l = self.op(res_l, self.node[l])
l += 1
if r & 1:
r -= 1
res_r = self.op(self.node[r], res_r)
l, r = l >> 1, r >> 1
return self.op(res_l, res_r)
ALPH = "abcdefghijklmnopqrstuvwxyz"
to_int = {char: i for i, char in enumerate(ALPH)}
n = int(input())
s = input()
q = int(input())
query = [list(input().split()) for i in range(q)]
init = [0] * n
for i, char in enumerate(s):
init[i] = 1 << to_int[char]
op = lambda a, b: a | b
st = SegmentTree(n, op, 0)
st.build(init)
for i in range(q):
if query[i][0] == "1":
_, ind, char = query[i]
ind = int(ind) - 1
st.update(ind, 1 << to_int[char])
else:
_, l, r = query[i]
l, r = int(l) - 1, int(r)
print(bin(st.get_val(l, r)).count("1"))
| 1 | 62,571,535,563,520 | null | 210 | 210 |
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
b = 0
tb = 0
for i in range(M):
if tb + B[i] > K:
break
tb += B[i]
b = i+1
ans = [0, b]
m = b
a = 0
ta = 0
for i in range(N):
if ta + A[i] > K:
break
a = i+1
ta += A[i]
while True:
if ta + tb > K:
if b == 0:break
b -= 1
tb -= B[b]
else:
if a + b > m:
m = a + b
ans = [a, b]
break
print(ans[0]+ans[1])
|
N, M, K = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min = 0
cnt = 0
for k in b:
min += k
j = M
for i in range(N+1):
while(j > 0 and min > K):
j -= 1
min -= b[j]
if(min > K):
break
cnt = max(cnt, i + j)
if(i == N):
break
min += a[i]
print(cnt)
| 1 | 10,720,611,266,354 | null | 117 | 117 |
N = input()
over = 1
eq = 0
for n in map(int, N):
o = min(eq + n + 1, over + (10 - n) - 1)
e = min(eq + n, over + (10 - n))
over = o
eq = e
print(eq)
|
N = input()
n = len(N)
dp = [[0,0]for i in range(0,n,1)]#[i][0]その桁はピッタリ払う[i][1]一つ上の桁を１枚つかう ときの合計枚数
dp[n-1][0] = int(N[n-1])
dp[n-1][1] = int(10 - int(N[n-1]) + 1 )#一つ上の桁で払うandおつり
for i in range(n-2,-1,-1):
dp[i][0] = int(N[i]) + min(dp[i+1][0],dp[i+1][1])
dp[i][1] = 10 - int(N[i]) + 1 + min(dp[i+1][0],dp[i+1][1] - 2)#次の桁で払った、の＋１を取り消すマイナス１と繰り下がりの
print(min(dp[0][0],dp[0][1]))
| 1 | 71,160,902,505,612 | null | 219 | 219 |
N = int(input())
a = list(map(int, input().split()))
num = 1
cnt = 0
for i in range(N):
if a[i] == num:
num += 1
else:
cnt += 1
if cnt == N:
print(-1)
else:
print(cnt)
|
total_people, min_height = map(int, input().split())
height = map(int, input().split())
rideable_people = 0
for i in height:
if i >= min_height:
rideable_people += 1
print(rideable_people)
| 0 | null | 146,896,267,377,948 | 257 | 298 |
X, Y = map(int, input().split())
if X>=2*Y:
print(X-2*Y)
else:
print(0)
|
a,b = map(int,input().split())
ans = a-b*2
if ans<=0:
print(0);exit()
else:
print(ans)
| 1 | 166,563,429,517,760 | null | 291 | 291 |
while True:
line = input()
if line == '0':
break
n = 0
for c in line:
n += int(c)
print(n)
|
while True:
line = input()
if line == '0':
break
print(sum(map(int, list(line))))
| 1 | 1,592,681,833,106 | null | 62 | 62 |
import sys
input = sys.stdin.readline
def print_ans(X):
"""Test Case
>>> print_ans(30)
Yes
>>> print_ans(25)
No
>>> print_ans(35)
Yes
>>> print_ans(-10)
No
"""
if X >= 30:
print('Yes')
else:
print('No')
if __name__ == '__main__':
X = int(input().rstrip())
print_ans(X)
|
x = int(input())
if x >= 30:
ans = 'Yes'
else:
ans = 'No'
print(ans)
| 1 | 5,675,940,416,092 | null | 95 | 95 |
a, b = map(int, input().split())
if a < 10 and b < 10:
print(a * b)
else:
print('-1')
|
x,y,a,b,c = map(int,input().split())
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))
p = sorted(p,reverse=True)
q = sorted(q,reverse=True)
r = sorted(r,reverse=True)
lis = p[:x]
lis.extend(q[:y])
lis = sorted(lis)
#print(lis)
ans = []
lr = len(r)
for i in range(len(lis)):
if i<lr:
ans.append(max(lis[i],r[i]))
else:
ans.append(lis[i])
print(sum(ans))
| 0 | null | 101,293,757,129,620 | 286 | 188 |
n, k = map(int, input().split())
h = list(map(int, input().split()))
h.sort()
ans = len(h)
for height in h:
if height < k:
ans -= 1
else:
print(ans)
exit()
print(ans)
|
n,k=[int(x) for x in input().split()]
d=[int(x) for x in input().split()]
t=[x for x in d if x>=k]
print(len(t))
| 1 | 178,659,254,587,120 | null | 298 | 298 |
n,m,l=map(int,input().split())
g=[[999999999999 if i!=j else 0 for j in range(n)] for i in range(n)]
for i in range(m):
a,b,c=map(int,input().split())
a,b=a-1,b-1
if c>l:
continue
g[a][b]=c
g[b][a]=c
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]
for i in range(n):
for j in range(n):
if g[i][j]<=l:
g[i][j]=1
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]
for i in range(int(input())):
s,t=map(int,input().split())
s-=1
t-=1
print(g[s][t]-1 if g[s][t]-1<99999999999 else -1)
|
N = int(input())
S, T = input().split()
L = [S[i]+T[i] for i in range(N)]
print(*L, sep="")
| 0 | null | 142,388,325,294,748 | 295 | 255 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.