input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
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 = list(map(int, readline().split()))
S = list(map(int, readline().split()))
T = list(map(int, readline().split()))
dp = [[0] * (M + 1) for _ in range(N + 1)]
sdp = [[0] * (M + 2) for _ in range(N + 2)]
dp[0][0] = 1
for i in range(N + 1):
sdp[i][0] = 1
for j in range(M + 1):
sdp[0][j] = 1
for i in range(N):
for j in range(M):
if S[i] == T[j]:
dp[i + 1][j + 1] = sdp[i][j]
sdp[i + 1][j + 1] = (sdp[i][j + 1] + sdp[i + 1][j] - sdp[i][j] + dp[i + 1][j + 1]) % MOD
print((sdp[N][M]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M = list(map(int, readline().split()))
S = list(map(int, readline().split()))
T = list(map(int, readline().split()))
dp = [1] * (M + 1)
for i in range(N):
dp_prev = dp[:]
for j in range(M):
if S[i] == T[j]:
dp[j + 1] = (dp_prev[j + 1] + dp[j]) % MOD
else:
dp[j + 1] = (dp_prev[j + 1] + dp[j] - dp_prev[j]) % MOD
print((dp[M]))
return
if __name__ == '__main__':
main()
| p03003 |
n,m = list(map(int, input().split()))
s = list(map(int, input().split()))
t = list(map(int, input().split()))
PR = 1000000007
dp = [[0 for j in range(m+1)] for i in range(n+1)]
for i in range(n+1):
dp[i][0] = 1
for j in range(m+1):
dp[0][j] = 1
for i in range(n):
for j in range(m):
#aa
sumI = 0
for jj in range(0,j):
if s[i] == t[jj]:
sumI=(sumI + dp[i][jj]) % PR
sumJ = 0
for ii in range(0,i):
if t[j] == s[ii]:
sumJ=(sumJ + dp[ii][j]) % PR
if s[i] == t[j]:
dp[i+1][j+1] = (sumI + sumJ + dp[i][j] + dp[i][j]) % PR
else:
dp[i+1][j+1] = (sumI + sumJ + dp[i][j]) % PR
# print("i: %d j: %d sumI: %d sumJ:%d dp[i][j]:%d" % (i+1,j+1,sumI,sumJ,dp[i+1][j+1]))
#print(dp)
print((dp[n][m])) | n,m = list(map(int, input().split()))
s = list(map(int, input().split()))
t = list(map(int, input().split()))
PR = 1000000007
dp = [[0 for j in range(m+1)] for i in range(n+1)]
for i in range(n+1):
dp[i][0] = 1
for j in range(m+1):
dp[0][j] = 1
for i in range(n):
for j in range(m):
#aa
sumI = 0
sumI = dp[i+1][j]
# for jj in range(0,j):
# if s[i] == t[jj]:
# sumI=(sumI + dp[i][jj]) % PR
sumJ = 0
sumJ = dp[i][j+1]
# for ii in range(0,i):
# if t[j] == s[ii]:
# sumJ=(sumJ + dp[ii][j]) % PR
if s[i] == t[j]:
dp[i+1][j+1] = (sumI + sumJ) % PR
else:
dp[i+1][j+1] = (sumI + sumJ - dp[i][j]) % PR
# print("i: %d j: %d sumI: %d sumJ:%d dp[i][j]:%d" % (i+1,j+1,sumI,sumJ,dp[i+1][j+1]))
#print(dp)
print((dp[n][m]))
| p03003 |
class BIT():
__slots__ = ["func", "e", "n", "data"]
def __init__(self, length_or_list, func, e):
self.func = func
self.e = e
if isinstance(length_or_list, int):
self.n = length_or_list + 1
self.data = [self.e] * self.n
else:
self.n = len(length_or_list) + 1
self.data = [self.e] + length_or_list
for i in range(1, self.n):
if i + (i & -i) < self.n:
self.data[i + (i & -i)] = self.func(self.data[i + (i & -i)], self.data[i])
def point_append(self, index, delta):
index += 1
while index < self.n:
self.data[index] = self.func(self.data[index], delta)
index += index & -index
def prefix_folded(self, end):
res = 0
while end > 0:
res = self.func(res, self.data[end])
end -= end & -end
return res
def main():
import sys
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
N, Q = list(map(int, input().split()))
seg = BIT(list(map(int, input().split())), lambda a, b: a + b, 0)
for _ in range(Q):
a, b, c = list(map(int, input().split()))
if a:
print((seg.prefix_folded(c) - seg.prefix_folded(b)))
else:
seg.point_append(b, c)
if __name__ == "__main__":
main() | class BIT():
__slots__ = ["n", "data"]
def __init__(self, length_or_list):
if isinstance(length_or_list, int):
self.n = length_or_list + 1
self.data = [0] * self.n
else:
self.n = len(length_or_list) + 1
self.data = [0] + length_or_list
for i in range(1, self.n):
if i + (i & -i) < self.n:
self.data[i + (i & -i)] = self.data[i + (i & -i)] + self.data[i]
def point_append(self, index, delta):
index += 1
while index < self.n:
self.data[index] = self.data[index] + delta
index += index & -index
def prefix_folded(self, end):
res = 0
while end > 0:
res += self.data[end]
end -= end & -end
return res
def folded(self, begin, end):
ret = 0
while begin < end:
ret += self.data[end]
end -= end & -end
while end < begin:
ret -= self.data[begin]
begin -= begin & -begin
return ret
def main():
import sys
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
N, Q = list(map(int, input().split()))
seg = BIT(list(map(int, input().split())))
for _ in range(Q):
a, b, c = list(map(int, input().split()))
if a:
print((seg.folded(b, c)))
else:
seg.point_append(b, c)
if __name__ == "__main__":
main() | p02559 |
class BIT():
__slots__ = ["n", "data"]
def __init__(self, length_or_list):
if isinstance(length_or_list, int):
self.n = length_or_list + 1
self.data = [0] * self.n
else:
self.n = len(length_or_list) + 1
self.data = [0] + length_or_list
for i in range(1, self.n):
if i + (i & -i) < self.n:
self.data[i + (i & -i)] += self.data[i]
def point_append(self, index, delta):
index += 1
while index < self.n:
self.data[index] += delta
index += index & -index
def prefix_folded(self, end):
res = 0
while end > 0:
res += self.data[end]
end -= end & -end
return res
def folded(self, begin, end):
ret = 0
while begin < end:
ret += self.data[end]
end -= end & -end
while end < begin:
ret -= self.data[begin]
begin -= begin & -begin
return ret
def main():
import sys
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
N, Q = list(map(int, input().split()))
seg = BIT(list(map(int, input().split())))
for _ in range(Q):
a, b, c = list(map(int, input().split()))
if a:
print((seg.folded(b, c)))
else:
seg.point_append(b, c)
if __name__ == "__main__":
main() | class BIT():
__slots__ = ["n", "data"]
def __init__(self, length_or_list):
if isinstance(length_or_list, int):
self.n = length_or_list + 1
self.data = [0] * self.n
else:
self.n = len(length_or_list) + 1
self.data = [0] + length_or_list
for i in range(1, self.n):
if i + (i & -i) < self.n:
self.data[i + (i & -i)] += self.data[i]
def point_append(self, index, delta):
index += 1
while index < self.n:
self.data[index] += delta
index += index & -index
def prefix_folded(self, end):
res = 0
while end > 0:
res += self.data[end]
end -= end & -end
return res
def folded(self, begin, end):
ret = 0
while begin < end:
ret += self.data[end]
end -= end & -end
while end < begin:
ret -= self.data[begin]
begin -= begin & -begin
return ret
def main():
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
bit = BIT(list(map(int, input().split())))
ans = []
for _ in range(Q):
a, b, c = list(map(int, input().split()))
if a:
ans.append(bit.folded(b, c))
else:
bit.point_append(b, c)
print(('\n'.join(map(str, ans))))
if __name__ == "__main__":
main() | p02559 |
class FenwickTree():
def __init__(self, n):
self.n = n
self.data = [0] * n
def add(self, p, x):
#assert 0 <= p < self.n
p += 1
while p <= self.n:
self.data[p - 1] += x
p += p & -p
def sum(self, r):
s = 0
while r:
s += self.data[r - 1]
r -= r & -r
return s
def range_sum(self, l, r):
#assert 0 <= l <= r <= self.n
return self.sum(r) - self.sum(l)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = tuple(map(int, input().split()))
ft = FenwickTree(N)
res = []
for i in range(N):
ft.add(i, A[i])
for _ in range(Q):
q, x, y = list(map(int, input().split()))
if q:
res.append(str(ft.range_sum(x, y)))
else:
ft.add(x, y)
print(('\n'.join(res))) | class FenwickTree():
def __init__(self, n):
self.n = n
self.data = [0] * n
def add(self, p, x):
#assert 0 <= p < self.n
p += 1
while p <= self.n:
self.data[p - 1] += x
p += p & -p
def sum(self, r):
s = 0
while r:
s += self.data[r - 1]
r -= r & -r
return s
def range_sum(self, l, r):
#assert 0 <= l <= r <= self.n
return self.sum(r) - self.sum(l)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = tuple(map(int, input().split()))
ft = FenwickTree(N)
res = []
for i, a in enumerate(A):
ft.add(i, a)
for _ in range(Q):
q, x, y = list(map(int, input().split()))
if q:
res.append(str(ft.range_sum(x, y)))
else:
ft.add(x, y)
print(('\n'.join(res))) | p02559 |
class FenwickTree():
def __init__(self, n):
self.n = n
self.data = [0] * n
def add(self, p, x):
#assert 0 <= p < self.n
p += 1
while p <= self.n:
self.data[p - 1] += x
p += p & -p
def sum(self, r):
s = 0
while r:
s += self.data[r - 1]
r -= r & -r
return s
def range_sum(self, l, r):
#assert 0 <= l <= r <= self.n
return self.sum(r) - self.sum(l)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = tuple(map(int, input().split()))
ft = FenwickTree(N)
res = []
for i, a in enumerate(A):
ft.add(i, a)
for _ in range(Q):
q, x, y = list(map(int, input().split()))
if q:
res.append(str(ft.range_sum(x, y)))
else:
ft.add(x, y)
print(('\n'.join(res))) | class FenwickTree():
def __init__(self, n):
self.n = n
self.data = [0] * n
def build(self, arr):
#assert len(arr) <= n
for i, a in enumerate(arr):
self.data[i] = a
for i in range(1, self.n + 1):
if i + (i & -i) <= self.n:
self.data[i + (i & -i) - 1] += self.data[i - 1]
def add(self, p, x):
#assert 0 <= p < self.n
p += 1
while p <= self.n:
self.data[p - 1] += x
p += p & -p
def sum(self, r):
s = 0
while r:
s += self.data[r - 1]
r -= r & -r
return s
def range_sum(self, l, r):
#assert 0 <= l <= r <= self.n
return self.sum(r) - self.sum(l)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = tuple(map(int, input().split()))
ft = FenwickTree(N)
ft.build(A)
res = []
for _ in range(Q):
q, x, y = list(map(int, input().split()))
if q:
res.append(str(ft.range_sum(x, y)))
else:
ft.add(x, y)
print(('\n'.join(res))) | p02559 |
import sys
input = lambda: sys.stdin.readline().rstrip()
class BIT:
def __init__(self, n):
self.bit = [0] * n
def add(self, i, x):
i += 1
while i <= len(self.bit):
self.bit[i-1] += x
i += i & -i
def sum_sub(self, i):
a = 0
i += 1
while i:
a += self.bit[i-1]
i -= i & -i
return a
def sum(self, i, j):
a = 0
if j != 0:
a += self.sum_sub(j-1)
if i != 0:
a -= self.sum_sub(i-1)
return a
n,q=list(map(int,input().split()))
a=list(map(int,input().split()))
Bit=BIT(n)
for i in range(n):
Bit.add(i,a[i])
for i in range(q):
t,a,b=list(map(int,input().split()))
if t==0:
Bit.add(a,b)
else:
print((Bit.sum(a,b))) | import sys
input = sys.stdin.readline
class BIT():
def __init__(self, n, data=None):
self.n = n
self.bit = [0] * (self.n + 1)
self.data = [0] * (self.n + 1)
if data:
self.build(data)
def build(self, data):
for i in range(self.n):
self.bit[i + 1] = self.data[i + 1] = data[i]
for i in range(1, self.n):
j = i + (i & (-i))
if j <= self.n:
self.bit[j] += self.bit[i]
def add(self, idx, x):
self.data[idx] += x
while idx <= self.n:
self.bit[idx] += x
idx += (idx & (-idx))
def sum(self, idx):
s = 0
while idx:
s += self.bit[idx]
idx -= (idx & (-idx))
return s
n,q=list(map(int,input().split()))
a=list(map(int,input().split()))
bit=BIT(n,a)
for i in range(q):
t,x,y=list(map(int,input().split()))
if t==0:
bit.add(x+1,y)
else:
print((bit.sum(y)-bit.sum(x))) | p02559 |
import sys
input = sys.stdin.readline
class BIT():
def __init__(self, n, data=None):
self.n = n
self.bit = [0] * (self.n + 1)
self.data = [0] * (self.n + 1)
if data:
self.build(data)
def build(self, data):
for i in range(self.n):
self.bit[i + 1] = self.data[i + 1] = data[i]
for i in range(1, self.n):
j = i + (i & (-i))
if j <= self.n:
self.bit[j] += self.bit[i]
def add(self, idx, x):
self.data[idx] += x
while idx <= self.n:
self.bit[idx] += x
idx += (idx & (-idx))
def sum(self, idx):
s = 0
while idx:
s += self.bit[idx]
idx -= (idx & (-idx))
return s
n,q=list(map(int,input().split()))
a=list(map(int,input().split()))
bit=BIT(n,a)
for i in range(q):
t,x,y=list(map(int,input().split()))
if t==0:
bit.add(x+1,y)
else:
print((bit.sum(y)-bit.sum(x))) | from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))
class BIT():
def __init__(self, n, data=None):
self.n = n
self.bit = [0] * (self.n + 1)
self.data = [0] * (self.n + 1)
if data:
self.build(data)
def build(self, data):
for i in range(self.n):
self.bit[i + 1] = self.data[i + 1] = data[i]
for i in range(1, self.n):
j = i + (i & (-i))
if j <= self.n:
self.bit[j] += self.bit[i]
def add(self, idx, x):
self.data[idx] += x
while idx <= self.n:
self.bit[idx] += x
idx += (idx & (-idx))
def sum(self, idx):
s = 0
while idx:
s += self.bit[idx]
idx -= (idx & (-idx))
return s
#n,q=map(int,input().split())
#a=list(map(int,input().split()))
n,q=nii()
a=lnii()
bit=BIT(n,a)
for i in range(q):
# t,x,y=map(int,input().split())
t,x,y=nii()
if t==0:
bit.add(x+1,y)
else:
print((bit.sum(y)-bit.sum(x))) | p02559 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
# Binary Indexed Tree
# 1-indexed
# sum(r) :閉区間 [0,r] の合計を取得する
# [8] a0 ・ a1 ・ a2 ・ a3 ・ a4 ・ a5 ・ a6 ・ a7
# [4] a0 ・ a1 ・ a2 ・ a3
# [2] a0 ・ a1 [6] a4 ・ a5
# [1] a0 [3] a2 [5] a4 [7] a6
# [1000]
# [0100]
# [0010] [0110]
# [0001] [0011] [0111] [1111]
class BinaryIndexedTree:
# 初期化処理
def __init__(self, size):
self.size = size
self.dat = [0]*(size+1)
def add(self, i, x):
i += 1
while i <= self.size:
self.dat[i] += x
i += i & -i # 更新すべき位置
def sum(self, r):
r += 1
ret = 0
while r>0:
ret += self.dat[r]
r -= r & -r # 加算すべき位置
return ret
def init(self, a):
for i, x in enumerate(a):
self.add(i, x)
def initrng(self, a):
self.add(0, a[0])
for i in range(1,n):
self.add(i, a[i]-a[i-1])
n, q = list(map(int,input().split()))
a = list(map(int, input().split()))
bit = BinaryIndexedTree(n)
bit.init(a)
ret = [bit.sum(i) for i in range(n)]
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
bit.add(u, v)
else:
print((bit.sum(v-1)-bit.sum(u-1)))
| #!/usr/bin python3
# -*- coding: utf-8 -*-
# Binary Indexed Tree
# 1-indexed
# sum(r) :閉区間 [0,r] の合計を取得する
# [8] a0 ・ a1 ・ a2 ・ a3 ・ a4 ・ a5 ・ a6 ・ a7
# [4] a0 ・ a1 ・ a2 ・ a3
# [2] a0 ・ a1 [6] a4 ・ a5
# [1] a0 [3] a2 [5] a4 [7] a6
# [1000]
# [0100]
# [0010] [0110]
# [0001] [0011] [0111] [1111]
class BinaryIndexedTree:
# 初期化処理
def __init__(self, size):
self.size = size
self.dat = [0]*(size+1)
def add(self, i, x):
i += 1
while i <= self.size:
self.dat[i] += x
i += i & -i # 更新すべき位置
def sum(self, r):
r += 1
ret = 0
while r>0:
ret += self.dat[r]
r -= r & -r # 加算すべき位置
return ret
def init(self, a):
for i, x in enumerate(a):
self.add(i, x)
def initrng(self, a):
self.add(0, a[0])
for i in range(1,n):
self.add(i, a[i]-a[i-1])
n, q = list(map(int,input().split()))
a = list(map(int, input().split()))
bit = BinaryIndexedTree(n)
bit.init(a)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
bit.add(u, v)
else:
print((bit.sum(v-1)-bit.sum(u-1)))
| p02559 |
n, q = list(map(int, input().split()))
lst = [int(i) for i in input().split()]
sum_list = [0]
total = 0
for i in range(n):
total += lst[i]
sum_list.append(total)
for _ in range(q):
t, a, b = list(map(int, input().split()))
if t == 0:
for i in range(a + 1, n + 1):
sum_list[i] += b
else:
print((sum_list[b] - sum_list[a]))
| class bit:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def make(self, lst):
self.bit = [0] + lst[:]
for i in range(1, self.size + 1):
if i + (i & -i) > self.size:
continue
self.bit[i + (i & -i)] += self.bit[i]
def add(self, a, b):
i = a + 1
while i <= self.size:
self.bit[i] += b
i += i & -i
def sum(self, a):
i = a
ret = 0
while i > 0:
ret += self.bit[i]
i -= i & -i
return ret
def sub(self, a, b):
return self.sum(b) - self.sum(a)
n, q = list(map(int, input().split()))
lst = [int(i) for i in input().split()]
l = bit(n)
l.make(lst)
for _ in range(q):
t, a, b = list(map(int, input().split()))
if t == 0:
l.add(a, b)
else:
print((l.sub(a, b))) | p02559 |
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * n
def sum(self, i):
s = 0
while i > 0:
s += self.data[i - 1]
i &= i - 1
return s
def update(self, i, x):
while i < self.n:
self.data[i] += x
i |= i + 1
return
n, m = list(map(int, input().split()))
c = list(map(int, input().split()))
b = BIT(n)
for i in range(n):
b.update(i, c[i])
for i in range(m):
t, x, y = list(map(int, input().split()))
if t == 1:
print((b.sum(y) - b.sum(x)))
else:
b.update(x, y)
| import sys
input = lambda: sys.stdin.readline()
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * n
def sum(self, i):
s = 0
while i > 0:
s += self.data[i - 1]
i &= i - 1
return s
def update(self, i, x):
while i < self.n:
self.data[i] += x
i |= i + 1
return
n, m = list(map(int, input().split()))
c = list(map(int, input().split()))
b = BIT(n)
for i in range(n):
b.update(i, c[i])
res = []
for i in range(m):
t, x, y = list(map(int, input().split()))
if t == 1:
res.append(b.sum(y) - b.sum(x))
else:
b.update(x, y)
print(("\n".join(map(str, res))))
| p02559 |
import sys
input = lambda: sys.stdin.readline()
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * n
def sum(self, i):
s = 0
while i > 0:
s += self.data[i - 1]
i &= i - 1
return s
def update(self, i, x):
while i < self.n:
self.data[i] += x
i |= i + 1
return
n, m = list(map(int, input().split()))
c = list(map(int, input().split()))
b = BIT(n)
for i in range(n):
b.update(i, c[i])
res = []
for i in range(m):
t, x, y = list(map(int, input().split()))
if t == 1:
res.append(b.sum(y) - b.sum(x))
else:
b.update(x, y)
print(("\n".join(map(str, res))))
| import sys
input = lambda: sys.stdin.readline()
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
i += i & -i
n, m = list(map(int, input().split()))
c = list(map(int, input().split()))
b = BIT(n)
for i in range(n):
b.add(i + 1, c[i])
res = []
for i in range(m):
t, x, y = list(map(int, input().split()))
if t == 1:
res.append(b.sum(y) - b.sum(x))
else:
b.add(x + 1, y)
print(("\n".join(map(str, res))))
| p02559 |
import sys
input = sys.stdin.readline
class segtree:
x_unit=0 # 単位元
x_func=sum # 関数
def __init__(self,n,seq):
self.n=n
self.x=[self.x_unit]*(2*n)
for i,j in enumerate(seq, self.n): # n番目からseqをx配列に移していく
self.x[i] = j
for i in range(self.n-1, 0, -1):
self.x[i] = self.x_func([self.x[i*2], self.x[i*2+1]])
def update(self,i,j): # 1点更新
i += self.n
self.x[i]=j
while i>1:
i//=2 # 更新後、木の上へと登っていくついでに更新
self.x[i]=self.x_func([self.x[i*2], self.x[i*2+1]])
def fold(self,l,r): # 区間[l, r)の合計を取得
l+=self.n
r+=self.n
val_l=self.x_unit
val_r=self.x_unit
while l<r:
if l & 1: # lが奇数
val_l=self.x_func([val_l,self.x[l]])
l+=1 # 偶数に調節
if r & 1: # rが奇数
r-=1 # 開区間なので1個前は偶数番目の要素
val_r=self.x_func([val_r,self.x[r]])
l //= 2
r //= 2
return self.x_func([val_l,val_r])
n,q=list(map(int,input().split()))
*a,=list(map(int,input().split()))
seg=segtree(n,a)
for i in range(q):
t,x,y=list(map(int,input().split()))
if t==0:
old=seg.fold(x,x+1)
seg.update(x, old+y)
else:
print((seg.fold(x, y))) | import sys
input = sys.stdin.readline
class segtree:
x_unit=0 # 単位元
x_func=lambda self,a:a[0]+a[1] # 関数
def __init__(self,n,seq):
self.n=n
self.x=[self.x_unit]*(2*n)
for i,j in enumerate(seq, self.n): # n番目からseqをx配列に移していく
self.x[i] = j
for i in range(self.n-1, 0, -1):
self.x[i] = self.x_func([self.x[i*2], self.x[i*2+1]])
def update(self,i,j): # 1点更新
i += self.n
self.x[i]=j
while i>1:
i//=2 # 更新後、木の上へと登っていくついでに更新
self.x[i]=self.x_func([self.x[i*2], self.x[i*2+1]])
def fold(self,l,r): # 区間[l, r)の合計を取得
l+=self.n
r+=self.n
val_l=self.x_unit
val_r=self.x_unit
while l<r:
if l & 1: # lが奇数
val_l=self.x_func([val_l,self.x[l]])
l+=1 # 偶数に調節
if r & 1: # rが奇数
r-=1 # 開区間なので1個前は偶数番目の要素
val_r=self.x_func([val_r,self.x[r]])
l //= 2
r //= 2
return self.x_func([val_l,val_r])
n,q=list(map(int,input().split()))
*a,=list(map(int,input().split()))
seg=segtree(n,a)
for i in range(q):
t,x,y=list(map(int,input().split()))
if t==0:
old=seg.fold(x,x+1)
seg.update(x, old+y)
else:
print((seg.fold(x, y))) | p02559 |
import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
BIT=[0]*n
def ADD(x,y):#A[x]+=y,1-origin
while x<=n:
BIT[x-1]+=y
x+=x&(-x)
def SUM(l):#1からlまでの和
if l==0:
return 0
ret=0
while l>=1:
ret+=BIT[l-1]
l-=l&(-l)
return ret
IN=list(map(int,input().split()))
for i in range(n):
ADD(i+1,IN[i])
for i in range(q):
t,a,b=list(map(int,input().split()))
if t==0:
ADD(a+1,b)
else:
print((SUM(b)-SUM(a))) | import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
BIT=[0]*n
def ADD(x,y):#A[x]+=y,1-origin
while x<=n:
BIT[x-1]+=y
x+=x&(-x)
def SUM(l):#1からlまでの和
ret=0
while l>=1:
ret+=BIT[l-1]
l-=l&(-l)
return ret
IN=list(map(int,input().split()))
for i in range(n):
ADD(i+1,IN[i])
for i in range(q):
t,a,b=list(map(int,input().split()))
if t==0:
ADD(a+1,b)
else:
print((SUM(b)-SUM(a))) | p02559 |
class BIT:
def __init__(self, n):
self.size = n
self.tree = [0]*(n+1)
def sum(self, i):
# [0, i) の要素の総和を返す
s = 0
while i>0:
s += self.tree[i]
i -= i & -i
return s
# 0 index を 1 index に変更 転倒数を求めるなら1を足していく
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
# 総和がx以上になる位置のindex をbinary search
def bsearch(self,x):
le = 0
ri = 1<<(self.size.bit_length()-1)
while ri > 0:
if le+ri <= self.size and self.tree[le+ri]<x:
x -= self.tree[le+ri]
le += ri
ri >>= 1
return le+1
n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
bit = BIT(n)
for i,x in enumerate(a):
bit.add(i,x)
for i in range(q):
t,l,r = list(map(int,input().split()))
if t == 0:
bit.add(l,r)
else:
print((bit.sum(r)-bit.sum(l))) | class BIT:
def __init__(self, n):
self.size = n
self.tree = [0]*(n+1)
def make(self, list):
self.tree[1:] = list.copy()
for i in range(self.size+1):
j = i + (i & (-i))
if j < self.size+1:
self.tree[j] += self.tree[i]
def sum(self, i):
# [0, i) の要素の総和を返す
s = 0
while i>0:
s += self.tree[i]
i -= i & -i
return s
# 0 index を 1 index に変更 転倒数を求めるなら1を足していく
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
# 総和がx以上になる位置のindex をbinary search
def bsearch(self,x):
le = 0
ri = 1<<(self.size.bit_length()-1)
while ri > 0:
if le+ri <= self.size and self.tree[le+ri]<x:
x -= self.tree[le+ri]
le += ri
ri >>= 1
return le+1
n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
bit = BIT(n)
bit.make(a)
for i in range(q):
t,l,r = list(map(int,input().split()))
if t == 0:
bit.add(l,r)
else:
print((bit.sum(r)-bit.sum(l))) | p02559 |
class BIT:
def __init__(self, n):
self.size = n
self.tree = [0]*(n+1)
def make(self, list):
self.tree[1:] = list.copy()
for i in range(self.size+1):
j = i + (i & (-i))
if j < self.size+1:
self.tree[j] += self.tree[i]
def sum(self, i):
# [0, i) の要素の総和を返す
s = 0
while i>0:
s += self.tree[i]
i -= i & -i
return s
# 0 index を 1 index に変更 転倒数を求めるなら1を足していく
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
# 総和がx以上になる位置のindex をbinary search
def bsearch(self,x):
le = 0
ri = 1<<(self.size.bit_length()-1)
while ri > 0:
if le+ri <= self.size and self.tree[le+ri]<x:
x -= self.tree[le+ri]
le += ri
ri >>= 1
return le+1
n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
bit = BIT(n)
bit.make(a)
for i in range(q):
t,l,r = list(map(int,input().split()))
if t == 0:
bit.add(l,r)
else:
print((bit.sum(r)-bit.sum(l))) | import sys
input = sys.stdin.readline
class BIT:
def __init__(self, n):
self.size = n
self.tree = [0]*(n+1)
def make(self, list):
self.tree[1:] = list.copy()
for i in range(self.size+1):
j = i + (i & (-i))
if j < self.size+1:
self.tree[j] += self.tree[i]
def sum(self, i):
# [0, i) の要素の総和を返す
s = 0
while i>0:
s += self.tree[i]
i -= i & -i
return s
# 0 index を 1 index に変更 転倒数を求めるなら1を足していく
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
# 総和がx以上になる位置のindex をbinary search
def bsearch(self,x):
le = 0
ri = 1<<(self.size.bit_length()-1)
while ri > 0:
if le+ri <= self.size and self.tree[le+ri]<x:
x -= self.tree[le+ri]
le += ri
ri >>= 1
return le+1
n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
bit = BIT(n)
bit.make(a)
for i in range(q):
t,l,r = list(map(int,input().split()))
if t == 0:
bit.add(l,r)
else:
print((bit.sum(r)-bit.sum(l))) | p02559 |
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
ips = lambda:input().split()
import collections
import math
import itertools
import heapq as hq
class FenwickTree():
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def add(self,idx,a):#値の更新
idx+=1
while idx<=self.n:
self.tree[idx] +=a
idx += idx &-idx
def _sum(self,r):
ret=0
r+=1
while r>0:
ret+=self.tree[r]
r-=r&-r
return ret
def sum(self,l,r):
return self._sum(r)-self._sum(l-1)
n,q = ma()
A = lma()
ft = FenwickTree(n)
for i in range(n):
ft.add(i,A[i])
for i in range(q):
t,u,v = ma()
if t==0:
ft.add(u,v)
else:
print(ft.sum(u,v-1))
| ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
ips = lambda:input().split()
import collections
import math
import itertools
import heapq as hq
import sys
input=sys.stdin.readline
class FenwickTree():
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def add(self,idx,a):#値の更新
idx+=1
while idx<=self.n:
self.tree[idx] +=a
idx += idx &-idx
def _sum(self,r):
ret=0
r+=1
while r>0:
ret+=self.tree[r]
r-=r&-r
return ret
def sum(self,l,r):
return self._sum(r)-self._sum(l-1)
n,q = ma()
A = lma()
ft = FenwickTree(n)
for i in range(n):
ft.add(i,A[i])
for i in range(q):
t,u,v = ma()
if t==0:
ft.add(u,v)
else:
print(ft.sum(u,v-1))
| p02559 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
class BIT:
def __init__(self, li):
self.n, self.data = len(li) + 1, [0] + li
for i in range(1, self.n):
if i + (i & -i) < self.n: self.data[i + (i & -i)] += self.data[i]
def add(self, i, a):
i += 1
while i < self.n:
self.data[i] += a
i += i & -i
# sum of [0, i)
def acc(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
# sum of [l, r)
def get(self, l, r = None):
if r is None: r = l+1
res = 0
# return self.acc(r) - self.acc(l)
while l < r:
res += self.data[r]
r -= r & -r
while r < l:
res -= self.data[l]
l -= l & -l
return res
def main():
N, Q = LI()
A = LI()
query = LIR(Q)
bit = BIT(A)
# print([bit.get(i) for i in range(N)])
for a, b, c in query:
if a == 0:
bit.add(b, c)
else:
print((bit.get(b, c)))
# print([bit.get(i) for i in range(N)])
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
class BIT:
def __init__(self, li):
self.n, self.data = len(li) + 1, [0] + li
for i in range(1, self.n):
if i + (i & -i) < self.n: self.data[i + (i & -i)] += self.data[i]
def add(self, i, a):
i += 1
while i < self.n:
self.data[i] += a
i += i & -i
# sum of [0, i)
def acc(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
# sum of [l, r)
def get(self, l, r = None):
if r is None: r = l+1
return self.acc(r) - self.acc(l)
def main():
N, Q = LI()
A = LI()
query = LIR(Q)
bit = BIT(A)
for a, b, c in query:
if a == 0:
bit.add(b, c)
else:
print((bit.get(b, c)))
if __name__ == '__main__':
main() | p02559 |
class fenwick_tree():
def __init__(self, n:int, mod:int = 0):
self.__mod = mod
self.__n = n
self.__data = [0] * self.__n
def add(self, p:int, x:int):
assert (0 <= p) & (p < self.__n)
if(self.__mod == 0):
self.__add_mod0(p,x)
else:
self.__add_mod(p,x)
def __add_mod0(self, p:int, x:int):
p+=1
while( p<= self.__n):
self.__data[p-1] += x
p += p & -p
def __add_mod(self, p:int, x:int):
p+=1
while( p<= self.__n):
self.__data[p-1] += x
self.__data[p-1] %= self.__mod
p += p & -p
def sum(self, l:int, r:int):
assert (0 <= l) & (l <= r) & (r <= self.__n)
if(self.__mod == 0):
return self.__sum_mod0(r) - self.__sum_mod0(l)
else:
return self.__sum_mod(r) - self.__sum_mod(l)
def __sum_mod0(self, r:int):
s = 0
while(r > 0):
s += self.__data[r-1]
r -= r & -r
return s
def __sum_mod(self, r:int):
s = 0
while(r > 0):
s += self.__data[r-1]
s %= self.__mod
r -= r & -r
return s
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,q = list(map(int,readline().split()))
a = list(map(int,readline().split()))
query = list(map(int,read().split()))
ft = fenwick_tree(n,mod=10**18)
ans = []
for i,ai in enumerate(a):
ft.add(i,ai)
i = 0
for _ in range(q):
if(query[i]==0):
p,x = query[i+1:i+3]
ft.add(p,x)
else:
l,r = query[i+1:i+3]
ans.append(ft.sum(l,r))
i += 3
print(('\n'.join(map(str,ans)))) | class fenwick_tree():
def __init__(self, n:int):
self.__n = n
self.__data = [0] * self.__n
def add(self, p:int, x:int):
assert (0 <= p) & (p < self.__n)
p+=1
while( p<= self.__n):
self.__data[p-1] += x
p += p & -p
def sum(self, l:int, r:int):
assert (0 <= l) & (l <= r) & (r <= self.__n)
return self.__sum_mod0(r) - self.__sum_mod0(l)
def __sum_mod0(self, r:int):
s = 0
while(r > 0):
s += self.__data[r-1]
r -= r & -r
return s
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,q = list(map(int,readline().split()))
a = list(map(int,readline().split()))
query = list(map(int,read().split()))
ft = fenwick_tree(n)
ans = []
for i,ai in enumerate(a):
ft.add(i,ai)
i = 0
for _ in range(q):
if(query[i]==0):
p,x = query[i+1:i+3]
ft.add(p,x)
else:
l,r = query[i+1:i+3]
ans.append(ft.sum(l,r))
i += 3
print(('\n'.join(map(str,ans))))
| p02559 |
n,q=list(map(int, input().split()))
*a,=list(map(int, input().split()))
bit=[0]*(2*n+1)
def add(t,x):
while t<=n:
bit[t]+=x
t+=t&(-t)
def que(t):
res=0
while t:
res+=bit[t]
t-=t&(-t)
return res
for i in range(n):
add(i+1,a[i])
for _ in range(q):
i,p,x=list(map(int, input().split()))
if i:
ans=que(x)-que(p)
print(ans)
else:
add(p+1,x)
| import sys
input=sys.stdin.readline
n,q=list(map(int, input().split()))
*a,=list(map(int, input().split()))
bit=[0]*(n+1)
def add(t,x):
while t<=n:
bit[t]+=x
t+=t&(-t)
def que(t):
res=0
while t:
res+=bit[t]
t-=t&(-t)
return res
for i in range(n):
add(i+1,a[i])
for _ in range(q):
i,p,x=list(map(int, input().split()))
if i:
ans=que(x)-que(p)
print(ans)
else:
add(p+1,x)
| p02559 |
import sys
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def build(self, arr):
#assert len(arr) <= n
for i, a in enumerate(arr):
self.add(i+1, a)
def sum(self, i):
s = 0
while i > 0:
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 range_sum(self, l, r):
#assert 0 <= l <= r <= self.n
return self.sum(r) - self.sum(l)
def main():
n, q = list(map(int, sys.stdin.buffer.readline().split()))
bit = Bit(n)
bit.build(list(map(int, sys.stdin.buffer.readline().split())))
for x in sys.stdin.buffer.readlines():
q, p, x = list(map(int, x.split()))
if q:
print((bit.range_sum(p, x)))
else:
bit.add(p+1, x)
if __name__ == "__main__":
main()
| import sys
class Bit:
def __init__(self, n, arr):
self.size = n
self.tree = [0] + arr
for i in range(1, n+1):
if i + (i & -i) < n + 1:
self.tree[i + (i & -i)] += self.tree[i]
def sum(self, i):
s = 0
while i > 0:
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 range_sum(self, l, r):
return self.sum(r) - self.sum(l)
def main():
n, q = list(map(int, sys.stdin.buffer.readline().split()))
bit = Bit(n, list(map(int, sys.stdin.buffer.readline().split())))
for x in sys.stdin.buffer.readlines():
q, p, x = list(map(int, x.split()))
if q:
print((bit.range_sum(p, x)))
else:
bit.add(p+1, x)
if __name__ == "__main__":
main()
| p02559 |
"""
n,q = map(int,input().split())
a = list(map(int,input().split()))
def segfunc(x,y):
return x + y
def init(init_val):
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
#####単位元######
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
init(a)
for _ in range(q):
q1,p,x = map(int,input().split())
if q1 == 0:
update(p, seg[p+num-1] + x)
else:
print(query(p, x))
"""
from typing import Callable, List, TypeVar
T = TypeVar("T")
class SegmentTree:
"""Segment Tree"""
__slots__ = ["e", "op", "_n", "_size", "tree"]
def __init__(self, a: List[T], e: T, op: Callable[[T, T], T]) -> None:
self.e = e
self.op = op
self._n = len(a)
self._size = 1 << (self._n - 1).bit_length()
self.tree = [e] * self._size + a + [e] * (self._size - self._n)
for i in range(self._size - 1, 0, -1):
self._update(i)
def _update(self, k: int) -> None:
"""Update the value of a[k]."""
self.tree[k] = self.op(self.tree[2 * k], self.tree[2 * k + 1])
def set(self, k: int, x: T) -> None:
"""Assign x to a[k] in O(log n)."""
assert 0 <= k < self._n
k += self._size
self.tree[k] = x
while k:
k >>= 1
self._update(k)
def get(self, k: int) -> T:
"""Return a[k] in O(1)."""
assert 0 <= k < self._n
return self.tree[k + self._size]
def prod(self, l: int, r: int) -> T:
"""Return op(a[l], ..., a[r - 1]). Return e, if l == r.
Complexity: O(log n)
"""
assert 0 <= l <= r <= self._n
sml, smr = self.e, self.e
l += self._size
r += self._size
while l < r:
if l & 1:
sml = self.op(sml, self.tree[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.tree[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def prod_all(self) -> T:
"""Return op(a[0], ..., a[n - 1]. Return e if n == 0.
Complexity: O(1)
"""
return self.tree[1]
def max_right(self, l: int, f: Callable[[T], bool]) -> int:
"""
Return an index r satisfying both:
1. r = l or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
2. r = n or f(op(a[l], a[l + 1], ..., a[r])) = false.
If f is monotone, this is the maximum r satisfying:
f(op(a[l], a[l + 1], ..., a[r - 1])) = true.
Complexity: O(log n)
"""
assert 0 <= l <= self._n
assert f(self.e)
if l == self._n:
return self._n
l += self._size
sm = self.e
while True:
while not l & 1:
l >>= 1
if not f(self.op(sm, self.tree[l])):
while l < self._size:
l *= 2
if f(self.op(sm, self.tree[l])):
sm = self.op(sm, self.tree[l])
l += 1
return l - self._size
sm = self.op(sm, self.tree[l])
l += 1
if (l & -l) == l:
break
return self._n
def min_left(self, r: int, f: Callable[[T], bool]) -> int:
"""
Return an index l satisfying both:
1. l = r or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
2. l = 0 or f(op(a[l - 1], a[l + 1], ..., a[r - 1])) = false.
If f is monotone, this is the minimum l satisfying:
f(op(a[l], a[l + 1], ..., a[r - 1])) = true.
Complexity: O(log n)
"""
assert 0 <= r <= self._n
assert f(self.e)
if not r:
return 0
r += self._size
sm = self.e
while True:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not f(self.op(self.tree[r], sm)):
while r < self._size:
r = 2 * r + 1
if f(self.op(self.tree[r], sm)):
sm = self.op(self.tree[r], sm)
r -= 1
return r + 1 - self._size
if (r & -r) == r:
break
return 0
def add(x, y):
return x + y
n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
tree = SegmentTree(a, 0, add)
for _ in range(q):
t,p,x = list(map(int,input().split()))
if t == 0:
tree.set(p, tree.get(p) + x)
else:
print((tree.prod(p, x)))
| class Bit:
def __init__(self, n):
"""
:param n: 最大の要素数
"""
self.n = n
self.tree = [0]*(n+1)
self.depth = n.bit_length() - 1
def sum(self, i):
""" 区間[0,i) の総和を求める """
s = 0
i -= 1
while i >= 0:
s += self.tree[i]
i = (i & (i + 1) )- 1
return s
def built(self, array):
""" array を初期値とするBITを構築 """
for i, a in enumerate(array):
self.add(i, a)
def add(self, i, x):
""" i 番目の要素に x を足す """
while i < self.n:
self.tree[i] += x
i |= i + 1
def get(self, i, j):
""" 部分区間和 [i, j) """
if i == 0:
return self.sum(j)
return self.sum(j) - self.sum(i)
def lower_bound(self, x, equal=False):
"""
(a0+a1+...+ai < x となる最大の i (存在しない時は -1 ) , その時の a0+a1+...+ai )
a0+a1+...+ai <= x としたい場合は equal = True
二分探索であるため、ai>=0 を満たす必要がある
"""
sum_ = 0
pos = -1 # 1-indexed の時は pos = 0
if not equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] < x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
if equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] <= x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
return pos, sum_
def __getitem__(self, i):
""" [a0, a1, a2, ...] """
return self.get(i, i+1)
def __iter__(self):
""" [a0, a1, a2, ...] """
for i in range(self.n):
yield self.get(i, i+1)
def __str__(self):
text1 = " ".join(["element: "] + list(map(str, self)))
text2 = " ".join(["cumsum(1-indexed): "] + list(str(self.sum(i)) for i in range(1, self.n + 1)))
return "\n".join((text1, text2))
n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
B = Bit(n)
B.built(a)
for _ in range(q):
a,b,c = list(map(int,input().split()))
if a == 0:
B.add(b, c)
else:
print((B.get(b, c)))
| p02559 |
def segfunc(x,y):return x+y
ide_ele=0
class segtree():
def __init__(self,init_val,segfunc=segfunc,ide_ele=ide_ele):
n=len(init_val)
self.segfunc=segfunc
self.ide_ele=ide_ele
self.num=1<<(n-1).bit_length()
self.tree=[ide_ele]*2*self.num
for i in range(n):
self.tree[self.num+i]=init_val[i]
for i in range(self.num-1,0,-1):
self.tree[i]=self.segfunc(self.tree[2*i], self.tree[2*i+1])
def update(self,k,x):
k+=self.num
self.tree[k]+=x
while k>1:
self.tree[k>>1]=self.segfunc(self.tree[k],self.tree[k^1])
k>>=1
def query(self,l,r):
res=self.ide_ele
l+=self.num
r+=self.num+1
while l<r:
if l&1:
res=self.segfunc(res,self.tree[l])
l+=1
if r&1:
res=self.segfunc(res,self.tree[r-1])
l>>=1
r>>=1
return res
n,q=map(int,input().split())
st=segtree(list(map(int,input().split())))
ans=[]
for _ in range(q):
x,y,z=map(int,input().split())
if x:ans+=[st.query(y,z-1)]
else:st.update(y,z)
print(*ans,sep='\n')
| class binaryindexedtree():
def __init__(self,n):
self.n=n
self.tree=[0]*n
def add(self,a,w):
x=a
while x<=self.n:
self.tree[x-1]+=w
x+=x&(-x)
def sums(self,a):
x=a
S=0
while x!=0:
S+=self.tree[x-1]
x-=x&(-x)
return S
n,q=map(int,input().split())
a=list(map(int,input().split()))
bit=binaryindexedtree(n)
for i,x in enumerate(a,1):
bit.add(i,x)
ans=[]
for _ in range(q):
x,y,z=map(int,input().split())
if x:ans+=[bit.sums(z)-bit.sums(y)]
else:bit.add(y+1,z)
print(*ans,sep='\n')
| p02559 |
class BIT():
__slots__ = ["n", "data"]
def __init__(self, li):
self.n = len(li) + 1
self.data = [0] + li
for i in range(1, self.n):
if i + (i & -i) < self.n:
self.data[i + (i & -i)] += self.data[i]
def add(self, i, a):
i += 1
while i < self.n:
self.data[i] += a
i += i & -i
def acc(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
def fold(self, l, r):
return self.acc(r) - self.acc(l)
import sys
input = sys.stdin.buffer.readline
n, q = list(map(int, input().split()))
A = list(map(int, input().split()))
bit = BIT(A)
for _ in range(q):
t, p, x = list(map(int, input().split()))
if t == 0:
bit.add(p, x)
else:
print((bit.fold(p, x))) | class BIT():
__slots__ = ["n", "data"]
def __init__(self, li):
self.n = len(li) + 1
self.data = [0] + li
for i in range(1, self.n):
if i + (i & -i) < self.n:
self.data[i + (i & -i)] += self.data[i]
def add(self, i, a):
i += 1
while i < self.n:
self.data[i] += a
i += i & -i
def acc(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
def fold(self, l, r):
res = 0
while l < r:
res += self.data[r]
r -= r & -r
while r < l:
res -= self.data[l]
l -= l & -l
return res
import sys
input = sys.stdin.buffer.readline
n, q = list(map(int, input().split()))
A = list(map(int, input().split()))
bit = BIT(A)
for _ in range(q):
t, p, x = list(map(int, input().split()))
if t == 0:
bit.add(p, x)
else:
print((bit.fold(p, x))) | p02559 |
class Binary_Indexed_Tree_Exception(Exception):
pass
class Binary_Indexed_Tree():
def __init__(self,N,L=[]):
"""calcを演算とするN項のBinary Indexed Treeを作成
N:要素数
"""
self.calc=lambda x,y:x+y
self.unit=0
N=max(N,len(L))
k=1
d=1
while k<N:
k*=2
d+=1
X=[None]+[0]*k
self.num=k
self.depth=d
if L:
for i in range(len(L)):
p=i+1
while p<=k:
X[p]+=L[i]
p+=p&(-p)
self.data=X
def index(self,k,index=1):
"""第k要素の値を出力する.
k:数列の要素
index:先頭の要素の番号
"""
p=k+(1-index)
return self.sub_array(p,p)
def add(self,k,x,index=1):
"""第k要素にx加え,更新を行う.
k:数列の要素
x:更新後の値
index:先頭の要素の番号
"""
p=k+(1-index)
while p<=self.num:
self.data[p]+=x
p+=p&(-p)
def update(self,k,x,index=1):
"""第k要素をxに変え,更新を行う.
k:数列の要素
x:更新後の値
"""
a=self.index(k,index)
y=x-a
self.add(k,y,index)
def sub_array(self,From,To,index=1):
"""第From要素から第To要素までの総和を求める.
From:始まり
To:終わり
index:先頭の要素の番号
"""
alpha=max(1,From+(1-index))
beta=min(self.num,To+(1-index))
return self.__section(beta)-self.__section(alpha-1)
def __section(self,To):
S=0
x=To
while x>0:
S+=self.data[x]
x-=x&(-x)
return S
#================================================
N,Q=list(map(int,input().split()))
A=list(map(int,input().split()))
B=Binary_Indexed_Tree(N,A)
X=[]
for _ in range(Q):
t,u,v=list(map(int,input().split()))
if t==0:
B.add(u,v,0)
else:
X.append(B.sub_array(u,v-1,0))
print(("\n".join(map(str,X)))) | class Binary_Indexed_Tree_Exception(Exception):
pass
class Binary_Indexed_Tree():
def __init__(self,L,calc,unit,inv):
"""calcを演算とするN項のBinary Indexed Treeを作成
calc:演算(2変数関数,群)
unit:群calcの単位元(xe=ex=xを満たすe)
inv:群calcの逆元(1変数関数)
"""
self.calc=calc
self.unit=unit
self.inv=inv
N=len(L)
d=max(1,(N-1).bit_length())
k=2**d
X=[None]+[unit]*k
self.num=k
self.depth=d
if L:
for i in range(len(L)):
p=i+1
while p<=k:
X[p]=calc(X[p],L[i])
p+=p&(-p)
self.data=X
def index(self,k,index=1):
"""第k要素の値を出力する.
k:数列の要素
index:先頭の要素の番号
"""
p=k+(1-index)
return self.sub_array(p,p)
def add(self,k,x,index=1,right=False):
"""第k要素にxを左から加え,更新を行う.
k:数列の要素
x:更新後の値
index:先頭の要素の番号
right:「左から」が「右から」になる
"""
p=k+(1-index)
while p<=self.num:
if right==False:
#左から
self.data[p]=self.calc(x,self.data[p])
else:
#右から
self.data[p]=self.cal(self.data[p],x)
p+=p&(-p)
def update(self,k,x,index=1,right=False):
"""第k要素をxに変え,更新を行う.
k:数列の要素
x:更新後の値
"""
a=self.index(k,index)
if right==False:
#左から
y=self.calc(x,self.inv(a))
else:
#右から
y=self.calc(self.inv(a),x)
self.add(k,y,index,right)
def product(self,From,To,index=1):
"""第From要素から第To要素までの総和を求める.
From:始まり
To:終わり
index:先頭の要素の番号
"""
alpha=max(1,From+(1-index))
beta=min(self.num,To+(1-index))
return self.calc(self.inv(self.__section(alpha-1)),self.__section(beta))
def __section(self,To):
S=self.unit
x=To
while x>0:
S=self.calc(self.data[x],S)
x-=x&(-x)
return S
def all_product(self):
return self.data[-1]
#================================================
N,Q=list(map(int,input().split()))
A=list(map(int,input().split()))
B=Binary_Indexed_Tree(A,lambda x,y:x+y,0,lambda x:-x)
X=[]
for _ in range(Q):
t,u,v=list(map(int,input().split()))
if t==0:
B.add(u,v,0)
else:
X.append(B.product(u,v-1,0))
print(("\n".join(map(str,X)))) | p02559 |
from copy import *
import sys
S=sys.stdin.readlines()
def init(N,node,unit,func):
n=1
while n<N:
n<<=1
for i in range(n*2-1):
if len(node)<=i:
node.append(deepcopy(unit))
else:
node[i]=deepcopy(unit)
node.append(func)
node.append(unit)
node.append(n)
def upd(node,x,a):
y=node[-1]+x
node[y-1]=a
while y>1:
y=y>>1
node[y-1]=node[-3](node[(y<<1)-1],node[y<<1])
def query(node,l,r):
x,y=l,r
z=node[-1]-1
r=node[-2]
while True:
if x==y:
return r
if x&1:
r=node[-3](r,node[x+z])
x+=1
if y&1:
r=node[-3](r,node[y+z-1])
x>>=1
y>>=1
z>>=1
if z==0:
return r
def bis_min_k(node,k,cond):
x=k+1
while True:
if node[-1]<=x:
return x-node[-1]
if cond(node[(x<<1)-1]):
x=x<<1
else:
x=(x<<1)+1
def bis_min(node,l,r,cond):
x,y=l,r
z=node[-1]-1
for i in range(30):
if x+(1<<i)>y:
break
if x&(1<<i):
if cond(node[z+(x>>i)]):
return bis_min_k(node,z+(x>>i),cond)
x+=(1<<i)
if z==0:
break
z>>=1
for i in range(29,-1,-1):
if i and ((node[-1]-1)>>(i-1))==0:
continue
if x+(1<<i)>y:
continue
if (y-x)&(1<<i):
if cond(node[((node[-1]-1)>>i)+(x>>i)]):
return bis_min_k(node,((node[-1]-1)>>i)+(x>>i),cond)
x+=(1<<i)
return node[-1]
N,Q=list(map(int,S[0].split()))
A=list(map(int,S[1].split()))
X=[]
init(N+1,X,0,lambda x,y:x+y)
for i in range(N):
upd(X,i,A[i])
a,b,c=0,0,0
for i in range(Q):
a,b,c=list(map(int,S[i+2].split()))
if a:
print((query(X,b,c)))
else:
upd(X,b,X[X[-1]+b-1]+c) | import sys
S=sys.stdin.readlines()
def Binit(B,siz):
while len(B)<siz+1:
B.append(0)
while len(B)>siz+1:
del B[-1]
for i in range(siz+1):
B[i]=0
B.append(siz)
def Badd(B,a,x):
z=a
while z<=B[-1]:
B[z]+=x
z+=(z&(-z))
def Bsum(B,a):
r=0
z=a
while z>0:
r+=B[z]
z-=(z&(-z))
return r
def Bssum(B,a,b):
return Bsum(B,max(a,b))-Bsum(B,min(a,b)-1)
BIT=[]
N,Q=list(map(int,S[0].split()))
Binit(BIT,N+1)
A=list(map(int,S[1].split()))
for i in range(N):
Badd(BIT,i+1,A[i])
a,b,c=0,0,0
for i in range(Q):
a,b,c=list(map(int,S[i+2].split()))
if a:
print((Bssum(BIT,b+1,c)))
else:
Badd(BIT,b+1,c) | p02559 |
import sys
class Fenwick_Tree:
def __init__(self, n):
self._n = n
self.data = [0] * n
def add(self, p, x):
assert 0 <= p < self._n
p += 1
while p <= self._n:
self.data[p - 1] += x
p += p & -p
def sum(self, l, r):
assert 0 <= l <= r <= self._n
return self._sum(r) - self._sum(l)
def _sum(self, r):
s = 0
while r > 0:
s += self.data[r - 1]
r -= r & -r
return s
def main():
input = sys.stdin.readline
n, q = list(map(int, input().split()))
fw = Fenwick_Tree(n)
for i, a in enumerate(map(int, input().split())): fw.add(i, a)
for _ in range(q):
t, a, b = list(map(int, input().split()))
if t == 0:
fw.add(a, b)
else:
print((fw.sum(a, b)))
if __name__ == "__main__":
main()
| import sys
class Fenwick_Tree:
def __init__(self, n):
self._n = n
self.data = [0] * n
def add(self, p, x):
assert 0 <= p < self._n
p += 1
while p <= self._n:
self.data[p - 1] += x
p += p & -p
def sum(self, l, r):
assert 0 <= l <= r <= self._n
return self._sum(r) - self._sum(l)
def _sum(self, r):
s = 0
while r > 0:
s += self.data[r - 1]
r -= r & -r
return s
def main():
input = sys.stdin.readline
n, q = list(map(int, input().split()))
fw = Fenwick_Tree(n)
for i, a in enumerate(map(int, input().split())): fw.add(i, a)
A = list(map(int, sys.stdin.read().split()))
for i in range(0, 3 * q, 3):
t, a, b = A[i:i+3]
if t == 0:
fw.add(a, b)
else:
print((fw.sum(a, b)))
if __name__ == "__main__":
main()
| p02559 |
class SegmentTree:
ele = 0
def func(self, a, b):
return a + b
# SEG木は1-index
# Aに関しては0-index
def __init__(self, n): # Aは0-idx
self.n = n
self.num = 2 ** ((self.n - 1).bit_length())
self.SEG = [self.ele] * (2 * self.num)
def search(self, idx):
return self.SEG[idx + self.num]
def initialize(self, A):
for i in range(self.n):
self.SEG[i + self.num] = A[i]
for i in range(self.num - 1, 0, -1):
self.SEG[i] = self.func(self.SEG[2 * i], self.SEG[2 * i + 1])
def update(self, idx, val):
idx += self.num
self.SEG[idx] += val
idx //= 2
while idx:
self.SEG[idx] = self.func(self.SEG[2 * idx], self.SEG[2 * idx + 1])
idx //= 2
def query(self, left, right):
# 開区間
resleft = self.ele
resright = self.ele
left += self.num
right += self.num
while right - left > 0:
if left % 2 == 1:
resleft = self.func(resleft, self.SEG[left])
left += 1
if right % 2 == 1:
right -= 1
resright = self.func(resright, self.SEG[right])
left //= 2
right //= 2
return self.func(resleft, resright)
n, q = list(map(int, input().split()))
A = list(map(int, input().split()))
ST = SegmentTree(n)
ST.initialize(A)
for _ in range(q):
s, a, b = list(map(int, input().split()))
if s:
print((ST.query(a, b)))
else:
ST.update(a, b)
| import sys
input = sys.stdin.buffer.readline
class SegmentTree:
ele = 0
def func(self, a, b):
return a + b
# SEG木は1-index
# Aに関しては0-index
def __init__(self, n): # Aは0-idx
self.n = n
self.num = 2 ** ((self.n - 1).bit_length())
self.SEG = [self.ele] * (2 * self.num)
def search(self, idx):
return self.SEG[idx + self.num]
def initialize(self, A):
for i in range(self.n):
self.SEG[i + self.num] = A[i]
for i in range(self.num - 1, 0, -1):
self.SEG[i] = self.func(self.SEG[2 * i], self.SEG[2 * i + 1])
def update(self, idx, val):
idx += self.num
self.SEG[idx] += val
idx //= 2
while idx:
self.SEG[idx] = self.func(self.SEG[2 * idx], self.SEG[2 * idx + 1])
idx //= 2
def query(self, left, right):
# 開区間
resleft = self.ele
resright = self.ele
left += self.num
right += self.num
while right - left > 0:
if left % 2 == 1:
resleft = self.func(resleft, self.SEG[left])
left += 1
if right % 2 == 1:
right -= 1
resright = self.func(resright, self.SEG[right])
left //= 2
right //= 2
return self.func(resleft, resright)
n, q = list(map(int, input().split()))
ST = SegmentTree(n)
ST.initialize(list(map(int, input().split())))
for _ in range(q):
s, a, b = list(map(int, input().split()))
if s:
print((ST.query(a, b)))
else:
ST.update(a, b)
| p02559 |
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
l=list(map(int,input().split()))
c1=0
c2=0
c4=0
for i in l:
if i%2==1:
c1+=1
else:
if i%4==0:
c4+=1
else:
c2+=1
if c2==0:
if c1<=c4+1:
print('Yes')
else:
print('No')
else:
if c1<=c4:
print('Yes')
else:
print('No')
resolve() | import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
l=list(map(int,input().split()))
cnt1=0
cnt2=0
cnt4=0
for i in l:
if i%2==1:
cnt1+=1
elif i%4==0:
cnt4+=1
else:
cnt2+=1
if cnt2==0 and cnt4+1>=cnt1:
print('Yes')
elif cnt2>0 and cnt4>=cnt1:
print('Yes')
else:
print('No')
resolve() | p03639 |
# def makelist(n, m):
# return [[0 for i in range(m)] for j in range(n)]
# n = int(input())
# a, b = map(int, input().split())
# s = input()
yes = "Yes"
no = "No"
N = int(eval(input()))
a = list(map(int, input().split()))
four = 0
two = 0
none = 0
for e in a:
if e % 4 == 0:
four += 1
elif e % 2 != 0:
none += 1
else:
two += 1
if four >= none or (two == 0 and four+1 >= none):
print(yes)
else:
print(no)
| N = int(eval(input()))
four = 0
two = 0
one = 0
for e in map(int, input().split()):
if e % 4 == 0:
four += 1
elif e % 2 != 0:
one += 1
else:
two += 1
if four >= one:
print("Yes")
else:
if two == 0 and four == one - 1:
print("Yes")
else:
print("No")
| p03639 |
import itertools
N= int(eval(input()))
A_list = list(map(int,input().split()))
ans = ''
for v in itertools.permutations(A_list):
counter = 0
for i in range(len(v)-1):
if (v[i]*v[i+1]) % 4 == 0:
counter += 1
else:
break
if counter + 1 == len(v):
ans += 'Yes'
print(ans)
break
if ans == '':
print('No')
| N = int(eval(input()))
A_list = list(map(int, input().split()))
dic = {4: 0, 2: 0, 1: 0}
for i in A_list:
if i % 4 == 0:
dic[4] += 1
elif i % 2 == 0:
dic[2] += 1
else:
dic[1] += 1
dic[4] += dic[2] // 2
if len(A_list) // 2 <= dic[4]:
print('Yes')
else:
print('No')
| p03639 |
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
for a in A:
if a % 4 == 0: cnt += 1
elif a % 2 == 0: cnt += 0.5
print(("Yes" if cnt >= N // 2 else "No")) | n = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
for a in A:
if a%4==0: cnt += 1
elif a%2==0: cnt += 0.5
cnt = int(cnt)
print(("Yes" if n//2 <= cnt else "No")) | p03639 |
n = int(eval(input()))
A = list(map(int, input().split()))
checker = []
for a in A:
cnt = 0
if a % 2 == 0:
cnt = 1
if a % 4 == 0:
cnt += 1
checker.append(cnt)
count_2 = checker.count(2)
count_1 = checker.count(1)
count_0 = checker.count(0)
if (count_0 <= count_2+1 and count_0 + count_1 <= count_2 + 1) or count_0 == count_2:
answer = 'Yes'
else:
answer = 'No'
print(answer)
| n = int(eval(input()))
A = list(map(int, input().split()))
cnt4 = 0
cnt2 = 0
other = 0
for a in A:
if a % 4 == 0:
cnt4 += 1
continue
if a % 2 == 0:
cnt2 += 1
else:
other += 1
if cnt4+1 >= cnt2 + other or cnt4 >= other:
print('Yes')
else:
print('No')
| p03639 |
import random
N = int(eval(input()))
num = list(map(int, input().split()))
count = 0
for i in num:
if i%4==0:
N -= 2
elif i%2==0:
count += 1
if count>1:
N = N - count + 1
if N > 1:
print('No')
else:
print('Yes') | N = int(eval(input()))
num = list(map(int, input().split()))
count = 0
for i in num:
if i%4==0:
N -= 2
elif i%2==0:
count += 1
if count>1:
N = N - count + 1
if N > 1:
print('No')
else:
print('Yes')
| p03639 |
import collections
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
n = int(eval(input()))
A = list(map(int, input().split()))
f2 = 0
f4 = 0
for a in A:
c = collections.Counter(prime_factorize(a))
if c[2] == 1:
f2 += 1
elif c[2] >= 2:
f4 += 1
if n -f2//2 *2 -f4 *3 <= 0:
print('Yes')
else:
print('No') | n = int(eval(input()))
A = list(map(int, input().split()))
f2 = 0
f4 = 0
f_another = 0
for a in A:
#c = collections.Counter(prime_factorize(a))
if a%4 == 0:
f4 += 1
elif a%2 == 0:
f2 += 1
else:
f_another +=1
if n%2 == 0 and (n -f2//2 *2 -f4 *2 <= 0):
print('Yes')
elif n%2 == 1 and (n -f2//2 *2 -f4 *2 <= 1):
print('Yes')
else:
print('No') | p03639 |
n = int(eval(input()))
cnt2 = 0
cnt4 = 0
A = list(map(int, input().split()))
for a in A:
if a % 4 == 0:
cnt4 += 1
elif a % 2 == 0:
cnt2 += 1
odd = n - cnt2 - cnt4
if cnt2 != 0:
odd += 1
if odd - 1 > cnt4:
print("No")
else:
print("Yes")
| n = int(eval(input()))
A = list(map(int, input().split()))
div = 0
even = 0
for a in A:
if a % 4 == 0:
div += 1
elif a % 2 == 0:
even += 1
odd = n - div - even
if even:
odd += 1
if div:
div += 1
if div >= odd or even == n:
print("Yes")
else:
print("No")
| p03639 |
n = int(eval(input()))
As = list(map(int, input().split()))
four = sum([1 for a in As if a%4 == 0])
odd = sum([1 for a in As if a%2 == 1])
two = sum([1 for a in As if a%2 == 0 and a%4 != 0])
if four < two%2 + odd - 1:
print("No")
else:
print("Yes") | n = int(eval(input()))
As = list(map(int, input().split()))
# four = sum([1 for a in As if a%4 == 0])
# odd = sum([1 for a in As if a%2 == 1])
# two = sum([1 for a in As if a%2 == 0 and a%4 != 0])
four = 0
odd = 0
two = 0
for a in As:
if a % 2 == 1:
odd += 1
elif a % 4 == 0:
four += 1
else:
two += 1
if four < two%2 + odd - 1:
print("No")
else:
print("Yes")
| p03639 |
import sys
n = int(sys.stdin.readline().strip())
ar = [int(x) for x in sys.stdin.readline().split()]
stop = False
def ok(x, y):
if x == -1: return True
return (x*y)%4 == 0
def find(ctr, prev, mask, app):
global stop
if ctr == n:
stop = True
if stop == True: return
for i in range(n):
if mask[i] and ok(prev, ar[i]):
mask[i] = False
find(ctr+1, ar[i], mask, app + [ar[i]])
mask[i] = True
find(0, -1, [True]*n, [])
print("Yes" if stop else "No") | import sys
n = int(sys.stdin.readline().strip())
ar = [int(x) for x in sys.stdin.readline().split()]
f4, odd, even = 0, 0, 0
for num in ar:
if num%4==0:
f4 +=1
elif num%2==0:
even+=1
else:
odd+=1
if odd-f4 == 0:
print("Yes")
elif odd-f4 <= 1 and even == 0:
print("Yes")
else:
print("No") | p03639 |
from collections import Counter
N = int(eval(input()))
A = [int(i) for i in input().split()]
C = Counter(4 if a % 4 == 0 else 2 if a % 2 == 0 else 1 for a in A)
if C[2] == 0:
print(("Yes" if C[1] <= C[4] + 1 else "No"))
else:
print(("Yes" if C[1] <= C[4] else "No"))
| N = int(eval(input()))
A = [int(i) for i in input().split()]
def solve():
f, t, o = 0, 0, 0
for a in A:
if a % 4 == 0:
f += 1
elif a % 2 == 0:
t += 1
else:
o += 1
if t == 0:
return (o <= f + 1)
else:
return (o <= f)
if solve():
print("Yes")
else:
print("No")
| p03639 |
N = int(eval(input()))
A = [int(i) for i in input().split()]
f, t = 0, 0
for a in A:
if a % 4 == 0:
f += 1
elif a % 2 == 0:
t += 1
if N - f - t <= f + (t == 0):
print("Yes")
else:
print("No")
| N = int(eval(input()))
A = [int(i) % 4 for i in input().split()]
f, t = A.count(0), A.count(2)
if N - f - t <= f + (t == 0):
print("Yes")
else:
print("No")
| p03639 |
N = int(eval(input()))
A = list(map(int, input().split()))
n1, n2, n4 = 0, 0, 0
for a in A:
if not a % 4:
n4 += 1
elif not a % 2:
n2 += 1
else:
n1 += 1
#print(n1, n2, n4)
print((["Yes", "No"][not(n1 + (n2 % 2) <= n4 + 1)]))
| N = int(eval(input()))
A = list(map(int, input().split()))
n1, n2, n4 = 0, 0, 0
for a in A:
if not a % 4:
n4 += 1
elif not a % 2:
n2 = 1
else:
n1 += 1
#print(n1, n2, n4)
print((["Yes", "No"][not(n1 + n2 <= n4 + 1)]))
| p03639 |
n = int(eval(input()))
cou1 = 0
cou2 = 0
cou4 = 0
lis = list(map(int,input().split()))
for i in range(n):
if lis[i] % 2 == 0:
if lis[i] % 4 == 0:
cou4 += 1
else:
cou2 += 1
else:
cou1 += 1
if cou2 == 0:
if cou1 <= cou4 + 1:
print("Yes")
else:
print("No")
else:
if cou1 <= cou4:
print("Yes")
else:
print("No") | n = int(eval(input()))
lis = list(map(int,input().split()))
nu1 = 0
nu2 = 0
nu4 = 0
for nu in lis:
if nu % 2 == 0:
if nu % 4 == 0:
nu4 += 1
else:
nu2 = 1
else:
nu1 += 1
if nu4 + 1 >= nu1 + nu2:print("Yes")
else:print("No") | p03639 |
# AtCoder Regular Contest 080
# C - 4-adjacent
N=int(eval(input()))
alist=list(map(int,input().split()))
oddcount=0
mod40=0
other=0
for a in alist:
if a%2==1:
oddcount+=1
elif a%4==0:
mod40+=1
else:
other+=1
if N==1:
if mod40==N:
print("Yes")
exit()
else:
print("No")
exit()
if N==2 or N==3:
if mod40>0 or other==N:
print("Yes")
exit()
else:
print("No")
exit()
# ↑ここまではあってそう。
if N%2==1: # N>3 ,Nが奇数の時
if (N-((other//2)*2))//2 <= mod40:
print("Yes")
exit()
else:
print("No")
exit()
else: # N>3 ,Nが偶数の時
if other%2==1: #かつ、要素が偶数である数が奇数の時
if (N-((other//2)*2))//2 <= mod40:
print("Yes")
exit()
else:
print("No")
exit()
else:
if (N-((other//2)*2))//2 <= mod40:
print("Yes")
exit()
else:
print("No")
exit() | # AtCoder Regular Contest 080
# C - 4-adjacent
N=int(eval(input()))
alist=list(map(int,input().split()))
oddcount=0
mod40=0
other=0
for a in alist:
if a%2==1:
oddcount+=1
elif a%4==0:
mod40+=1
else:
other+=1
if N==1:
if mod40==N:
print("Yes")
exit()
else:
print("No")
exit()
if N==2 or N==3:
if mod40>0 or other==N:
print("Yes")
exit()
else:
print("No")
exit()
# ↑ここまではあってそう。
if N%2==1: # N>3 ,Nが奇数の時
if (N-((other//2)*2))//2 <= mod40:
print("Yes")
exit()
else:
print("No")
exit()
else: # N>3 ,Nが偶数の時
if (N-((other//2)*2))//2 <= mod40:
print("Yes")
exit()
else:
print("No")
exit() | p03639 |
from collections import defaultdict
N = int(input())
counter = defaultdict(int)
for a in map(int, input().split()):
if a % 4 == 0:
counter[2] += 1
elif a % 2 == 0:
counter[1] += 1
else:
counter[0] += 1
if counter[1] == 0:
print('Yes') if counter[0] <= counter[2] + 1 else print('No')
else:
print('Yes') if counter[0] <= counter[2] else print('No')
| from collections import Counter
N = int(input())
c = Counter(map(lambda x: int(x) % 4, input().split()))
print('Yes') if sum([c[1], c[2] > 0, c[3]]) <= c[0] + 1 else print('No')
| p03639 |
n=int(eval(input()))
l=list(map(int,input().split()))
c_4=0
even=0
odd=0
for i in l:
if i%4==0:
c_4+=1
elif i%2==0:
even+=1
else:
odd+=1
if even==0 and odd-1 <= c_4:
ans="Yes"
else:
ans="No"
if even>0 and odd <= c_4:
ans="Yes"
else:
"No"
print(ans) | n=int(eval(input()))
l=list(map(int,input().split()))
c_4=0
even=0
odd=0
for i in l:
if i%4==0:
c_4+=1
elif i%2==0:
even+=1
else:
odd+=1
if even==0 and odd-1 <= c_4:
ans="Yes"
else:
ans="No"
if even>0 and odd <= c_4:
ans="Yes"
elif even>0:
ans="No"
print(ans)
| p03639 |
def reads(offset = 0):
return [int(i) - offset for i in input().split(' ')]
def Judge(vector):
length = len(vector)-1
for i in range(length):
if(vector[i] > vector[i+1]):
return 0
return 1
(N, M) = reads()
Q = int(input())
A = reads(1)
pos = [-1] * M
pat = []
freq = [0] * (M+1)
freq[0] = N
counter = 0
for i in A[::-1]:
if (i not in pat):
pat.append(i)
pos[i] = counter
counter += 1
if(counter == M):
break
for i in range(M):
if (pos[i] == -1):
pat.append(i)
for i in A[::-1]:
temp = pos[i]
if (freq[temp] > 0):
freq[temp] -= 1
freq[temp+1] += 1
for i in range(M):
if (freq[i] != 0):
start = i
break
print("Yes") if Judge(pat[start:]) else print("No")
| def reads(offset = 0):
return [int(i) - offset for i in input().split(' ')]
def Judge(vector):
length = len(vector)-1
for i in range(length):
if(vector[i] > vector[i+1]):
return 0
return 1
(N, M) = reads()
Q = int(input())
A = reads(1)
pos = [-1] * M
pat = []
freq = [0] * (M+1)
freq[0] = N
found = set()
counter = 0
for i in A[::-1]:
if (i not in found):
pat.append(i)
found.add(i)
pos[i] = counter
counter += 1
if(counter == M):
break
for i in range(M):
if (pos[i] == -1):
pat.append(i)
for i in A[::-1]:
temp = pos[i]
if (freq[temp] > 0):
freq[temp] -= 1
freq[temp+1] += 1
start = M
for i in range(M):
if (freq[i] != 0):
start = i
break
print("Yes") if Judge(pat[start:]) else print("No")
| p03996 |
def reads(offset = 0):
return [int(i) - offset for i in input().split(' ')]
def Judge(vector):
length = len(vector)-1
for i in range(length):
if(vector[i] > vector[i+1]):
return 0
return 1
(N, M) = reads()
Q = int(input())
A = reads(1)
pos = [-1] * M
pat = []
freq = [0] * (M+1)
freq[0] = N
found = set()
counter = 0
for i in A[::-1]:
if (i not in found):
pat.append(i)
found.add(i)
pos[i] = counter
counter += 1
for i in range(M):
if (pos[i] == -1):
pat.append(i)
for i in A[::-1]:
temp = pos[i]
if (freq[temp] > 0):
freq[temp] -= 1
freq[temp+1] += 1
for i in range(M+1):
if (freq[i] != 0):
start = i
break
print("Yes") if Judge(pat[start:]) else print("No")
| def reads(offset = 0):
return [int(i) - offset for i in input().split(' ')]
def Judge(vector):
length = len(vector)-1
for i in range(length):
if(vector[i] > vector[i+1]):
return 0
return 1
(N, M) = reads()
Q = int(input())
A = reads(1)
pos = [-1] * M
pat = []
freq = [0] * (M+1)
freq[0] = N
found = set()
counter = 0
for i in A[::-1]:
if (i not in found):
pat.append(i)
found.add(i)
pos[i] = counter
freq[counter] -= 1
counter += 1
freq[counter] += 1
elif (freq[pos[i]] > 0):
freq[pos[i]] -= 1
freq[pos[i]+1] += 1
for i in range(M):
if (pos[i] == -1):
pat.append(i)
for i in range(M+1):
if (freq[i] != 0):
start = i
break
print("Yes") if Judge(pat[start:]) else print("No")
| p03996 |
import sys
import math
def v():
pt=[5,0,1,2]
N=100000
s=list(['0' if x=='g' else '1' for x in list(sys.stdin.readline().strip())])
n,x=len(s),int(''.join(s),2)
s=list(format(x<<(N-n),'0100000b'))
p=pt[n%4]
for _ in range(n//4):p=(p<<4)+5
ss=list(format(p<<(N-n),'010000b'))
res=0
for _,a,b in zip(list(range(n)),s,ss):
d=int(b)-int(a)
res = res if d==0 else res+d
print(res)
if __name__=='__main__':v()
| import sys
def v():
pt=[5,0,1,2]
s=list(['0' if x=='g' else '1' for x in list(sys.stdin.readline().strip())])
n=len(s)
p=pt[n%4]
for _ in range(n//4):p=(p<<4)+5
ss=list(format(p,'b').zfill(n))
res=0
for a,b in zip(s,ss):
d=int(b)-int(a)
res = res if d==0 else res+d
print(res)
if __name__=='__main__':v()
| p03965 |
#len(s)//2-s.count("p")
iG = 0
iR = 0
for g in [int(_) for _ in list(input().rstrip().replace("g","1").replace("p","0"))]:
if g :
if 0 < iG:
iR += 1
iG -= 1
else:
iG += 1
else:
if 0 < iG:
iG -= 1
else:
iR -= 1
iG += 1
print(iR)
| #len(s)//2-s.count("p")
iG = 0
iR = 0
for s in input().rstrip():
if s == "g" :
if 0 < iG:
iR += 1
iG -= 1
else:
iG += 1
else:
if 0 < iG:
iG -= 1
else:
iR -= 1
iG += 1
print(iR)
| p03965 |
def d_AtCoDeer_and_RockPaper(S):
# 解説どおり
n = len(S) # ターン数
p = 0 # 相手がパーを出した回数
for c in S:
if c == 'p':
p += 1
return n // 2 - p
S = input().strip()
print((d_AtCoDeer_and_RockPaper(S))) | def d_atcodeer_and_rock_paper(S):
return len(S) // 2 - S.count('p')
S = input().strip()
print((d_atcodeer_and_rock_paper(S))) | p03965 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
S = readline().strip()
g, p = 0, 0
ans = 0
for c in S:
if g > p:
p += 1
if c == 'g':
ans += 1
else:
g += 1
if c == 'p':
ans -= 1
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
S = readline().strip()
ans = len(S) // 2 - S.count('p')
print(ans)
return
if __name__ == '__main__':
main()
| p03965 |
N = int(eval(input()))
A = list(map(int, input().split()))
T = [None] * N
c = 0
from functools import reduce
def check():
def f(a, b):
return a * b
global c
r = reduce(f, T)
# print(T, r)
if r % 2 == 0:
c += 1
def dfs(pos):
if pos == N:
check()
return
T[pos] = A[pos] - 1
dfs(pos+1)
T[pos] = A[pos]
dfs(pos+1)
T[pos] = A[pos] + 1
dfs(pos+1)
dfs(0)
print(c) | N = int(eval(input()))
A = list(map(int, input().split()))
total = 3 ** N
ng = 1
for ai in A:
if ai % 2 == 0:
ng *= 2
print((total-ng)) | p03568 |
from itertools import product
n = int(eval(input()))
A = list(map(int, input().split()))
count = 0
for C in product((-1, 0, 1), repeat=n):
total = 1
for a, c in zip(A, C):
total *= (a + c)
if total % 2 == 0:
count += 1
print(count) | n = int(eval(input()))
A = list(map(int, input().split()))
count = 1
for a in A:
count *= 2 if a % 2 == 0 else 1
print((3 ** n - count)) | p03568 |
import math
import string
def readints():
return list(map(int, input().split()))
def nCr(n, r):
return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))
def has_duplicates2(seq):
seen = []
for item in seq:
if not(item in seen):
seen.append(item)
return len(seq) != len(seen)
def divisor(n):
divisor = []
for i in range(1, n+1):
if n % i == 0:
divisor.append(i)
return divisor
# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
n = int(eval(input()))
a = readints()
def func(l):
if len(l) == n:
for i in range(len(l)):
if l[i] % 2 == 0:
return 1
return 0
return func(l+[(a[len(l)])])+func(l+[(a[len(l)]-1)])+func(l+[(a[len(l)]+1)])
print((func([])))
| import math
import string
def readints():
return list(map(int, input().split()))
def nCr(n, r):
return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))
def has_duplicates2(seq):
seen = []
for item in seq:
if not(item in seen):
seen.append(item)
return len(seq) != len(seen)
def divisor(n):
divisor = []
for i in range(1, n+1):
if n % i == 0:
divisor.append(i)
return divisor
# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
n = int(eval(input()))
a = readints()
sum = 1
for i in range(len(a)):
if a[i] % 2 == 0:
sum *= 2
else:
sum *= 1
print((3**len(a)-sum))
| p03568 |
def main():
N = int(input())
A = [int(i) for i in input().split()]
if N == 1:
return print(1 if A[0] % 2 == 0 else 2)
ans = 0
d = (-1, 0, 1)
from itertools import product
for i in product(range(3), repeat=N):
cur = 1
for j in range(N):
cur *= (A[j] + d[i[j]])
if cur % 2 == 0:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = 3**N
cnt = len([a for a in A if a % 2 == 0])
ans -= 2**cnt
print(ans)
if __name__ == '__main__':
main()
| p03568 |
N = int(eval(input()))
A = [int(x) for x in input().split()]
ret = 0
for state in range(1 << N):
flag = False
ans = 1
for i in range(N):
if (state >> i & 1):
if A[i] % 2 == 1:
flag = True
ans *= 2
else:
if A[i] % 2 == 0:
flag = True
if flag:
ret += ans
print(ret)
| def main() -> None:
N = int(eval(input()))
ans = 3 ** N
odd = 1
for a in map(int, input().split()):
if a % 2 == 0:
odd *= 2
print((ans - odd))
if __name__ == '__main__':
main()
| p03568 |
n = int(eval(input()))
a = list(map(int,input().split()))
amax = []
amin = []
for i in range(n):
amax.append(a[i] + 1)
amin.append(a[i] - 1)
m = 3 ** n
for z in range(3 ** n):
asearch = []
amulti = 1
x = z
for i in range(n):
asearch.append(x % 3)
x = x // 3
for i in range(n):
if asearch[i] == 0:
amulti *= a[i]
elif asearch[i] == 1:
amulti *= amax[i]
else:
amulti *= amin[i]
if amulti % 2 != 0:
m -= 1
print(m) | n = int(eval(input()))
a = list(map(int,input().split()))
ans = 3 ** n
o = 1
for i in range(n):
if a[i] % 2 == 0:
o *= 2
else:
o *= 1
print((ans - o)) | p03568 |
print((3**int(eval(input()))-2**sum(int(s)%2==0for s in input().split()))) | print((3**int(eval(input()))-2**sum(~int(s)%2for s in input().split()))) | p03568 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000)
INF = 1<<32
def solve(N: int, A: "List[int]"):
ans = 1
t = 1
for i in range(N):
# if A[i] == 1 or A[i] == 100:
# t *= 2
# continue
t *= 3
if A[i]%2 == 0:
ans *= 2
print((t-ans))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000)
INF = 1<<32
def solve(N: int, A: "List[int]"):
ans = 1
t = 1
for i in range(N):
t *= 3
if A[i]%2 == 0:
ans *= 2
print((t-ans))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
| p03568 |
N = int(eval(input()))
A = list(map(int,input().split()))
odd_count = 1
for a in A:
if a%2 != 0:
odd_count *= 1
else:
odd_count *= 2
print((3**N - odd_count)) | N = int(eval(input()))
A = list(map(int,input().split()))
odd_count = 1
for a in A:
if a%2 == 0:
odd_count *= 2
print((3**N - odd_count)) | p03568 |
from functools import reduce
from itertools import product
N = int(eval(input()))
*A, = list(map(int, input().split()))
ans = 0
for t in product([-1, 0, 1], repeat=N):
prod = reduce(lambda x, y: x*y, [a + t[i] for i, a in enumerate(A)])
if prod % 2 == 0: ans += 1
print(ans) | N = int(eval(input()))
*A, = list(map(int, input().split()))
evens = 0
for a in A:
if a % 2 == 0: evens += 1
ans = 3**N - 2**evens
print(ans) | p03568 |
n = int(eval(input()))
a = sum(list([1-int(x)%2 for x in input().split()]))
print((3**n-2**a))
| print((3**int(eval(input()))-2**sum(list([1-int(x)%2 for x in input().split()]))))
| p03568 |
N = int(eval(input()))
As = list(map(int,input().split()))
def dfs(A_s, index,Bss):
if index == N:
tmp = 1
for b in Bss:
tmp *= b
return 1 if tmp % 2 == 0 else 0
b_mi = Bss.copy()
b_mi.append(A_s[index] - 1)
b = Bss.copy()
b.append(A_s[index])
b_pl = Bss.copy()
b_pl.append(A_s[index] + 1)
return dfs(A_s,index + 1, b_mi) + dfs(A_s,index + 1,b) + dfs(A_s,index + 1,b_pl)
print((dfs(As,0,[])))
| N = int(eval(input()))
As = list(map(int,input().split()))
tmp = 1
for i in range(N):
if As[i] % 2 == 0:
tmp *= 2
print((3 ** N - tmp)) | p03568 |
n = int(eval(input()))
print(('ABC' if n<1000 else 'ABD')) | print(('ABD' if int(eval(input()))>=1000 else 'ABC')) | p03327 |
n = int(eval(input()))
if n < 1000:
print("ABC")
else:
print("ABD") | n = int(eval(input()))
if n > 999:
print("ABD")
else:
print("ABC") | p03327 |
n = int(eval(input()))
if n <= 999:
print('ABC')
else:
print('ABD')
| n = int(eval(input()))
if n >= 1000:
print('ABD')
else:
print('ABC')
| p03327 |
print(('AB'+('C' if int(eval(input())) < 1000 else 'D'))) | N = int(eval(input()))
if N < 1000:
ans = "ABC"
N += 1000
N = str(N)
N = N[1:]
ans += N
else:
ans = "ABD"
N -= 999
N += 1000
N = str(N)
N = N[1:]
ans += N
print((ans[:3])) | p03327 |
print((('ABC','ABD')[len(input()[3:])])) | print((('ABD','ABC')[not input()[3:]])) | p03327 |
N=eval(input())
N=int(N)
if N<1000:
print('ABC')
elif N>=1000:
print('ABD') | N=eval(input())
N=int(N)
if N<1000:
print('ABC')
else:
print('ABD') | p03327 |
#S=input()
N=int(eval(input()))
#A,B=map(int,input().split())
if N<1000:
print("ABC")
else:
print("ABD") | N=int(eval(input()))
if N>999:
print("ABD")
else:
print("ABC")
| p03327 |
print(("ABC" if int(eval(input()))<1000 else "ABD")) | print((['ABC','ABD'][int(eval(input()))>999])) | p03327 |
print(('ABC' if int(eval(input())) < 1000 else 'ABD')) | # coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
answer = 'ABC' if N < 1000 else 'ABD'
print(answer)
| p03327 |
def main():
num = int(eval(input()))
if num<1000:
ans = 'ABC'
elif num < 1999:
ans = 'ABD'
else:
print("error")
print(ans)
if __name__ == "__main__":
main() | N = int(eval(input()))
if N < 1000:
print("ABC")
else:
print("ABD") | p03327 |
a = int(eval(input()))
if a > 999:
print("ABD")
else:
print("ABC") | a=int(eval(input()))
print(("ABC" if a<1000 else "ABD")) | p03327 |
print("ABC") if int(input())<=999 else print("ABD")
| if int(eval(input()))<1000:
print("ABC")
else:
print("ABD") | p03327 |
n=int(eval(input()))
if n<=999:
print("ABC")
else:
print("ABD") | if int(eval(input()))<=999:
print("ABC")
else:
print("ABD") | p03327 |
n=int(eval(input()))
if n<=999:
print('ABC')
else:
print('ABD') | n=int(eval(input()))
print(('ABC' if n<1000 else 'ABD')) | p03327 |
n = int(eval(input()))
if n <= 999:
print("ABC")
else:
print("ABD")
| n = int(eval(input()))
if n < 1000:
ans = "ABC"
else:
ans = "ABD"
print(ans)
| p03327 |
# -*- coding: utf-8 -*-
N = int(eval(input()))
if N >= 1000:
print("ABD")
else:
print("ABC") | N = int(eval(input()))
if N >= 1000:
print("ABD")
else:
print("ABC") | p03327 |
n = int(eval(input()))
if n < 1000:
print('ABC')
else:
print('ABD') | N = int(eval(input()))
print(('ABC' if N < 1000 else 'ABD')) | p03327 |
from sys import stdin
import fractions
n = int(stdin.readline().rstrip())
if n <1000:
print("ABC")
else:
print("ABD") | n = int(eval(input()))
if n < 1000:
print("ABC")
else:
print("ABD") | p03327 |
n=int(eval(input()))
if n<=999:
print("ABC")
else:
print("ABD")
| n=int(eval(input()))
x=n-999 if n>999 else n
if n>999:
print("ABD")
else:
print("ABC")
| p03327 |
a, b, x = list(map(int, input().split()))
if a%x == 0:
print(((b//x+1) - (a//x)))
else:
print(((b//x+1) - (a//x+1)))
| a, b, x = list(map(int, input().split()))
def f(n):
if n == -1:
return 0
else:
return n//x + 1
print((f(b) - f(a-1))) | p03861 |
from decimal import *
a, b, x = list(map(int, input().split()))
ax = int(Decimal(a) / Decimal(x))
bx = int(Decimal(b) / Decimal(x))
am = a % x
bm = b % x
if ax == bx and am != 0 and bm != 0:
print((0))
elif am == 0:
print((bx - ax + 1))
else:
print((bx - ax)) | a, b, x = list(map(int, input().split()))
ans = b // x - a // x
if a % x == 0:
ans += 1
print(ans) | p03861 |
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
a,b,x=list(map(int, input().split()))
if a!=0:
amade=(a-1)//x
bmade=b//x
print((bmade-amade))
else:
print((b//x+1))
resolve() | import sys
def input(): return sys.stdin.readline().strip()
def resolve():
a,b,x=list(map(int, input().split()))
amade=(a-1)//x
bmade=b//x
print((bmade-amade))
resolve() | p03861 |
a, b, x = list(map(int, input().split()))
for i in range(x):
fa = a+i
if fa%x == 0:
break
if b < fa:
print((0))
else:
print((1+(b-fa)//x)) | a, b, x = list(map(int, input().split()))
i = 0
fa = x*i
while x*i < a:
i += 1
fa = x*i
if b < fa:
print((0))
else:
print((1+(b-fa)//x)) | p03861 |
from decimal import *
#exp = Decimal(10**23)
#rint((Decimal(11)*exp)/Decimal(10))
## coding: UTF-8
s = input().split()
t = [int(p) for p in s]
#print(t)
a = t[0]
b = t[1]
x = t[2]
start = a
goal = b
while True:
if(start % x == 0):
break
else:
start += 1
#print(start)
while True:
if(goal % x == 0):
break
else:
goal -= 1
#start = Decimal(3)
#goal = Decimal(999999999999999999)
#print(Decimal(goal))
print((Decimal(Decimal(Decimal(goal) - Decimal(start)) / Decimal(x)) + Decimal(1) ))
#answer = ((goal - start) / x ) + 1
#print('{}'.format(int(answer))) | from decimal import *
#exp = Decimal(10**23)
#rint((Decimal(11)*exp)/Decimal(10))
## coding: UTF-8
s = input().split()
t = [int(p) for p in s]
#print(t)
a = t[0]
b = t[1]
x = t[2]
'''
start = a
goal = b
while True:
if(start % x == 0):
break
else:
start += 1
#print(start)
while True:
if(goal % x == 0):
break
else:
goal -= 1
#start = Decimal(3)
#goal = Decimal(999999999999999999)
#print(Decimal(goal))
print(Decimal(Decimal(Decimal(goal) - Decimal(start)) / Decimal(x)) + Decimal(1) )
#answer = ((goal - start) / x ) + 1
#print('{}'.format(int(answer)))
'''
def count_even(t, x):
return int( Decimal(t)/ Decimal(x) )
if( a == 0):
answer = count_even(b, x) + 1
else:
answer = count_even(b, x) - count_even(a-1, x)
print(answer) | p03861 |
from decimal import *
#exp = Decimal(10**23)
#rint((Decimal(11)*exp)/Decimal(10))
## coding: UTF-8
s = input().split()
t = [int(p) for p in s]
#print(t)
a = t[0]
b = t[1]
x = t[2]
'''
start = a
goal = b
while True:
if(start % x == 0):
break
else:
start += 1
#print(start)
while True:
if(goal % x == 0):
break
else:
goal -= 1
#start = Decimal(3)
#goal = Decimal(999999999999999999)
#print(Decimal(goal))
print(Decimal(Decimal(Decimal(goal) - Decimal(start)) / Decimal(x)) + Decimal(1) )
#answer = ((goal - start) / x ) + 1
#print('{}'.format(int(answer)))
'''
def count_even(t, x):
return int( Decimal(t)/ Decimal(x) )
if( a == 0):
answer = count_even(b, x) + 1
else:
answer = count_even(b, x) - count_even(a-1, x)
print(answer) | a, b, x = list(map(int,input().split()))
if(a%x == 0):
A = a//x
else:
A = a//x + 1
B = b//x
print((B-A+1)) | p03861 |
arr = input().split()
arr = list(map(int,arr))
a = arr[0]
b = arr[1]
x = arr[2]
c = a
left = 0
while(True):
if c % x == 0:
left = c
break
else:
c += 1
c = b
while(True):
if c % x == 0:
right = c
break
else:
c -= 1
print(((right - left) // x + 1))
| arr = input().split()
arr = list(map(int,arr))
a = arr[0]
b = arr[1]
x = arr[2]
def f(n):
if n == -1:
return 0
else:
return n // x + 1
print((f(b) - f(a-1)))
| p03861 |
a, b, x = list(map(int, input().split()))
c=a//x
d=b//x
e=a%x
if(e == 0):
print((d-c+1))
else:
print((d-c)) | a,b,x=list(map(int, input().split()))
c=b//x-a//x
if(a%x==0):
print((c+1))
else:
print(c) | p03861 |
a, b, x = list(map(int, input().split()))
ans = 0
p = a
while p <= b:
if p%x == 0:
break
p += 1
t = b-p
s = t//x
ans = s + 1
print(ans) | a, b, x = list(map(int, input().split()))
p = 0
y = int(b//x) + 1
i = 1
#for i in range(1,y):
while x*i <= b:
if a <= x*i:
p = x*i
break
i += 1
if p != 0:
t = b-p
s = t//x
ans = s + 1
if a == 0:
ans += 1
print(ans)
elif a == 0:
print((1))
else:
print((0)) | p03861 |
# ABC48, B - between a and b
import itertools
a, b, x = [int(el) for el in input().split(' ')]
for i in itertools.count(a):
if i % x == 0:
A = i
break
for i in itertools.count(b, -1):
if i % x == 0:
B = i
break
print((B // x - A // x +1))
| # ABC48, B - between a and b
def f(n, x):
if n == -1:
return(0)
else:
return(n // x + 1)
a, b, x = [int(el) for el in input().split(' ')]
print((f(b, x) - f(a-1, x)))
| p03861 |
a,b,x = list(map(int, input().split()))
s = b//x
t = (a-1)//x
print((s-t)) | a,b,x = list(map(int, input().split()))
print((b//x - (a-1)//x)) | p03861 |
import sys
a, b, x = list(map(int, input().split()))
if a == b == 0:
print((1))
sys.exit()
if x > b:
if a != 0:
print((0))
sys.exit()
else:
print((1))
sys.exit()
if x <= b:
if a % x == 0:
print((b // x - a //x + 1))
else:
print((b // x - a // x))
| import sys
a, b, x = list(map(int, input().split()))
if a == b == 0:
print((1))
sys.exit()
if a % x == 0:
print((b // x - a //x + 1))
else:
print((b // x - a // x))
| p03861 |
a, b, x = list(map(int, input().split()))
print((b // x - (a - 1) // x)) | a, b, x = list(map(int, input().split()))
print((b // x - ~-a // x)) | p03861 |
a, b, x = list(map(int, input().split()))
def max_search(s, t):
for i in range(s):
if (s-i) % t == 0:
return (s-i) // t
return 0
a_max = max_search(a-1, x)
b_max = max_search(b, x)
if a == 0:
b_max += 1
print((b_max-a_max)) | a, b, x = list(map(int, input().split()))
a_max = max(((a-1) // x, 0))
b_max = b // x
if a == 0:
b_max += 1
print((b_max-a_max)) | p03861 |
a,b,x=list(map(int, input().split()))
print((b//x-((a-1)//x+1)+1)) | a,b,x=list(map(int, input().split()))
print((b//x-(a-1)//x))
| p03861 |
A,B,X = list(map(int,input().split()))
print((B//X - (A-1)//X)) | # python3 (3.4.3)
import sys
input = sys.stdin.readline
# main
A,B,X = list(map(int,input().split()))
print((B//X - (A-1)//X)) | p03861 |
start,end,devide = list(map(int,input().split()))
num = 0
for i in range(start,end + 1):
if i % devide == 0:
num +=1
num += (end - i) // devide
break
print(num) | a, b, x = list(map(int, input().split()))
if a != 0:
print((b//x - (a-1)//x))
else:
print((b//x + 1)) | p03861 |
a, b, x = list(map(int, input().split()))
key = 0
count = 0
if a == b:
if a % x == 0:
print((1))
exit()
else:
print((0))
exit()
for i in range(a, b + 1, 1):
if i % x == 0:
key = i
count += 1
ans = count + (b - key) // x
print(ans)
exit() | a, b, x = list(map(int, input().split()))
big = b // x + 1
small = (a - 1) // x + 1
ans = big - small
if ans < 0:
ans = 0
print(ans) | p03861 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.