input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from collections import deque
import sys
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
G = [[] for i in range(N)]
for i in range(M):
a, b = list(map(int, readline().split()))
a -= 1; b -= 1
G[a].append(b)
G[b].append(a)
def check(s, t):
u = [0]*N
u[s] = u[t] = 1
for v in G[s]:
if v == t:
continue
u[v] = 1
que = deque([v])
ok = 0
while que:
x = que.popleft()
for y in G[x]:
if y == s and x != v:
return 1
if u[y]:
continue
u[y] = 1
que.append(y)
return 0
C = [0]*4
ok = 1
for i in range(N):
if len(G[i]) % 2 == 1:
ok = 0
C[min(3, len(G[i])//2)] += 1
if C[1] == N or (C[1] == N-1 and C[2] == 1):
ok = 0
elif C[1] == N-2 and C[2] == 2:
VV = []
for i in range(N):
if len(G[i]) == 4:
VV.append(i)
if not check(*VV):
ok = 0
print(("Yes" if ok else "No")) | from collections import deque
import sys
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
G = [[] for i in range(N)]
for i in range(M):
a, b = list(map(int, readline().split()))
a -= 1; b -= 1
G[a].append(b)
G[b].append(a)
def check(s, t):
u = [0]*N
u[s] = u[t] = 1
que = deque()
for v in G[s]:
if v == t:
continue
u[v] = 1
que.append(v)
ok = 0
while que:
x = que.popleft()
for y in G[x]:
if y == s and x != v:
return 1
if not u[y]:
u[y] = 1
que.append(y)
return 0
C = [0]*4
ok = 1
for i in range(N):
if len(G[i]) % 2 == 1:
ok = 0
C[min(3, len(G[i])//2)] += 1
if C[1] == N or (C[1] == N-1 and C[2] == 1):
ok = 0
elif C[1] == N-2 and C[2] == 2:
VV = []
for i in range(N):
if len(G[i]) == 4:
VV.append(i)
if not check(*VV):
ok = 0
print(("Yes" if ok else "No")) | p03091 |
import sys
def solve(n, m, links):
v4 = set()
v6 = 0
for v, link in enumerate(links):
l = len(link)
if l % 2 == 1:
return False
if l == 4:
v4.add(v)
elif l >= 6:
v6 += 1
if v6 > 0:
return True
if len(v4) > 2:
return True
if len(v4) < 2:
return False
s = v4.pop()
t = v4.pop()
visited = set()
q = [s]
while q:
v = q.pop()
if v == t:
continue
if v == s:
if s in visited:
return True
elif v in visited:
continue
visited.add(s)
q.extend(u for u in links[v] if u not in visited)
return False
n, m = list(map(int, input().split()))
links = [set() for _ in [0] * n]
for line in sys.stdin:
a, b = list(map(int, line.split()))
a -= 1
b -= 1
links[a].add(b)
links[b].add(a)
print(('Yes' if solve(n, m, links) else 'No'))
| import sys
def solve(n, m, links):
v4 = set()
v6 = 0
for v, link in enumerate(links):
l = len(link)
if l % 2 == 1:
return False
if l == 4:
v4.add(v)
elif l >= 6:
v6 += 1
if v6 > 0:
return True
if len(v4) > 2:
return True
if len(v4) < 2:
return False
s = v4.pop()
t = v4.pop()
for c in links[s]:
visited = {s, t}
q = [c]
while q:
v = q.pop()
if v in visited:
continue
visited.add(v)
for u in links[v]:
if v != c and u == s:
return True
if u not in visited:
q.append(u)
return False
n, m = list(map(int, input().split()))
links = [set() for _ in [0] * n]
for line in sys.stdin:
a, b = list(map(int, line.split()))
a -= 1
b -= 1
links[a].add(b)
links[b].add(a)
print(('Yes' if solve(n, m, links) else 'No'))
| p03091 |
# AGC032C
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
def hoge():
from collections import defaultdict
n, m = list(map(int, input().split()))
ns = defaultdict(set)
used = {}
for _ in range(m):
u,v = list(map(int, input().split()))
ns[u-1].add(v-1)
ns[v-1].add(u-1)
used[u-1,v-1] = False
used[v-1,u-1] = False
seen = [False] * n
prev = [None] * n
cs = []
count = 0
done = True
if not all(len(item)%2==0 and len(item)>0 for item in list(ns.values())):
print("No")
return
for start in range(n):
if seen[start]:
continue
q = [start]
current_seen = [False] * n
update = False
while q:
# print(q)
u = q.pop()
current_seen[u] = True
for v in ns[u]:
if used[u,v] or prev[u]==v:
continue
prev[v] = u
if current_seen[v]:
# サイクル検出
count += 1
c = set()
tmp = v
while tmp not in c:
c.add(tmp)
used[tmp, prev[tmp]] = used[prev[tmp], tmp] = True
tmp = prev[tmp]
cs.append(c)
for u in c:
seen[u] = True
update = True
break
q.append(v)
if update:
break
if not update:
print("No")
done = False
break
def sub(cs):
if len(cs)==1:
return "No"
elif len(cs)==2:
if len(set(cs[0] & cs[1]))>=3:
return "Yes"
else:
return "No"
else :
return "Yes"
# u2s = defaultdict(set)
# nns = defaultdict(set) # i番目のサイクルと重なるサイクル
# for i,s in enumerate(cs):
# for u in s:
# nns[i] |= u2s[u]
# u2s[u].add(i)
# for i,s in nns.items():
# for j in s:
# nns[j].add(i)
# count = 0
# # print(u2s)
# # print(nns)
# seen = [False] * len(cs)
# for start in range(len(cs)):
# if seen[start]:
# continue
# q = [start]
# seen[start] = True
# while q:
# u = q.pop()
# for v in nns[u]:
# if not seen[v]:
# q.append(v)
# seen[v] = True
# count += 1
# if count<=3:
# return "Yes"
# else:
# return "No"
if done:
print((sub(cs)))
# print("Yes")
hoge() | # AGC032C
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
def hoge():
from collections import defaultdict
n, m = list(map(int, input().split()))
ns = defaultdict(set)
used = {}
for _ in range(m):
u,v = list(map(int, input().split()))
ns[u-1].add(v-1)
ns[v-1].add(u-1)
used[u-1,v-1] = False
used[v-1,u-1] = False
seen = [False] * n
prev = [None] * n
cs = []
count = 0
done = True
# if not all(len(item)%2==0 and len(item)>0 for item in ns.values()):
# print("No")
# return
for start in range(n):
if seen[start]:
continue
q = [start]
current_seen = [False] * n
update = False
while q:
u = q.pop()
current_seen[u] = True
for v in ns[u]:
if used[u,v] or prev[u]==v:
continue
prev[v] = u
if current_seen[v]:
# サイクル検出
count += 1
c = set()
tmp = v
while tmp not in c:
c.add(tmp)
used[tmp, prev[tmp]] = used[prev[tmp], tmp] = True
tmp = prev[tmp]
cs.append(c)
for u in c:
seen[u] = True
update = True
break
q.append(v)
if update:
break
if not update:
print("No")
return
if sum(seen)<n:
print("No")
return
def sub(cs):
if len(cs)==1:
return "No"
elif len(cs)==2:
if len(set(cs[0] & cs[1]))>=3:
return "Yes"
else:
return "No"
else :
return "Yes"
# u2s = defaultdict(set)
# nns = defaultdict(set) # i番目のサイクルと重なるサイクル
# for i,s in enumerate(cs):
# for u in s:
# nns[i] |= u2s[u]
# u2s[u].add(i)
# for i,s in nns.items():
# for j in s:
# nns[j].add(i)
# count = 0
# # print(u2s)
# # print(nns)
# seen = [False] * len(cs)
# for start in range(len(cs)):
# if seen[start]:
# continue
# q = [start]
# seen[start] = True
# while q:
# u = q.pop()
# for v in nns[u]:
# if not seen[v]:
# q.append(v)
# seen[v] = True
# count += 1
# if count<=3:
# return "Yes"
# else:
# return "No"
if done:
print((sub(cs)))
# print("Yes")
hoge() | p03091 |
# -*- coding: utf-8 -*-
from collections import defaultdict
def solve():
N, M = list(map(int, input().split()))
F = defaultdict(list)
D = defaultdict(int)
for _ in range(M):
a, b = list(map(int, input().split()))
D[a] += 1
D[b] += 1
F[a] += F[a] + [b]
F[b] += F[b] + [a]
E = defaultdict(int)
X = list()
for a,d in list(D.items()):
if d%2==0:
if d >= 6:
E[6] += 1
elif d == 4:
E[4] += 1
X.append(a)
else:
E[d] += 1
else:
E[1] += 1
if E[1]==0 and (E[6]>=1 or E[4]>=3):
res = 'Yes'
elif E[4]==2:
x, y = X
q = set((y,))
R = set((x,))
while q:
z = q.pop()
R.add(z)
q |= set(F[z])-R
if set(F[x])&R == set(F[x]):
res = 'No'
else:
res = 'Yes'
else:
res = 'No'
return str(res)
if __name__ == '__main__':
print((solve()))
| # -*- coding: utf-8 -*-
def solve():
N, M = list(map(int, input().split()))
F = [list() for _ in range(N+1)]
D = [int() for _ in range(N+1)]
for _ in range(M):
a, b = list(map(int, input().split()))
D[a] += 1
D[b] += 1
F[a].append(b)
F[b].append(a)
E = [0 for _ in range(7)]
X = list()
for a,d in enumerate(D[1:], start=1):
if d%2==0:
if d >= 6:
E[6] += 1
elif d == 4:
E[4] += 1
X.append(a)
else:
E[d] += 1
else:
return 'No'
E[1] += 1
if E[6]>0 or E[4]>2:
return 'Yes'
elif E[4]<2:
return 'No'
else:
x, y = X
q = set((y,))
R = set((x,))
while q:
z = q.pop()
R.add(z)
q |= set(F[z])-R
if set(F[x])&R == set(F[x]):
return 'No'
else:
return 'Yes'
if __name__ == '__main__':
print((solve()))
| p03091 |
while 1:
a, b, c = list(map(int, input().split()))
if not a:
break
n = eval(input())
I = []; J = []; K = []
res = [2]*(a+b+c)
for p in range(n):
i, j, k, r = list(map(int, input().split()))
i -= 1; j -= 1; k -= 1
if r:
res[i] = res[j] = res[k] = 1
else:
I.append(i); J.append(j); K.append(k)
for p in range(len(I)):
i, j, k = I[p], J[p], K[p]
if res[i]==res[j]==res[k]==1:
continue
if res[i]==res[j]==1:
res[k] = 0
elif res[j]==res[k]==1:
res[i] = 0
elif res[k]==res[i]==1:
res[j] = 0
for i in range(a+b+c):
print(res[i]) | while 1:
a, b, c = list(map(int, input().split()))
if not a:
break
I = []
res = [2]*(a+b+c)
for p in range(int(input())):
i, j, k, r = list(map(int, input().split()))
i -= 1; j -= 1; k -= 1
if r:
res[i] = res[j] = res[k] = 1
else:
I.append((i, j, k))
for e in I:
i, j, k = e
if res[i]+res[j]+res[k]!=4:
continue
if res[i]==2:
res[i] = -1
elif res[j]==2:
res[j] = -1
else:
res[k] = -1
for i in range(a+b+c):
print(res[i] if res[i]>=0 else 0) | p00437 |
import math
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree", "lazy"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size
self.tree = [default]*self.elem_size + a + [default]*(self.elem_size - real_size)
self.lazy = [None]*self.tree_size
self.init_tree()
def init_tree(self):
tree = self.tree
for i in range(self.elem_size-1, 0, -1):
left, right = tree[i << 1], tree[(i << 1)+1]
# ===== change me =====
tree[i] = left if left < right else right
def get_indexes(self, l: int, r: int):
'''[x, y)'''
l, r, indexes = l+self.elem_size, r+self.elem_size, []
append = indexes.append
while l < r:
if l & 1:
append(l)
l += 1
if r & 1:
r -= 1
append(r)
l, r = l >> 1, r >> 1
return indexes
def get_indexes_with_propagation(self, l: int, r: int, current_node: int, l_end: int, r_end: int):
# print(l,r,current_node,l_end,r_end,self.lazy[current_node])
indexes = []
tree, lazy = self.tree, self.lazy
lazy_value = lazy[current_node]
left_child, right_child = current_node << 1, (current_node << 1) + 1
if lazy_value is not None:
self.lazy[current_node] = None
tree[current_node] = lazy_value
if left_child < self.tree_size:
if left_child < self.elem_size:
lazy[left_child] = lazy[right_child] = lazy_value
else:
tree[left_child] = tree[right_child] = lazy_value
if l == l_end and r == r_end:
return [current_node]
mid = (l_end + r_end) // 2
if l < mid:
l_r = r if r < mid else mid
indexes += self.get_indexes_with_propagation(l, l_r, left_child, l_end, mid)
if r > mid:
r_l = l if mid < l else mid
indexes += self.get_indexes_with_propagation(r_l, r, right_child, mid, r_end)
return indexes
def update_lazy(self, l, r, value):
indexes = sorted(self.get_indexes_with_propagation(l, r, 1, 0, self.elem_size))
l = self.elem_size
lazy, tree, update = self.lazy, self.tree, self.update_tree
for n in indexes:
lazy[n] = None
if n < l//2:
lazy[n << 1] = value
lazy[(n << 1)+1] = value
elif n < l:
tree[n << 1] = value
tree[(n << 1)+1] = value
tree[n] = value
update(n)
def get_value(self, l: int, r: int):
tree = self.tree
indexes = self.get_indexes_with_propagation(l, r, 1, 0, self.elem_size)
update = self.update_tree
for n in indexes:
update(n)
# ===== change me =====
return min(tree[n] for n in indexes)
def update_tree(self, k: int):
tree, lazy = self.tree, self.lazy
if k >= self.elem_size:
k >>= 1
while k > 0:
left, right = k << 1, (k << 1)+1
if lazy[k] is None:
if lazy[left] is not None:
tree[left] = lazy[left]
if lazy[right] is not None:
tree[right] = lazy[right]
tree[k] = tree[left] if tree[left] < tree[right] else tree[right]
else:
tree[left] = tree[right] = tree[k] = lazy[k]
lazy[left] = lazy[right] = lazy[k] = None
# ===== change me =====
k >>= 1
def set_value(self, i: int, value: int, op: str):
k = self.elem_size + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = list(map(int, input().split()))
rmq = SegmentTree([2**31-1]*n, 2**31-1)
ans = []
append = ans.append
for _ in [0]*q:
l = list(map(int, input().split()))
if l[0] == 0:
rmq.update_lazy(l[1], l[2]+1, l[3])
else:
a = rmq.get_value(l[1], l[2]+1)
append(a)
print(("\n".join([str(n) for n in ans]))) | import math
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree", "lazy"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size
self.tree = [default]*self.elem_size + a + [default]*(self.elem_size - real_size)
self.lazy = [None]*self.tree_size
self.init_tree()
def init_tree(self):
tree = self.tree
for i in range(self.elem_size-1, 0, -1):
left, right = tree[i << 1], tree[(i << 1)+1]
# ===== change me =====
tree[i] = left if left < right else right
def get_indexes(self, l: int, r: int):
'''[x, y)'''
l, r, targets, path, p_l, p_r, = l+self.elem_size, r+self.elem_size, [], set(), 0, 0
t_ap, p_add = targets.append, path.add
while l < r:
if l & 1:
t_ap(l)
p_l = p_l or l >> 1
l += 1
if r & 1:
r -= 1
t_ap(r)
p_r = p_r or r >> 1
l, r = l >> 1, r >> 1
while p_l > 0 or p_r > 0:
if p_l > 0:
p_add(p_l)
p_l >>= 1
if p_r > 0:
p_add(p_r)
p_r >>= 1
#print(targets, path)
return sorted(targets), sorted(path)
def propagate(self, indexes: list, value: int = None):
tree, lazy = self.tree, self.lazy
if value is None:
for n in indexes:
if lazy[n] is None:
continue
tree[n] = lazy[n]
if n < self.elem_size:
lazy[n << 1] = lazy[(n << 1)+1] = lazy[n]
lazy[n] = None
else:
for n in indexes:
if n < self.elem_size:
lazy[n << 1] = lazy[(n << 1)+1] = value
tree[n] = value
lazy[n] = None
self.update_tree(n)
def get_indexes_with_propagation(self, l: int, r: int, current_node: int, l_end: int, r_end: int):
# print(l,r,current_node,l_end,r_end,self.lazy[current_node])
indexes = []
tree, lazy = self.tree, self.lazy
lazy_value, lazy[current_node] = lazy[current_node], None
left_child, right_child = current_node << 1, (current_node << 1) + 1
if lazy_value is not None:
tree[current_node] = lazy_value
if left_child < self.tree_size:
lazy[left_child] = lazy[right_child] = lazy_value
if l == l_end and r == r_end:
return [current_node]
mid = (l_end + r_end) // 2
if l < mid:
l_r = r if r < mid else mid
indexes += self.get_indexes_with_propagation(l, l_r, left_child, l_end, mid)
if r > mid:
r_l = l if mid < l else mid
indexes += self.get_indexes_with_propagation(r_l, r, right_child, mid, r_end)
return indexes
def update_lazy(self, l, r, value):
'''
indexes = sorted(self.get_indexes_with_propagation(l, r, 1, 0, self.elem_size))
l = self.elem_size
lazy, tree, update = self.lazy, self.tree, self.update_tree
for n in indexes:
lazy[n] = None
if n < l:
lazy[n << 1] = value
lazy[(n << 1)+1] = value
tree[n] = value
update(n)
print("update_lazy",indexes)
'''
targets, paths = self.get_indexes(l, r)
self.propagate(paths)
self.propagate(targets, value)
def get_value(self, l: int, r: int):
'''
tree = self.tree
indexes = self.get_indexes_with_propagation(l, r, 1, 0, self.elem_size)
update = self.update_tree
for n in indexes:
update(n)
'''
tree = self.tree
targets, paths = self.get_indexes(l, r)
self.propagate(paths)
self.propagate(targets)
# ===== change me =====
#print([(n,tree[n]) for n in indexes])
return min(tree[n] for n in targets)
def update_tree(self, k: int):
tree, lazy = self.tree, self.lazy
if k >= self.elem_size:
k >>= 1
while k > 0:
left, right = k << 1, (k << 1)+1
if lazy[k] is None:
if lazy[left] is not None:
tree[left] = lazy[left]
if lazy[right] is not None:
tree[right] = lazy[right]
tree[k] = tree[left] if tree[left] < tree[right] else tree[right]
else:
tree[left] = tree[right] = tree[k] = lazy[k]
lazy[left] = lazy[right] = lazy[k] = None
# ===== change me =====
k >>= 1
def set_value(self, i: int, value: int, op: str):
k = self.elem_size + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = list(map(int, input().split()))
rmq = SegmentTree([2**31-1]*n, 2**31-1)
ans = []
append = ans.append
for _ in [0]*q:
l = list(map(int, input().split()))
if l[0] == 0:
rmq.update_lazy(l[1], l[2]+1, l[3])
#print(rmq.get_indexes(l[1],l[2]+1))
else:
a = rmq.get_value(l[1], l[2]+1)
#print(rmq.get_indexes(l[1],l[2]+1))
append(a)
#print(rmq.tree,rmq.lazy)
print(("\n".join([str(n) for n in ans]))) | p02350 |
import math
from collections import deque
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree", "lazy"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size
self.tree = [default]*self.elem_size + a + [default]*(self.elem_size - real_size)
self.lazy = [None]*self.tree_size
self.init_tree()
def init_tree(self):
tree = self.tree
for i in range(self.elem_size-1, 0, -1):
left, right = tree[i << 1], tree[(i << 1)+1]
# ===== change me =====
tree[i] = left if left < right else right
def get_indexes(self, l: int, r: int):
'''[x, y)'''
l, r, targets, path, p_l, p_r, = l+self.elem_size, r+self.elem_size, deque(), deque(), 0, 0
t_ap, p_ap = targets.append, path.appendleft
while l < r:
if l & 1:
t_ap(l)
p_l = p_l or l >> 1
l += 1
if r & 1:
r -= 1
t_ap(r)
p_r = p_r or r >> 1
l, r = l >> 1, r >> 1
deepest = (p_l, p_r)
while p_l > 1 or p_r > 1:
if p_l > 1:
p_ap(p_l)
if p_l != p_r > 1:
p_ap(p_r)
p_l >>= 1
p_r >>= 1
#print(targets, path)
return targets, path, deepest
def propagate(self, indexes: list, value: int = None):
tree, lazy, elem_size = self.tree, self.lazy, self.elem_size
if value is None:
for n in indexes:
if lazy[n] is None:
continue
tree[n] = lazy[n]
if n < elem_size:
lazy[n << 1] = lazy[(n << 1)+1] = lazy[n]
lazy[n] = None
else:
for n in indexes:
if n < elem_size:
lazy[n << 1] = lazy[(n << 1)+1] = value
tree[n] = value
lazy[n] = None
def get_indexes_with_propagation(self, l: int, r: int, current_node: int, l_end: int, r_end: int):
# print(l,r,current_node,l_end,r_end,self.lazy[current_node])
indexes = []
tree, lazy = self.tree, self.lazy
lazy_value, lazy[current_node] = lazy[current_node], None
left_child, right_child = current_node << 1, (current_node << 1) + 1
if lazy_value is not None:
tree[current_node] = lazy_value
if left_child < self.tree_size:
lazy[left_child] = lazy[right_child] = lazy_value
if l == l_end and r == r_end:
return [current_node]
mid = (l_end + r_end) // 2
if l < mid:
l_r = r if r < mid else mid
indexes += self.get_indexes_with_propagation(l, l_r, left_child, l_end, mid)
if r > mid:
r_l = l if mid < l else mid
indexes += self.get_indexes_with_propagation(r_l, r, right_child, mid, r_end)
return indexes
def update_lazy(self, l, r, value):
'''
indexes = sorted(self.get_indexes_with_propagation(l, r, 1, 0, self.elem_size))
l = self.elem_size
lazy, tree, update = self.lazy, self.tree, self.update_tree
for n in indexes:
lazy[n] = None
if n < l:
lazy[n << 1] = value
lazy[(n << 1)+1] = value
tree[n] = value
update(n)
print("update_lazy",indexes)
'''
targets, paths, deepest = self.get_indexes(l, r)
self.propagate(paths)
self.propagate(targets, value)
self.update_tree(deepest[0])
self.update_tree(deepest[1])
def get_value(self, l: int, r: int):
'''
tree = self.tree
indexes = self.get_indexes_with_propagation(l, r, 1, 0, self.elem_size)
update = self.update_tree
for n in indexes:
update(n)
'''
tree = self.tree
targets, paths, deepest = self.get_indexes(l, r)
self.propagate(paths)
self.propagate(targets)
self.update_tree(deepest[0])
self.update_tree(deepest[1])
# ===== change me =====
#print([(n,tree[n]) for n in indexes])
return min(tree[n] for n in targets)
def update_tree(self, k: int):
tree, lazy = self.tree, self.lazy
if k >= self.elem_size:
k >>= 1
while k > 0:
left, right = k << 1, (k << 1)+1
if lazy[k] is None:
if lazy[left] is not None:
tree[left] = lazy[left]
if lazy[right] is not None:
tree[right] = lazy[right]
tree[k] = tree[left] if tree[left] < tree[right] else tree[right]
else:
tree[left] = tree[right] = tree[k] = lazy[k]
lazy[left] = lazy[right] = lazy[k] = None
# ===== change me =====
k >>= 1
def set_value(self, i: int, value: int, op: str):
k = self.elem_size + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = list(map(int, input().split()))
rmq = SegmentTree([2**31-1]*n, 2**31-1)
ans = []
append = ans.append
for _ in [0]*q:
l = list(map(int, input().split()))
if l[0] == 0:
rmq.update_lazy(l[1], l[2]+1, l[3])
#print(rmq.get_indexes(l[1],l[2]+1))
else:
a = rmq.get_value(l[1], l[2]+1)
#print(rmq.get_indexes(l[1],l[2]+1))
append(a)
#print(rmq.tree,rmq.lazy)
print(("\n".join([str(n) for n in ans]))) | import math
from collections import deque
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree", "lazy"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size
self.tree = [default]*self.elem_size + a + [default]*(self.elem_size - real_size)
self.lazy = [None]*self.tree_size
self.init_tree()
def init_tree(self):
tree = self.tree
for i in range(self.elem_size-1, 0, -1):
left, right = tree[i << 1], tree[(i << 1)+1]
# ===== change me =====
tree[i] = left if left < right else right
def get_indexes(self, l: int, r: int):
'''[x, y)'''
l, r, targets, path, p_l, p_r = l+self.elem_size, r+self.elem_size, deque(), deque(), 0, 0
t_ap, p_ap = targets.append, path.appendleft
while l < r:
if l & 1:
t_ap(l)
p_l = p_l or l >> 1
l += 1
if r & 1:
r -= 1
t_ap(r)
p_r = p_r or r >> 1
l >>= 1
r >>= 1
deepest = (p_l, p_r)
while p_l > 1 or p_r > 1:
if p_r != p_l > 1:
p_ap(p_l)
p_l >>= 1
if p_r > 1:
p_ap(p_r)
p_r >>= 1
#print(targets, path)
return targets, path, deepest
def propagate(self, indexes: list, value: int = None):
tree, lazy, elem_size = self.tree, self.lazy, self.elem_size
if value is None:
for n in indexes:
if lazy[n] is None:
continue
tree[n] = lazy[n]
if n < elem_size:
lazy[n << 1] = lazy[(n << 1)+1] = lazy[n]
lazy[n] = None
else:
for n in indexes:
if n < elem_size:
lazy[n << 1] = lazy[(n << 1)+1] = value
tree[n] = value
lazy[n] = None
def update_lazy(self, l, r, value):
targets, paths, deepest = self.get_indexes(l, r)
self.propagate(paths)
self.propagate(targets, value)
self.update_tree(deepest)
def get_value(self, l: int, r: int):
tree = self.tree
targets, paths, deepest = self.get_indexes(l, r)
self.propagate(paths)
self.propagate(targets)
self.update_tree(deepest)
# ===== change me =====
return min(tree[n] for n in targets)
def update_tree(self, indexes: tuple):
''' ????????????lazy?????¨????????¬????????§???????????¨???????????¨???????????? '''
tree, lazy = self.tree, self.lazy
for k in indexes:
#if k >= self.elem_size:
# k >>= 1
while k > 0:
left, right = k << 1, (k << 1)+1
# ===== change me =====
if lazy[left] is not None:
tree[left] = lazy[left]
if lazy[right] is not None:
tree[right] = lazy[right]
tree[k] = tree[left] if tree[left] < tree[right] else tree[right]
k >>= 1
def set_value(self, i: int, value: int, op: str):
k = self.elem_size + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = list(map(int, input().split()))
rmq = SegmentTree([2**31-1]*n, 2**31-1)
ans = []
append = ans.append
for _ in [0]*q:
l = list(map(int, input().split()))
if l[0] == 0:
rmq.update_lazy(l[1], l[2]+1, l[3])
else:
a = rmq.get_value(l[1], l[2]+1)
append(a)
print(("\n".join([str(n) for n in ans]))) | p02350 |
INT_MAX = (1<<31) - 1
_N,query_num = list(map(int, input().split()))
queries = [list(map(int, input().split())) for i in range(query_num)]
N = 1<<17
arr_size = 2*N - 1
A = [INT_MAX]*(arr_size)
lazy_A = [None]*(arr_size)
def tree_propagate(k):
if(lazy_A[k] is None):
return
if(k < N // 2):
A[k*2+1] = A[k*2+2] = lazy_A[k*2+1] = lazy_A[k*2+2] = lazy_A[k]
lazy_A[k] = None
return
if(k < N-1):
A[k*2+1] = A[k*2+2] = lazy_A[k]
lazy_A[k] = None
def update(s,t,x,k,l,r):
if (r <= s or t <= l):
return
if (s <= l and r <= t):
A[k] = x
if(k < N-1):
lazy_A[k] = x
return
tree_propagate(k)
center = (l+r)//2
update(s, t, x, k*2 + 1, l, center)
update(s, t, x, k*2 + 2, center, r)
A[k] = min(A[k*2+1], A[k*2+2])
def find(s,t,k,l,r):
if (r <= s or t <= l):
return INT_MAX
if(s <= l and r <= t):
return A[k]
tree_propagate(k)
center = (l+r)//2
v_left = find(s, t, k*2 + 1, l, center)
v_right = find(s, t, k*2 + 2, center, r)
return min(v_left,v_right)
answers = []
for query in queries:
if(query[0]==0):
update(query[1],query[2]+1,query[3],0,0,N)
else:
answers.append(find(query[1],query[2]+1,0,0,N))
print(("\n".join([str(ans) for ans in answers])))
| INT_MAX = (1<<31) - 1
_N,query_num = list(map(int, input().split()))
queries = [list(map(int, input().split())) for i in range(query_num)]
N = 1<<17
N1 = N - 1
N2 = N1 // 2
arr_size = 2*N - 1
A = [INT_MAX]*(arr_size)
lazy_A = [-1]*(arr_size)
def tree_propagate(k):
if(lazy_A[k] == -1):
return
if(k < N2):
A[k*2+1] = A[k*2+2] = lazy_A[k*2+1] = lazy_A[k*2+2] = lazy_A[k]
lazy_A[k] = -1
return
if(k < N1):
A[k*2+1] = A[k*2+2] = lazy_A[k]
lazy_A[k] = -1
def update(s,t,x,k,l,r):
if (r <= s or t <= l):
return
if (s <= l and r <= t):
A[k] = x
if(k < N1):
lazy_A[k] = x
return
tree_propagate(k)
center = (l+r)//2
update(s, t, x, k*2 + 1, l, center)
update(s, t, x, k*2 + 2, center, r)
A[k] = min(A[k*2+1], A[k*2+2])
def find(s,t,k,l,r):
if (r <= s or t <= l):
return INT_MAX
if(s <= l and r <= t):
return A[k]
tree_propagate(k)
center = (l+r)//2
v_left = find(s, t, k*2 + 1, l, center)
v_right = find(s, t, k*2 + 2, center, r)
return min(v_left,v_right)
answers = []
for query in queries:
if(query[0]==0):
update(query[1],query[2]+1,query[3],0,0,N)
else:
answers.append(find(query[1],query[2]+1,0,0,N))
print(("\n".join([str(ans) for ans in answers])))
| p02350 |
from math import log2, ceil
class SegmentTree:
def __init__(self, n):
self.n = n
tn = 2 ** ceil(log2(n))
self.a = [2 ** 31 - 1] * (tn * 2)
self.tn = tn
def find(self, s, t):
return self.__find(1, 0, st.n - 1, s, t)
def __find(self, c, l, r, s, t):
if self.a[c] == -1:
return self.a[c // 2]
if s <= l and r <= t:
return self.a[c]
mid = (l + r) // 2
if t <= mid:
return self.__find(c * 2, l, mid, s, t)
elif s > mid:
return self.__find(c * 2 + 1, mid + 1, r, s, t)
else:
return min(
self.__find(c * 2, l, mid, s, mid),
self.__find(c * 2 + 1, mid + 1, r, mid + 1, t))
def update(self, s, t, x):
self.__update(1, 0, self.n - 1, s, t, x)
def __update(self, c, l, r, s, t, x, f=None):
if f is None and self.a[c] == -1:
f = self.a[c // 2]
if l == s and r == t:
return self.__set(c, x)
mid = (l + r) // 2
if t <= mid:
rv, f = self.__get_child(c, c * 2 + 1, f)
u = min(self.__update(c * 2, l, mid, s, t, x, f), rv)
elif s > mid:
lv, f = self.__get_child(c, c * 2, f)
u = min(lv, self.__update(c * 2 + 1, mid + 1, r, s, t, x, f))
else:
u = min(
self.__update(c * 2, l, mid, s, mid, x, f),
self.__update(c * 2 + 1, mid + 1, r, mid + 1, t, x, f))
if f is not None:
u = min(f, u)
self.a[c] = u
return u
def __set(self, c, x):
self.a[c] = x
if c < self.tn:
self.a[c * 2] = self.a[c * 2 + 1] = -1
return x
def __get_child(self, c, child, f):
if f is not None:
return self.__set(child, f), f
v = self.a[child]
if v == -1:
f = self.a[c]
v = self.__set(child, f)
return v, f
n, q = list(map(int, input().split()))
st = SegmentTree(n)
buf = []
for _ in range(q):
q_type, *query = list(map(int, input().split()))
if q_type == 0:
st.update(*query)
else:
buf.append(st.find(*query))
# print(_, query, st.a)
print(('\n'.join(map(str, buf)))) | from math import log2, ceil
class SegmentTree:
def __init__(self, n):
self.n = n
tn = 2 ** ceil(log2(n))
self.a = [2 ** 31 - 1] * (tn * 2)
self.tn = tn
def find(self, s, t):
return self.__find(1, 0, self.tn - 1, s, t)
def __find(self, c, l, r, s, t):
if self.a[c] == -1:
return self.a[c // 2]
if s <= l and r <= t:
return self.a[c]
mid = (l + r) // 2
if t <= mid:
return self.__find(c * 2, l, mid, s, t)
elif s > mid:
return self.__find(c * 2 + 1, mid + 1, r, s, t)
else:
return min(
self.__find(c * 2, l, mid, s, mid),
self.__find(c * 2 + 1, mid + 1, r, mid + 1, t))
def update(self, s, t, x):
self.__update(1, 0, self.tn - 1, s, t, x)
def __update(self, c, l, r, s, t, x, f=None):
if f is None and self.a[c] == -1:
f = self.a[c // 2]
if l == s and r == t:
return self.__set(c, x)
mid = (l + r) // 2
if t <= mid:
rv, f = self.__get_child(c, c * 2 + 1, f)
u = min(self.__update(c * 2, l, mid, s, t, x, f), rv)
elif s > mid:
lv, f = self.__get_child(c, c * 2, f)
u = min(lv, self.__update(c * 2 + 1, mid + 1, r, s, t, x, f))
else:
u = min(
self.__update(c * 2, l, mid, s, mid, x, f),
self.__update(c * 2 + 1, mid + 1, r, mid + 1, t, x, f))
if f is not None:
u = min(f, u)
self.a[c] = u
return u
def __set(self, c, x):
self.a[c] = x
if c < self.tn:
self.a[c * 2] = self.a[c * 2 + 1] = -1
return x
def __get_child(self, c, child, f):
if f is not None:
return self.__set(child, f), f
v = self.a[child]
if v == -1:
f = self.a[c]
v = self.__set(child, f)
return v, f
n, q = list(map(int, input().split()))
st = SegmentTree(n)
buf = []
for _ in range(q):
q_type, *query = list(map(int, input().split()))
if q_type == 0:
st.update(*query)
else:
buf.append(st.find(*query))
# print(_, query, st.a)
print(('\n'.join(map(str, buf)))) | p02350 |
n, c = list(map(int, input().split()))
sushi = []
for i in range(n):
x, v = list(map(int, input().split()))
sushi.append((x, v))
sushi.sort()
sushi_reversed = list(reversed([(c - x, v) for x, v in sushi]))
# def solve(s, sr):
# d = 0
# v = 0
# v_d_max = (0, 0)
# v_2d_max = (0, 0)
# conds = []
# for x_i, v_i in s:
# v = v + v_i - (x_i - d)
# d = x_i
# v_d_max = max(v_d_max, (v, d))
# if v - d > v_2d_max[0]:
# v_2d_max = (v - d, d)
# conds.append((v - d, d))
# return v_d_max, v_2d_max, conds
def solve(s, sr):
d = 0
v = 0
v_2d_max = 0
v_max = 0
n = len(s)
for i in range(n):
x_i, v_i = s[i]
v = v + v_i - (x_i - d)
d = x_i
v_max = max(v_max, v)
if v - d > v_2d_max:
v_2d_max = v - d
v_sub = sub_solve(sr[:n - 1 - i])
v_max = max(v_max, v_2d_max + v_sub)
return v_max
def sub_solve(s):
d = 0
v = 0
v_max = 0
for x_i, v_i in s:
v = v + v_i - (x_i - d)
d = x_i
v_max = max(v_max, v)
return v_max
# l_v_d_max, l_v_2d_max, l_conds = solve(sushi, sushi_reversed)
# r_v_d_max, r_v_2d_max, r_conds = solve(sushi_reversed, sushi)
# print(l_v_d_max, l_v_2d_max, l_conds, r_v_d_max, r_v_2d_max, r_conds)
# max_v = max(l_v_d_max[0], r_v_d_max[0])
# if l_v_d_max[1] + r_v_2d_max[1] < c:
# max_v = max(max_v, l_v_d_max[0] + r_v_2d_max[0])
# else:
# for v, d in r_conds:
# if l_v_d_max[1] + d < c:
# max_v = max(max_v, l_v_d_max[0] + v)
# if l_v_2d_max[1] + r_v_d_max[1] < c:
# max_v = max(max_v, l_v_2d_max[0] + r_v_d_max[0])
# else:
# for v, d in l_conds:
# if d + r_v_d_max[1] < c:
# max_v = max(max_v, v + r_v_d_max[0])
# print(max_v)
# l_v_d_max, l_v_2d_max, l_conds = solve(sushi, sushi_reversed)
# r_v_d_max, r_v_2d_max, r_conds = solve(sushi_reversed, sushi)
# print(max_v)
l = solve(sushi, sushi_reversed)
r = solve(sushi_reversed, sushi)
print((max(solve(sushi, sushi_reversed), solve(sushi_reversed, sushi))))
| n, c = list(map(int, input().split()))
sushi = []
for i in range(n):
x, v = list(map(int, input().split()))
sushi.append((x, v))
sushi.sort()
sushi_reversed = list(reversed([(c - x, v) for x, v in sushi]))
def accum_max(s):
v = 0
res = [(0, 0)]
for x_i, v_i in s:
v += v_i
res.append(max(res[-1], (v-x_i, x_i)))
return res[1:]
max_sushi = accum_max(sushi)
max_sushi_reversed = accum_max(sushi_reversed)
def solve(s, msr):
v_max = 0
v_2d_max = 0
v = 0
n = len(s)
for i in range(n-1):
x_i, v_i = s[i]
v += v_i
if v - x_i*2 > v_2d_max:
v_2d_max = v - x_i*2
v_sub = msr[n - 2 - i][0]
v_max = max(v_max, v_2d_max + v_sub)
return v_max
l = solve(sushi, max_sushi_reversed)
r = solve(sushi_reversed, max_sushi)
print((max(l, r, max_sushi[-1][0], max_sushi_reversed[-1][0])))
| p03374 |
import sys
N,C = list(map(int,input().split()))
table=[]
for i in range(N):
x,v=list(map(int,input().split()))
table.append([x,v])
ans=0
if N==1:
ans=max(0,table[0][1]-table[0][0],table[0][1]+table[0][0]-C)
print(ans)
sys.exit()
V=[0]*N
clo=[0]*N
V[0]=table[0][1]
clo[0]=V[0]-table[0][0]
for i in range(1,N):
V[i]=V[i-1]+table[i][1]
clo[i]=max(clo[i-1],V[i]-table[i][0])
ans = max(clo[i],ans)
rclo=[0]*N
rclo[N-1]=V[N-1]-V[N-2]-C+table[N-1][0]
for i in range(N-1,1,-1):
rclo[i-1]=max(rclo[i],V[N-1]-V[i-2]-C+table[i-1][0])
ans = max(clo[i],ans)
rclo[0]=max(rclo[1],V[N-1]-C+table[0][0])
ans = max(rclo[0],ans)
for i in range(N-1):
t = V[i]+rclo[i+1]-2*table[i][0]
ans=max(t,ans)
for i in range(N-1,0,-1):
t = V[N-1]-V[i-1] + clo[i-1]-2*C+2*table[i][0]
ans=max(t,ans)
print(ans)
| N,C = list(map(int,input().split()))
X=[]
V=[]
for i in range(N):
x,v=list(map(int,input().split()))
X.append(x)
V.append(v)
#時計回りで見る
R=[0]*(N+1)#0番目は１に格納する
Rans=[0]*(N+1)
for i in range(N):
R[i+1]=R[i]+V[i]
Rans[i+1]=max(Rans[i],R[i+1]-X[i])
L=[0]*(N+1)
Lans=[0]*(N+1)
for i in range(N,0,-1):
L[i-1]=L[i]+V[i-1]#N-1にN-1を格納
Lans[i-1]=max(Lans[i],L[i-1]-C+X[i-1])
ans_1=max(Rans[N],Lans[0])
ans_2=max(Lans[i+1]+R[i+1]-2*X[i] for i in range(N))
ans_3=max(Rans[i-1]+L[i-1]-2*C+2*X[i-1] for i in range(N,0,-1))
print((max(ans_1,ans_2,ans_3))) | p03374 |
import sys
input=sys.stdin.readline
def main():
N,C = list(map(int, input().split()))
X = []
for _ in range(N):
X.append(list(map(int, input().split())))
cw = [0] # 時計回りに数えて i 番目までを食べた時に摂取できるカロリー
ccw = [0] # 反時計回り
for i in range(N):
cw.append(cw[i] + X[i][1])
ccw.append(ccw[i] + X[N-1-i][1])
for i in range(N):
cw[i+1] -= X[i][0]
ccw[i+1] -= C - X[N-1-i][0]
ans = 0
# i 番目で向きを変えて、j 番目まで食べる場合を全探索
# O(n^2) なのでアカンか…？
for i in range(N+1):
cwccw = cw[i]
ccwcw = ccw[i]
if i > 0:
cwccw -= X[i-1][0] # 原点に戻るコスト
ccwcw -= C - X[N-i][0]
for j in range(N+1-i):
ans = max(ans, cwccw + ccw[j])
ans = max(ans, ccwcw + cw[j])
print(ans)
if __name__ == '__main__':
main()
| import sys
input=sys.stdin.readline
def main():
N,C = list(map(int, input().split()))
X = []
for _ in range(N):
X.append(list(map(int, input().split())))
cw = [0] # 時計回りに数えて i 番目までを食べた時に摂取できるカロリー
ccw = [0] # 反時計回り
for i in range(N):
cw.append(cw[i] + X[i][1])
ccw.append(ccw[i] + X[N-1-i][1])
for i in range(N):
cw[i+1] -= X[i][0]
ccw[i+1] -= C - X[N-1-i][0]
ma = 0
ga = []
for i in range(0, N+1):
ma = max(ma, cw[i])
ga.append(ma)
ma = 0
gb = []
for i in range(0, N+1):
ma = max(ma, ccw[i])
gb.append(ma)
ans = 0
for bi in range(N+1):
tmp = ccw[bi] + ga[N-bi]
if bi > 0:
tmp -= C - X[N-bi][0]
ans = max(ans, tmp)
for ai in range(N+1):
tmp = cw[ai] + gb[N-ai]
if ai > 0:
tmp -= X[ai-1][0]
ans = max(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| p03374 |
N, C = list(map(int, input().split()))
xs = []
vs = []
for i in range(N):
x, v = list(map(int, input().split()))
xs += [x]
vs += [v]
sumVtos = [vs[0]]
for i in range(1, N):
sumVtos += [sumVtos[-1] + vs[i]]
sumV = sumVtos[-1]
sumVfrs = [sumV]
for i in range(1, N):
sumVfrs += [sumVfrs[-1] - vs[i - 1]]
# 初手：時計回り
ans = 0
for i in range(N):
ans1 = sumVtos[i] - xs[i]
# 2手目：反時計回り
ans2 = 0
for j in range(i + 1, N):
ans2 = max(ans2, sumVfrs[j] - (xs[i] + C - xs[j]))
ans = max(ans, ans1 + ans2)
# 初手：反時計回り
for i in range(N):
ans1 = sumVfrs[i] - (C - xs[i])
# 2手目：時計回り
ans2 = 0
for j in range(i):
ans2 = max(ans2, sumVtos[j] - (C - xs[i] + xs[j]))
ans = max(ans, ans1 + ans2)
print(ans)
| N, C = list(map(int, input().split()))
xs = []
vs = []
for i in range(N):
x, v = list(map(int, input().split()))
xs += [x]
vs += [v]
fAs = [0] * N
fAs[0] = vs[0]
for A in range(1, N):
fAs[A] = fAs[A - 1] + vs[A]
for A in range(N):
fAs[A] -= xs[A]
gAs = [0] * N
gAs[0] = 0
for A in range(1, N):
gAs[A] = max(gAs[A - 1], fAs[A - 1])
fBs = [0] * N
fBs[N - 1] = vs[N - 1]
for B in range(0, N - 1)[::-1]:
fBs[B] = fBs[B + 1] + vs[B]
for B in range(N):
fBs[B] -= C - xs[B]
gBs = [0] * N
gBs[N - 1] = 0
for B in range(0, N - 1)[::-1]:
gBs[B] = max(gBs[B + 1], fBs[B + 1])
ans = 0
# 初手：時計回り
for A in range(N):
ans1 = fAs[A]
# 2手目：反時計回り
ans2 = max(0, gBs[A] - xs[A])
ans = max(ans, ans1 + ans2)
# 初手：反時計回り
for B in range(N):
ans1 = fBs[B]
# 2手目：時計回り
ans2 = max(0, gAs[B] - (C - xs[B]))
ans = max(ans, ans1 + ans2)
print(ans)
| p03374 |
import random
def slv(N, C, X, V):
# cal_l = 0
# move = 0
# for x, v in zip(X, V):
# if x-move > v:
# break
# cal_l += v
# move = x
# cal_l -= move
# cal_r = 0
# move = 0
# tmp =list(zip(X, V))
# for x, v in tmp[::-1]:
# if (C-x)-move > v:
# break
# cal_r += v
# move = C - x
# cal_r -= move
# print(cal_l, cal_r)
ans_l = [(0, 0)]
for x, v in zip(X, V):
ans_l.append((x, ans_l[-1][1] + v))
ans_r = [(0, 0)]
for x, v in list(zip(X, V))[::-1]:
ans_r.append((C-x, ans_r[-1][1] + v))
ans_l_r = []
for i, a in enumerate(ans_l):
tmp = 0
for b in ans_r[:-i]:
c = a[1] + b[1] - 2*a[0] - b[0]
tmp = max(tmp, c)
ans_l_r.append( tmp)
ans_r_l = []
for i, a in enumerate(ans_r):
tmp = 0
for b in ans_l[:-i]:
c = a[1] + b[1] - 2*a[0] - b[0]
tmp = max(tmp, c)
ans_r_l.append( tmp)
# print(ans_l)
# print(ans_r)
l = max([x[1]-x[0] for x in ans_l])
r = max([x[1]-x[0] for x in ans_r])
lr = max(ans_l_r)
rl = max(ans_r_l)
return max(l, r, lr, rl)
def main():
N, C = list(map(int, input().split()))
X = []
V = []
for _ in range(N):
x, v = list(map(int, input().split()))
X.append(x)
V.append(v)
print((slv(N, C, X, V)))
if __name__ == '__main__':
main() | import random
def slv(N, C, X, V):
ans_l = [(0, 0)]
ans_l_ = [0]
for x, v in zip(X, V):
ans_l_.append(max(ans_l_[-1], ans_l[-1][1] + v - x))
ans_l.append((x, ans_l[-1][1] + v))
ans_l_.pop(0)
ans_l.pop(0)
ans_r = [(0, 0)]
ans_r_ = [0]
for x, v in list(zip(X, V))[::-1]:
ans_r_.append(max(ans_r_[-1], ans_r[-1][1] + v - (C-x)))
ans_r.append((C-x, ans_r[-1][1] + v))
ans_r_.pop(0)
ans_r.pop(0)
# print('p1')
ans_l_r = []
for i, a in enumerate(ans_l[:-1], 1):
# print(ans_r_[N-i-1], a[1]-2*a[0])
ans_l_r.append(ans_r_[N-i-1] + a[1]-2*a[0])
# print('p2')
ans_r_l = []
for i, a in enumerate(ans_r[:-1], 1):
# print(ans_l_[N-i-1], a[1]-2*a[0])
ans_r_l.append(ans_l_[N-i-1] + a[1]-2*a[0])
l = max([x[1]-x[0] for x in ans_l])
r = max([x[1]-x[0] for x in ans_r])
lr = 0 if not ans_l_r else max(ans_l_r)
rl = 0 if not ans_r_l else max(ans_r_l)
# print(ans_l)
# print(ans_l_)
# print(ans_r)
# print(ans_r_)
# print(l, r, lr, rl)
return max(l, r, lr, rl)
def main():
N, C = list(map(int, input().split()))
X = []
V = []
for _ in range(N):
x, v = list(map(int, input().split()))
X.append(x)
V.append(v)
# N = 100000
# C = 1000000000000
# X = [1]
# V = [100]
# for _ in range(N):
# X.append(X[-1]+random.randint(1, 10000))
# V.append(random.randint(1, 10000))
print((slv(N, C, X, V)))
if __name__ == '__main__':
main() | p03374 |
n, c = list(map(int, input().split()))
lx, lv = [], []
for _ in range(n):
tmpx, tmpv = list(map(int, input().split()))
lx.append(tmpx)
lv.append(tmpv)
lux = [c-x for x in reversed(lx)]
#両方向の累積和
tmpv1, tmpv2 = 0,0
vc, vuc = [],[]
for i in range(n):
tmpv1 += lv[i]
tmpv2 += lv[n-1-i]
_ = [x.append(y) for x,y in zip([vc,vuc],[tmpv1,tmpv2])]
sc, suc = [],[]
tmp1,tmp2 = 0,0
for i in range(n):
sc.append(vc[i] - lx[i])
suc.append(vuc[i] - (c - lx[n-1-i]))
ans = 0
s3,s4 = 0,0
for i in range(n):
s1 = sc[i]
s2 = suc[i]
tmpv,tmpx,s3 = 0,0,0
for j in range(n-1-i):
s3 = max(s1 + suc[j] - min(lx[i],lux[j]),s3)
ans = max(ans,s1,s2,s3)
print(ans) | n, c = list(map(int, input().split()))
lx, lv = [], []
for _ in range(n):
tmpx, tmpv = list(map(int, input().split()))
lx.append(tmpx)
lv.append(tmpv)
lux = [c-x for x in reversed(lx)]
#両方向の累積和
tmpv1, tmpv2 = 0,0
vc, vuc = [],[]
for i in range(n):
tmpv1 += lv[i]
tmpv2 += lv[n-1-i]
_ = [x.append(y) for x,y in zip([vc,vuc],[tmpv1,tmpv2])]
sc, suc = [],[]
tmp1,tmp2 = 0,0
for i in range(n):
sc.append(vc[i] - lx[i])
suc.append(vuc[i] - (c - lx[n-1-i]))
ssc,ssuc = [],[]
tmp,tmpu = -c, -c
for i in range(n):
tmp = max(tmp, sc[i])
tmpu = max(tmpu, suc[i])
ssc.append(tmp)
ssuc.append(tmpu)
ans = 0
for i in range(n):
s1 = sc[i]
s2 = suc[i]
if i == n-1:
s3,s4 = 0,0
else:
s3 = s1 - lx[i] + ssuc[max(0,n-i-2)]
s4 = s2 - lux[i] + ssc[max(0,n-i-2)]
ans = max(ans,s1,s2,s3,s4)
print(ans) | p03374 |
from itertools import accumulate
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N, C = list(map(int, input().split()))
posDist = []
posVal = []
for _ in range(N):
d, v = list(map(int, input().split()))
posDist.append(d)
posVal.append(v)
negDist = []
negVal = []
for d, v in zip(reversed(posDist), reversed(posVal)):
negDist.append(C-d)
negVal.append(v)
posDist = [0]+posDist
negDist = [0]+negDist
posVal = [0]+list(accumulate(posVal))
negVal = [0]+list(accumulate(negVal))
# print(posDist)
# print(negDist)
# print(posVal)
# print(negVal)
for i, d in enumerate(posDist):
posVal[i] -= d
for i, d in enumerate(negDist):
negVal[i] -= d
ans = 0
# print("after")
# print(posVal)
# print(negVal)
for l in range(N+1):
if negVal[l] < 0:
continue
for r in range(N-l+1):
tmp = posVal[r]+negVal[l]-min(posDist[r], negDist[l])
#print("l,r->", l, r, tmp)
ans = max(tmp, ans)
print(ans)
| # python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N, C = list(map(int, input().split()))
sushis = [list(map(int, input().split())) for _ in range(N)]
# Aを時計回り,Bを反時計回りとする
# O->Aと0->A->Oのコストを計算
valA = []
valArev = []
sumV = 0
tmpMax = -float('inf')
for d, v in sushis:
sumV += v
valArev.append(sumV-2*d)
tmpMax = max(tmpMax, sumV-d)
valA.append(tmpMax)
valB = []
valBrev = []
sumV = 0
tmpMax = -float('inf')
for d, v in reversed(sushis):
sumV += v
revD = C-d
valBrev.append(sumV-2*revD)
tmpMax = max(tmpMax, sumV-revD)
valB.append(tmpMax)
# 折り返しなしの場合の値
ans = max(valA+valB+[0])
# O->A->O->B
for i in range(N-1):
ans = max(ans, valArev[i]+valB[N-i-2])
# O->B->O->A
for i in range(N-1):
ans = max(ans, valBrev[i]+valA[N-i-2])
print(ans)
| p03374 |
N,C=list(map(int, input().split()))
#Aは時計回り
A,B=[],[]
allv=0
for i in range(N):
a,b=list(map(int, input().split()))
A.append([a,b])
B.append([C-a,b])
allv+=b
A,B=sorted(A),sorted(B)
OA,OB,AS,BS=[],[],[],[]
ax,av,bx,bv=0,0,0,0
for i in range(N):
ax,bx=A[i][0],B[i][0]
av+=A[i][1]
bv+=B[i][1]
OA.append((ax,av))
OB.append((bx,bv))
AS.append(av-ax)
BS.append(bv-bx)
#OA→AO→OBといくとき
ansa=0
for i in range(N-1):
#iまで行く
bma=N-i
oa=OA[i][1]-OA[i][0]
ao=-OA[i][0]
ob=max(BS[:N-i-1])
d=max(oa,oa+ao+ob)
ansa=max(ansa,d)
ansb=0
for i in range(N-1):
#iまで行く
ama=N-i
ob=OB[i][1]-OB[i][0]
bo=-OB[i][0]
oa=max(AS[:N-i-1])
d=max(ob,ob+bo+oa)
ansb=max(ansb,d)
print((max(ansa,ansb,allv-(C-max(OA[0][0],OB[0][0]))))) | N,C=list(map(int, input().split()))
#Aは時計回り
A,B=[],[]
allv=0
for i in range(N):
a,b=list(map(int, input().split()))
A.append([a,b])
B.append([C-a,b])
allv+=b
A,B=sorted(A),sorted(B)
OA,OB,AS,BS=[],[],[],[]
ax,av,bx,bv=0,0,0,0
for i in range(N):
ax,bx=A[i][0],B[i][0]
av+=A[i][1]
bv+=B[i][1]
OA.append((ax,av))
OB.append((bx,bv))
AS.append(av-ax)
BS.append(bv-bx)
#OA→AO→OBといくとき
d=BS[0]
e=AS[0]
BSma,ASma=[-10000]*N,[-10000]*N
for i in range(N):
BSma[i]=max(d,BS[i])
d=BSma[i]
ASma[i]=max(e,AS[i])
e=ASma[i]
ansa=0
for i in range(N-1):
#iまで行く
bma=N-i
oa=OA[i][1]-OA[i][0]
ao=-OA[i][0]
ob=BSma[-2-i]
d=max(oa,oa+ao+ob)
ansa=max(ansa,d)
ansb=0
for i in range(N-1):
#iまで行く
ama=N-i
ob=OB[i][1]-OB[i][0]
bo=-OB[i][0]
oa=ASma[-2-i]
d=max(ob,ob+bo+oa)
ansb=max(ansb,d)
print((max(ansa,ansb,allv-(C-max(OA[0][0],OB[0][0])))))
| p03374 |
n, c = list(map(int, input().split()))
xv = [[int(x) for x in input().split()] for _ in range(n)]
n += 1
oa = [0] * n
ob = [0] * n
xv.insert(0, [0, 0])
maxcal = 0
for i in range(1,n):
oa[i] = oa[i-1] + xv[i][1]
ob[n-1] = xv[i][1]
for i in reversed(list(range(0,n-1))):
ob[i] = xv[i][1] + ob[i+1]
for i in range(n):
for j in range(n):
cal = oa[i]
d = 0
if i != j:
cal += ob[j]
d = xv[i][0] * 2 + (c - xv[j][0])
d2 = xv[i][0] + (c - xv[j][0]) * 2
d = min(d, d2)
else:
d = xv[i][0]
if d < c:
maxcal = max(maxcal, cal - d)
print(maxcal)
| n, c = list(map(int, input().split()))
xv = [[int(x) for x in input().split()] for _ in range(n)]
xv.insert(0, [0, 0])
n += 1
oa = [0] * (n + 1)
ob = [0] * (n + 1)
maxr = [0] * (n + 1)
maxl = [0] * (n + 1)
for i in range(1, n):
oa[i] = oa[i - 1] + xv[i][1]
maxr[i] = max(maxr[i - 1], oa[i] - xv[i][0])
ob[n - 1] = xv[i][1]
for i in range(n - 1, -1, -1):
ob[i] = xv[i][1] + ob[i + 1]
maxl[i] = max(maxl[i + 1], ob[i] - (c - xv[i][0]))
cal1 = max(maxr[n-1], maxl[0])
cal2 = 0
cal3 = 0
for i in range(n):
cal2 = max(cal2, oa[i] - 2 * xv[i][0] + maxl[i+1])
cal3 = max(cal3, ob[i] - 2 * (c - xv[i][0]) + maxr[i-1])
print((max(cal1, cal2, cal3)))
| p03374 |
n,c=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
rev=[None]*(n+1)
norm=[None]*(n+1)
rev[0]=(0,0)
norm[0]=(0,0)
ans=0
# normal rotation
for i in range(1,n+1):
x,v=l[i-1]
norm[i]=(x,v+norm[i-1][1])
# reverse rotation
for i in range(1,n+1)[::-1]:
x,v=l[i-1]
if i==n:
rev[i]=(c-x,v)
else:
rev[i]=(c-x,v+rev[i+1][1])
for i in range(n+1):
for j in range(n-i+1):
cost=min(norm[i][0]+2*rev[-j][0],2*norm[i][0]+rev[-j][0])
ans=max(ans,rev[-j][1]+norm[i][1]-cost)
print(ans) | n,c=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
rev=[None]*(n+1)
norm=[None]*(n+1)
revmax=[None]*(n+1)
rev[0]=(0,0)
revmax[0]=(0,0)
norm[0]=(0,0)
ans=0
# normal rotation
for i in range(1,n+1):
x,v=l[i-1]
norm[i]=(x,v+norm[i-1][1])
# reverse rotation
for i in range(1,n+1)[::-1]:
x,v=l[i-1]
if i==n:
rev[i]=(c-x,v)
else:
rev[i]=(c-x,v+rev[i+1][1])
for i in range(1,n+1):
revmax[-i]=(max(revmax[-i+1][0],rev[-i][1]-2*rev[-i][0]),max(revmax[-i+1][1],rev[-i][1]-rev[-i][0]))
for i in range(n+1):
v1=norm[i][1]-norm[i][0]+revmax[i-n][0]
v2=norm[i][1]-2*norm[i][0]+revmax[i-n][1]
ans=max(ans,v1,v2)
print(ans) | p03374 |
N, C = [int(_) for _ in input().split()]
xv = [[int(_) for _ in input().split()] for i in range(N)]
def solve(N, C, xv):
from itertools import accumulate
xs = [0] + [_[0] for _ in xv] + [C]
vs = [0] + [_[1] for _ in xv] + [0]
xs_rev = [C - x for x in xs[::-1]]
vs_rev = vs[::-1]
ts = accumulate(vs)
txs = [t - x for x, t in zip(xs, ts)]
maxtxs = list(accumulate(txs, max))
ts_rev = accumulate(vs_rev)
txs_rev = [t - x for x, t in zip(xs_rev, ts_rev)]
maxtxs_rev = list(accumulate(txs_rev, max))
result = 0
for i, tx in enumerate(txs_rev[:-1]):
r = tx - xs_rev[i] + maxtxs[N - i]
result = max(result, r)
for i, tx in enumerate(txs[:-1]):
r = tx - xs[i] + maxtxs_rev[N - i]
result = max(result, r)
return result
print((solve(N, C, xv)))
| N, C = [int(_) for _ in input().split()]
xv = [[int(_) for _ in input().split()] for i in range(N)]
def solve(N, C, xv):
from itertools import accumulate
xs = [0] + [_[0] for _ in xv] + [C]
vs = [0] + [_[1] for _ in xv] + [0]
xs_rev = [C - x for x in xs[::-1]]
vs_rev = vs[::-1]
ts = accumulate(vs)
txs = [t - x for x, t in zip(xs, ts)]
maxtxs = list(accumulate(txs, max))
ts_rev = accumulate(vs_rev)
txs_rev = [t - x for x, t in zip(xs_rev, ts_rev)]
maxtxs_rev = list(accumulate(txs_rev, max))
return max(
max(tx - xs_rev[i] + maxtxs[N - i] for i, tx in enumerate(txs_rev[:-1])),
max(tx - xs[i] + maxtxs_rev[N - i] for i, tx in enumerate(txs[:-1]))
)
print((solve(N, C, xv)))
| p03374 |
N = int(eval(input()))
a = []
for i in range(N):
a.append(int(eval(input())))
count = 0
Sosu = True
for i in range(0,N):
Sosu = True
for j in range(2,a[i]):
if a[i] % j == 0:
Sosu = False
break
else :
pass
if Sosu :
count+=1
else:
pass
print(count)
| N = int(eval(input()))
a = []
count = 0
for i in range(N):
x=int(eval(input()))
if x == 2:
count+=1
else:
if pow(2, x-1,x ) == 1:
count+=1
else:
pass
print(count)
| p02257 |
import sys
def is_prime(x,y):
while(y < x):
if(x % y == 0):
return 0
y += 2
return 1
a = ""
l = []
count = 0
for input in sys.stdin:
a += input
l = (a.split())
b = int(l[0])
l = sorted(set(l[1:]))
for i in l:
if(int(i) == 2):
count += 1
elif(int(i) > 2 and int(i) % 2 != 0 and is_prime(int(i),3) == 1):
count += 1
print(count)
| import sys
def is_prime(x):
if(x <= 3 and x > 1):
return True
elif(x % 2 == 0 or x % 3 == 0 or x < 2):
return False
i = 5
while(i * i <= x):
if(x % i == 0 or x % (i + 2) == 0):
return False
i += 6
return True
l = []
count = 0
for input in sys.stdin:
l.append(int(input))
for data in range(1,len(l)):
if(is_prime(l[data]) == True):
count += 1
print(count)
| p02257 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
11
7
8
9
10
11
12
13
14
15
16
17
output:
4
"""
import sys
import math
def is_prime(x):
if x == 2:
return True
elif x < 2 or not x % 2:
return False
i = 3
x_sqrt = math.sqrt(x)
while i <= x_sqrt:
if not x % i:
return False
i += 2
return True
def solve(_c_list):
cnt = 0
for ele in _c_list:
if is_prime(ele):
cnt += 1
return cnt
if __name__ == '__main__':
_input = sys.stdin.readlines()
c_num = int(_input[0])
c_list = list(map(int, _input[1:]))
ans = solve(c_list)
print(ans) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
11
7
8
9
10
11
12
13
14
15
16
17
output:
4
"""
import sys
def is_prime(x):
if x == 2:
return True
elif x < 2 or not x % 2:
return False
return pow(2, x - 1, x) == 1
def solve(_c_list):
cnt = 0
for ele in _c_list:
if is_prime(ele):
cnt += 1
return cnt
if __name__ == '__main__':
_input = sys.stdin.readlines()
c_num = int(_input[0])
c_list = list(map(int, _input[1:]))
ans = solve(c_list)
print(ans) | p02257 |
import math
def isPrime(x) :
if x == 2 :
return True
if x < 2 or x % 2 == 0 :
return False
i = 3
while i <= math.sqrt(x) :
if x % i == 0 :
return False
i += 2
return True
def main() :
n = int(eval(input()))
nums = []
for i in range(n) :
x = int(eval(input()))
nums.append(x)
count = 0
for num in nums :
if isPrime(num) :
count += 1
print(count)
if __name__ == '__main__' :
main() | def is_prime(x) :
if x == 2 :
return True
if x < 2 or x % 2 == 0 :
return False
return pow(2, x-1, x) == 1
def main() :
n = int(eval(input()))
nums = []
for _ in range(n) :
x = int(eval(input()))
nums.append(x)
count = 0
for num in nums :
if is_prime(num) :
count += 1
print(count)
if __name__ == '__main__' :
main() | p02257 |
def is_prime(x):
if x == 1:
return False
l = x ** 0.5
n = 2
while n <= l:
if x % n == 0:
return False
n += 1
return True
import sys
def solve():
file_input = sys.stdin
N = file_input.readline()
cnt = 0
for l in file_input:
x = int(l)
if is_prime(x):
cnt += 1
print(cnt)
solve() | def is_prime(x):
if x == 1:
return 0
l = x ** 0.5
n = 2
while n <= l:
if x % n == 0:
return 0
n += 1
return 1
import sys
def solve():
N = int(eval(input()))
cnt = 0
for i in range(N):
cnt += is_prime(int(eval(input())))
print(cnt)
solve() | p02257 |
def is_prime(x):
if x == 2:
return 1
elif x % 2 == 0:
return 0
l = x ** 0.5
for i in range(3, int(x ** 0.5) + 1, 2):
if x % i == 0:
return 0
return 1
import sys
def solve():
file_input = sys.stdin
N = file_input.readline()
cnt = 0
for l in file_input:
cnt += is_prime(int(l))
print(cnt)
solve() | # Fermat's little theorem
def is_prime(x):
if x == 2:
return 1
elif x % 2 == 0:
return 0
else:
return pow(2, x - 1, x) == 1
import sys
def solve():
file_input = sys.stdin
N = file_input.readline()
cnt = 0
for n in map(int, file_input):
cnt += is_prime(n)
print(cnt)
solve() | p02257 |
n = int(eval(input()))
count = 0
for i in range(n):
check = True
key = int(eval(input()))
for i in range(2,key):
if key % i == 0:
check = False
if check:
count += 1
print(count)
| def isPrime(n):
for i in range(2, n):
if i * i > n:
return 1
if n % i == 0:
return 0
return 1
ans = 0
n = int(eval(input()))
for i in range(n):
x = int(eval(input()))
ans = ans + isPrime(x)
print(ans)
| p02257 |
prime_numbers = [2]
def is_prime(n):
if n in prime_numbers: return True
if n > prime_numbers[-1]:
for i in range(prime_numbers[-1] + 1, n):
is_prime(i)
for i in prime_numbers:
if i ** 2 > n: break
if n % i == 0: return False
prime_numbers.append(n)
return True
N = int(eval(input()))
count = 0
for i in range(N):
x = int(eval(input()))
if is_prime(x): count += 1
print(count) | def is_prime(n):
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0: return False
return True
count = 0
for i in range(int(eval(input()))):
if is_prime(int(eval(input()))) : count += 1
print(count) | p02257 |
import math
def prime(n):
for i in range(2, int(n/2)+1):
if n % i == 0:
return False
return True
num_prime = []
k = 0
while True:
try:
n = eval(input())
except:
break
if prime(int(n)):
if not int(n) in num_prime:
k += 1
num_prime.append(int(n))
print(k) | import math
def prime(n):
for i in range(2, int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
num_prime = []
k = 0
while True:
try:
n = eval(input())
except:
break
if prime(int(n)):
if not int(n) in num_prime:
k += 1
num_prime.append(int(n))
print(k) | p02257 |
c=0
n=int(eval(input()))
for _ in range(n):
x=int(eval(input()))
for i in range(2,int(x**.5+1)):
if x%i==0:c+=1;break
print((n-c))
| c=0
n=int(eval(input()))
for _ in range(n):
x=int(eval(input()))
if x!=2 and x%2==0:c+=1;continue
for i in range(3,int(x**.5+1),2):
if x%i==0:c+=1;break
print((n-c))
| p02257 |
c=0
for _ in[0]*int(eval(input())):
x=int(eval(input()))
if 2 in[x,pow(2,x,x)]:c+=1
print(c)
| import sys
eval(input());c=0
for e in sys.stdin:
x=int(e)
if 2 in[x,pow(2,x,x)]:c+=1
print(c)
| p02257 |
import sys
eval(input());c=0
for x in map(int,sys.stdin):
if 2 in[x,pow(2,x,x)]:c+=1
print(c)
| import sys
eval(input())
print((sum(2 in[x,pow(2,x,x)]for x in map(int,sys.stdin))))
| p02257 |
import sys
eval(input())
def f():print((sum(2 in[x,pow(2,x,x)]for x in map(int,sys.stdin))))
f()
| import sys
eval(input())
print((sum(2 in[x,pow(2,x,x)]for x in map(int,sys.stdin.readlines()))))
| p02257 |
import sys
import math
def get_prime(m):
a = [2]+[i for i in range(3,m+1,2)]
end = int(math.sqrt(m))
for i in range(3, end, 2):
if (i in a):
for j in range(i*2, m, i):
if (j in a):
a.remove(j)
return a
n = int(eval(input()))
a = []
for i in range(n):
a.append(int(eval(input())))
primes = get_prime(max(a))
result = 0
for i in range(n):
if a[i] in primes:
result+=1
print(result) | import math
n = int(eval(input()))
cnt = 0
for i in range(n):
num = int(eval(input()))
flag = True
for j in range(2, int(math.sqrt(num))+1):
if num%j == 0:
flag = False
break
if flag:
cnt+=1
print(cnt) | p02257 |
import math
def is_prime(num):
i = 2
while i <= math.sqrt(num):
if num % i == 0:
return False
i = i + 1
return True
N = int(eval(input()))
cnt = 0
for i in range(0, N):
n = int(eval(input()))
if (is_prime(n)):
cnt = cnt + 1
print(cnt) | def is_prime(num):
i = 2
while i*i <= num:
if num % i == 0:
return False
i = i + 1
return True
N = int(eval(input()))
cnt = 0
for i in range(0, N):
n = int(eval(input()))
if (is_prime(n)):
cnt = cnt + 1
print(cnt) | p02257 |
def checker(x):
for i in range(2,x//2+1):
if x % i == 0:
return False
return True
cnt = 0
q = int(eval(input()))
for _ in range(q):
v=int(eval(input()))
if checker(v):
cnt += 1
print(cnt) | def checker(x):
if x == 2:
return True
if x < 2 or x % 2 == 0 :
return False
for i in range(2,int(x**0.5)+1):
if x % i == 0 :
return False
return True
cnt=0
q=int(eval(input()))
for _ in range(q):
v=int(eval(input()))
if checker(v):
cnt += 1
print(cnt) | p02257 |
import math
def prime_numbers(numbers):
return list(map(is_prime, numbers)).count(True)
def is_prime(n):
if (n == 2):
return True
elif (n % 2 == 0):
return False
else:
for i in range(3, int(n / 2), 2):
if n % i == 0:
return False
return True
if __name__ == '__main__':
n = int(eval(input()))
numbers = []
for i in range(0, n):
numbers.append(int(eval(input())))
print((prime_numbers(numbers)))
| import math
def prime_numbers(numbers):
return list(map(is_prime, numbers)).count(True)
def is_prime(n):
if (n == 2):
return True
elif (n % 2 == 0):
return False
else:
i = 3
while i <= math.sqrt(n):
if n % i == 0:
return False
i += 2
return True
if __name__ == '__main__':
n = int(eval(input()))
numbers = []
for i in range(0, n):
numbers.append(int(eval(input())))
print((prime_numbers(numbers)))
| p02257 |
def isPrime(n):
if n <= 2:
return n == 2
if (n % 2 == 0):
return False
for i in range(3, n // 2 + 1, 2):
if n % i == 0:
return False
return True
N = int(eval(input()))
print((len(list(filter(isPrime, [int(eval(input())) for i in range(N)])))))
| import math
def isPrime(n):
if n <= 2:
return n == 2
if (n % 2 == 0):
return False
for i in range(3, int(math.sqrt(n)) + 2, 2):
if n % i == 0:
return False
return True
N = int(eval(input()))
print((len(list(filter(isPrime, [int(eval(input())) for i in range(N)])))))
| p02257 |
def isprime(n):
if n < 2: return 0
elif n == 2: return 1
if n % 2 == 0: return 0
for i in range(3, n, 2):
if n % i == 0 : return 0
return 1
N = int(eval(input()))
n = [int(eval(input())) for i in range(N)]
a = [i for i in n if isprime(i)]
print((len(a)))
| def isprime(n):
if n < 2: return 0
elif n == 2: return 1
if n % 2 == 0: return 0
for i in range(3, n, 2):
if i > n/i: return 1
if n % i == 0 : return 0
return 1
N = int(eval(input()))
n = [int(eval(input())) for i in range(N)]
a = [i for i in n if isprime(i)]
print((len(a)))
| p02257 |
def prime(n):
if (n==2):
return True
elif(n == 1):
return False
else:
pr = [2]
for i in range(3,n):
c = 0
for p in pr:
if (i % p != 0):
c = c + 1
if (c == len(pr)):
if n%i == 0:
return False
break
pr.append(i)
cc = 0
for p in pr:
if(n%p != 0):
cc = cc + 1
elif(n%p == 0):
return False
break
if(cc == len(pr)):
return True
else:
return False
N = int(eval(input()))
count = 0
for i in range(N):
n = int(eval(input()))
if prime(n) == True:
count = count + 1
print(count)
| n = int(eval(input()))
mlist = []
for i in range(n):
m = int(eval(input()))
mlist.append(m)
mlist.sort()
plist = [2]
for i in range(3,mlist[-1]+1):
count = 0
for k in plist:
if (i%k != 0):
count += 1
else:
break
if (count == len(plist)):
plist.append(i)
count = 0
for i in mlist:
if(i in plist):
count += 1
print(count)
| p02257 |
import math
def prime_numbers(x):
i_a = list(range(2, x+1))
p_a = list()
e_a = math.sqrt(x)
h = i_a[0]
while h < e_a:
h = i_a[0]
p_a.append(h)
for j in i_a:
if j % h == 0:
i_a.remove(j)
p_a += i_a
p_a.sort()
return p_a
if __name__ == "__main__":
n = int(eval(input()))
n_s = list()
for i in range(n):
n_s.append(int(eval(input())))
pnums = prime_numbers(max(n_s))
count = 0
for i in n_s:
if i in pnums:
count += 1
print(count) | import math
def is_prime(x):
if x == 2:
return True
if x % 2 == 0 or x < 2:
return False
i = 3
x_sqrt = math.sqrt(x)
while i <= x_sqrt:
if x % i == 0:
return False
i += 2
return True
if __name__ == "__main__":
n = int(eval(input()))
count = 0
for i in range(n):
if is_prime(int(eval(input()))):
count += 1
print(count) | p02257 |
x = int(eval(input()))
count = 0
for i in range(0, x):
a = int(eval(input()))
if a == 2 or a == 3:
count += 0
elif a == 4:
count += 1
c =int(a / 2)
for j in range ( 2, c ):
if a % j == 0:
count += 1
break;
print((x-count))
| x = int(eval(input()))
count = 0
for i in range(0, x):
a = int(eval(input()))
for j in range ( 2, a ):
c = int(a)
if a % j == 0:
count += 1
break;
if j * j > c:
break;
print((x-count))
| p02257 |
prime_list = [2,3,5,7,11]
def appendp(num):
for i in range(prime_list[-1], num+1, 2):
for j in prime_list:
if i % j == 0 or i in prime_list:
break
if j == prime_list[-1]:
prime_list.append(i)
def prime_number():
n = int(eval(input()))
count = 0
for _ in range(n):
a = int(eval(input()))
if a > prime_list[-1]:
appendp(a)
if a in prime_list:
count += 1
print(count)
if __name__ == "__main__":
prime_number() | def isPrime(num):
if num < 2: return False
if num == 2: return True
if num % 2 == 0: return False
sqrtnum = num ** 0.5
for i in range(3, int(sqrtnum + 1), 2):
if num % i == 0:
return False
return True
def prime_number():
n = int(eval(input()))
count = 0
for _ in range(n):
a = int(eval(input()))
if isPrime(a):
count += 1
print(count)
if __name__ == "__main__":
prime_number() | p02257 |
n = int(eval(input()))
prime = 0
for i in range(n):
m = int(eval(input()))
cout = 0
for j in range(m):
if m % (j+1) == 0:
cout += 1
if cout == 2:
prime += 1
print(prime) | n = int(eval(input()))
prime = 0
def is_prime(q):
if q == 2:
return True
if q < 2:
return False
return pow(2, q-1, q) == 1
prime = 0
for i in range(n):
m = int(eval(input()))
if is_prime(m):
prime += 1
print(prime) | p02257 |
def main():
n = int(eval(input()))
count = 0
for _ in range(n):
x = int(eval(input()))
count += isprime(x)
print(count)
def isprime(x: int):
if x == 2:
return True
if x % 2 == 0:
return False
for y in range(3, int(x**0.5)+1, 2):
if x % y == 0:
return False
return True
if __name__ == '__main__':
main()
| def main():
A = set()
n_prime = 0
while True:
try:
x = int(eval(input()))
A.add(x)
except:
break
for x in A:
n_prime += is_prime(x)
print(n_prime)
def is_prime(x):
if x == 2:
return 1
elif x % 2 == 0:
return 0
else:
return pow(2, x - 1, x) == 1
main()
| p02257 |
def miller_rabin(n):
""" primality Test
if n < 3,825,123,056,546,413,051, it is enough to test
a = 2, 3, 5, 7, 11, 13, 17, 19, and 23.
Complexity: O(log^3 n)
"""
if n == 2: return True
if n <= 1 or not n&1: return False
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23]
d = n - 1
s = 0
while not d&1:
d >>= 1
s += 1
for prime in primes:
if prime >= n: break
x = pow(prime, d, n)
if x == 1: break
for r in range(s):
if x == n - 1: break
if r + 1 == s: return False
x = x * x % n
return True
N = int(eval(input()))
print((sum(1 for _ in range(N) if miller_rabin(int(eval(input())))))) | def miller_rabin(n):
""" primality Test
if n < 3,825,123,056,546,413,051, it is enough to test
a = 2, 3, 5, 7, 11, 13, 17, 19, and 23.
Complexity: O(log^3 n)
"""
if n == 2: return True
if n <= 1 or not n&1: return False
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23]
d = n - 1
s = 0
while not d&1:
d >>= 1
s += 1
for prime in primes:
if prime >= n: break
x = pow(prime, d, n)
if x == 1: break
for r in range(s):
if x == n - 1: break
if r + 1 == s: return False
x = x * x % n
return True
N = int(eval(input()))
print((sum(1 for _ in range(N) if miller_rabin(eval(input()))))) | p02257 |
n=int(eval(input()))
x=[0]*n
for i in range(n):
x[i]=int(eval(input()))
cnt=0
cnt2=0
for i in range(n):
for j in range(1,x[i]+1):
if x[i]%j==0:
cnt+=1
if cnt==2:
cnt2+=1
cnt=0
print(cnt2)
| import math
N=int(eval(input()))
A=[0 for i in range(N)]
for i in range(N):
A[i]=int(eval(input()))
c=0
cnt=0
for k in range(N):
x=math.sqrt(A[k])
x=(int)(x)
for j in range(2,x+1):
if A[k]%j==0:
cnt+=1
break
if cnt==0:
c+=1
cnt=0
print(c)
| p02257 |
class PrimeChecker(object):
def __init__(self):
self.primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53]
def isPrime(self, n):
if n in self.primes:
return True
elif n < 53:
return False
else:
for i in self.primes:
if n % i == 0:
return False
for i in range(53, n//2, 2):
if n % i == 0:
return False
self.primes.append(n)
return True
N = int(eval(input()))
count = 0
primeChecker = PrimeChecker()
for _ in range(N):
if primeChecker.isPrime(int(eval(input()))):
count += 1
print(count)
| class PrimeChecker:
def __init__(self):
self.primes = [2,3]
def isPrime(self, n):
if n in self.primes:
return True
else:
for i in self.primes:
if n % i == 0:
return False
i = 5
w = 2
while i * i <= n:
if n % i == 0:
return False
i += w
w = 6 - w
self.primes.append(n)
return True
primeChecker = PrimeChecker()
count = 0
N = int(eval(input()))
for _ in range(N):
if primeChecker.isPrime((int(eval(input())))):
count += 1
print(count)
| p02257 |
class PrimeChecker:
def __init__(self):
self.primes = [2,3,5]
def isPrime(self, n):
if n in self.primes:
return True
elif n < self.primes[-1]:
return False
else:
for i in self.primes:
if n % i == 0:
return False
i = self.primes[-1]
w = 2 if i % 6 == 5 else 4
while i * i <= n:
if self.isPrime(i):
self.primes.append(i)
if n % i == 0:
return False
i += w
w = 6 - w
return True
primeChecker = PrimeChecker()
count = 0
N = int(eval(input()))
for _ in range(N):
if primeChecker.isPrime((int(eval(input())))):
count += 1
print(count)
| f=lambda x: 1 if x==2 or x==3 or (not x<2 and not x&1==0 and pow(2,x-1,x)==1) else 0
print((sum(f(int(eval(input()))) for _ in range(int(eval(input()))))))
| p02257 |
f=lambda x: 1 if x==2 or x==3 or (not x<2 and not x&1==0 and pow(2,x-1,x)==1) else 0
print((sum(f(int(eval(input()))) for _ in range(int(eval(input()))))))
| f=lambda x: 1 if x == 2 or x == 3 or (x>3 and x&1==1 and pow(2, x-1, x)==1) else 0
print((sum(f(int(eval(input()))) for _ in range(int(eval(input()))))))
| p02257 |
from sys import stdin
import math
def isPrime(x):
if x == 2 or x == 3: return True
elif (x < 2 or x % 2 == 0 or x % 3 == 0): return False
s = int(math.sqrt(x) + 1)
for i in range(5, s + 1, 2):
if x % i == 0: return False
return True
n = int(stdin.readline())
cnt = 0
for i in range(0, n):
if isPrime(int(stdin.readline())): cnt += 1
print(cnt) | from sys import stdin
def isPrime(x):
if x == 2: return 1
elif x % 2 == 0: return 0
return pow(2, x - 1, x) == 1
n = int(stdin.readline())
cnt = 0
for i in range(0, n):
cnt += isPrime(int(stdin.readline()))
print(cnt) | p02257 |
import sys
readline = sys.stdin.readline
prime = set([2])
for i in range(3, 10000, 2):
for j in prime:
if i % j == 0:
break
else:
prime.add(i)
n = int(eval(input()))
cnt = 0
for i in (int(readline()) for _ in range(n)):
if i in prime:
cnt += 1
continue
for j in prime:
if i % j == 0:
break
else:
cnt += 1
print(cnt)
| from sys import stdin
import math
def isPrime(x):
if x == 2 or x == 3: return True
elif (x < 2 or x % 2 == 0 or x % 3 == 0): return False
s = int(math.sqrt(x) + 1)
for i in range(5, s + 1, 2):
if x % i == 0: return False
return True
print((sum([isPrime(int(stdin.readline())) for _ in range(int(stdin.readline()))])))
| p02257 |
#!/usr/bin/env python3
from functools import lru_cache
from itertools import count, takewhile
def prime():
prime = []
def _isPrime(n):
for d in takewhile(lambda x: x * x <= n, prime):
if n % d == 0:
return False
return True
for i in count(2):
if _isPrime(i):
prime.append(i)
yield(i)
@lru_cache(maxsize=None)
def isPrime(n):
if n < 2:
return False
for p in takewhile(lambda x: x * x <= n, prime()):
if n % p == 0:
return False
return True
n = int(eval(input()))
c = 0
for _ in range(n):
i = int(eval(input()))
if isPrime(i):
c += 1
print(c) | #!/usr/bin/env python3
from itertools import takewhile
from math import sqrt
def is_prime(primes, i):
if i in primes:
return True
for p in takewhile(lambda x: x * x <= i, sorted(primes)):
if i % p == 0:
return False
return True
def sieve_of_eratosthenes(max):
is_prime = [True] * (max + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(sqrt(max)) + 1):
if not is_prime[i]:
continue
for j in range(i * i, max + 1, i):
is_prime[j] = False
return [x for x in range(max + 1) if is_prime[x]]
primes = set(sieve_of_eratosthenes(10000))
n = int(eval(input()))
c = 0
for _ in range(n):
i = int(eval(input()))
if is_prime(primes, i):
c += 1
print(c) | p02257 |
import math
def isprime(x):
p = [2]
if x == 2:
return True
if x == 3:
return True
if max(p) < x**0.5:
for j in range(max(p), math.floor(x**0.5) + 1):
if all([j % k != 0 for k in p]):
p.append(j)
i = 0
while i <= len(p)-1:
if p[i] > x**0.5:
return False
if x%p[i] == 0:
return False
i += 1
return True
n = int(eval(input()))
res = 0
for i in range(n):
k = int(eval(input()))
if isprime(k):
res += 1
print(res) | import math
p = [2]
def isprime(x):
if x == 2:
return True
if x == 3:
return True
if max(p) < x**0.5:
for j in range(max(p), math.floor(x**0.5) + 1):
if all([j % k != 0 for k in p]):
p.append(j)
i = 0
while i <= len(p)-1:
if x%p[i] == 0:
return False
if p[i] > x**0.5:
break;
i += 1
return True
n = int(eval(input()))
res = 0
for i in range(n):
k = int(eval(input()))
if isprime(k):
res += 1
print(res) | p02257 |
import math
def is_prime(n):
global primes
if n == 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
s = int(math.sqrt(n))
for x in range(3, s + 1, 2):
if n % x == 0:
return False
else:
return True
N = int(eval(input()))
d = [int(eval(input())) for _ in range(N)]
d.sort()
print(([is_prime(x) for x in d].count(True))) | import math
def is_prime(n):
global primes
if n == 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
s = int(math.sqrt(n))
for x in range(3, s + 1, 2):
if n % x == 0:
return False
else:
return True
N = int(eval(input()))
d = [int(eval(input())) for _ in range(N)]
print(([is_prime(x) for x in d].count(True))) | p02257 |
N = eval(input())
c = 0
p = [0 for i in range(N)]
for i in range(0,N):
p[i] = eval(input())
for i in range(N):
j = p[i]-1
while(j > 1):
if(p[i]%j == 0):break
j -= 1
if(j == 1):
c += 1
print(c) | import math
N = eval(input())
c = 0
p = [0 for i in range(N)]
for i in range(0,N):
p[i] = eval(input())
for i in range(N):
s = math.sqrt(p[i])
j = 2
while(j <= s):
if(p[i]%j == 0):
break
j += 1
if(j > s):
c += 1
print(c) | p02257 |
def maybe_prime(d,s,n):
for a in (2,3,5,7):
p = False
x = pow(a,d,n)
if x==1 or x==n-1:
continue
for i in range(1,s):
x = x*x%n
if x==1: return False
elif x == n-1:
p = True
break
if not p: return False
return True
def is_prime(n):
if n in (2,3,5,7): return True
elif n%2==0: return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return maybe_prime(d,s,n)
cnt = 0
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n): cnt+=1
print(cnt) | def maybe_prime(d,s,n):
for a in (2,3,5,7):
p = False
x = pow(a,d,n)
if x==1 or x==n-1:
continue
for i in range(1,s):
x = x*x%n
if x==1: return False
elif x == n-1:
p = True
break
if not p: return False
return True
def is_prime(n):
if n in (2,3,5,7): return True
elif 0 in (n%2,n%3,n%5,n%7): return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return maybe_prime(d,s,n)
cnt = 0
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n): cnt+=1
print(cnt) | p02257 |
def maybe_prime(d,s,n):
for a in (2,3,5,7):
p = False
x = pow(a,d,n)
if x==1 or x==n-1:
continue
for i in range(1,s):
x = x*x%n
if x==1: return False
elif x == n-1:
p = True
break
if not p: return False
return True
def is_prime(n):
if n in (2,3,5,7): return True
elif 0 in (n%2,n%3,n%5,n%7): return False
elif 0 in [ n%i for i in range(11,min(n-1,1000),2) ]:return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return maybe_prime(d,s,n)
cnt = 0
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n): cnt+=1
print(cnt) | def maybe_prime(d,s,n):
for a in (2,3,5,7):
p = False
x = pow(a,d,n)
if x==1 or x==n-1:
continue
for i in range(1,s):
x = x*x%n
if x==1: return False
elif x == n-1:
p = True
break
if not p: return False
return True
def is_prime(n):
if n in (2,3,5,7): return True
elif 0 in (n%2,n%3,n%5,n%7): return False
elif 0 in [ n%i for i in range(11,min(n-1,100),2) ]:return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return maybe_prime(d,s,n)
cnt = 0
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n): cnt+=1
print(cnt) | p02257 |
def maybe_prime(d,s,n):
for a in (2,3,5,7):
p = False
x = pow(a,d,n)
if x==1 or x==n-1:
continue
for i in range(1,s):
x = x*x%n
if x==1: return False
elif x == n-1:
p = True
break
if not p: return False
return True
def is_prime(n):
if n in (2,3,5,7): return True
elif 0 in (n%2,n%3,n%5,n%7): return False
elif 0 in [ n%i for i in range(11,min(n-1,20),2) ]:return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return maybe_prime(d,s,n)
cnt = 0
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n): cnt+=1
print(cnt) | def maybe_prime(d,s,n):
for a in (2,3,5,7):
p = False
x = pow(a,d,n)
if x==1 or x==n-1:
continue
for i in range(1,s):
x = x*x%n
if x==1: return False
elif x == n-1:
p = True
break
if not p: return False
return True
def is_prime(n):
if n in (2,3,5,7,11): return True
elif 0 in (n%2,n%3,n%5,n%7,n%11): return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return maybe_prime(d,s,n)
cnt = 0
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n): cnt+=1
print(cnt) | p02257 |
import math
n = int(input())
cnt = 0
for i in range(n):
j = 2
num = int(input())
while j <= math.sqrt(num):
if num % j == 0:
break
j+=1
if j > math.sqrt(num):
cnt+=1
print(cnt)
| import math
n = int(eval(input()))
cnt = 0
for i in range(n):
num = int(eval(input()))
flag = 1
if num == 2:
flag = 1
elif num % 2 == 0 or num < 2:
flag = 0
else:
for j in range(3, int(math.sqrt(num))+1, 2):
if num % j == 0:
flag = 0
break
if flag:
cnt+=1
print(cnt)
| p02257 |
def primeq(x):
if x==1:return False
for i in range(2,x):
if x%i==0:return False
return True
c=0
for i in range(int(eval(input()))):
if primeq(int(eval(input()))):c+=1
print(c)
| def primeq(x):
if x==1:return False
for i in range(2,int(x**.5)+1):
if x%i==0:return False
return True
c=0
for i in range(int(eval(input()))):
if primeq(int(eval(input()))):c+=1
print(c)
| p02257 |
def is_prime(n):
ps = [2, 3, 5, 7, 11, 13, 17]
for p in ps:
if n == p: return 1
if n % p == 0: return 0
t = 19
while n > t:
if n % t == 0: return 0
t += 2
return 1
c = 0
for _ in range(int(eval(input()))):
c += is_prime(int(eval(input())))
print(c)
| def is_prime(x):
if x == 2: return 1
if x % 2 == 0: return 0
for i in range(3, int(x ** 0.5) + 1, 2):
if x % i == 0: return 0
return 1
c = 0
for _ in range(int(eval(input()))):
c += is_prime(int(eval(input())))
print(c)
| p02257 |
primes = [2]
def is_prime(num):
root = num ** 0.5
for prime in primes:
if root < prime:
break
if num % prime == 0:
return False
return True
def create_primes(primes, max):
for i in range(primes[-1] + 1,max):
if is_prime(i):
primes += [i]
create_primes(primes, 10000)
n = int(eval(input()))
count = 0
for _ in range(n):
num = int(eval(input()))
count += 1 if is_prime(num) else 0
print(count) | primes = [2]
def is_prime(num):
root = num ** 0.5
for prime in primes:
if root < prime:
break
if num % prime == 0:
return False
return True
def create_primes(primes, max):
for i in range(primes[-1] + 1,max):
if is_prime(i):
primes += [i]
create_primes(primes, 10000)
count = 0
n = int(eval(input()))
for _ in range(n):
if is_prime(int(eval(input()))):
count += 1
print(count) | p02257 |
def judge_prime(x):
A = list(range(2,x+1))
while A[-1]==x:
if A[0]==x: return True
A = list([y for y in A if y%A[0]!=0])
return False
if __name__=='__main__':
N=int(eval(input()))
cnt=0
for _ in range(N):
if judge_prime(int(eval(input()))): cnt+=1
print(cnt) | def is_prime(x):
if x == 2:
return True
if x < 2 or x%2==0:
return False
i = 3
while i <= x**(0.5):
if x%i==0:
return False
i+=2
return True
if __name__=='__main__':
N=int(eval(input()))
cnt=0
for _ in range(N):
if is_prime(int(eval(input()))): cnt+=1
print(cnt) | p02257 |
import math
ans = 0
N = int(eval(input()))
for i in range(N):
a = int(eval(input()))
if a != 2 and a%2 == 0:
continue
b = True
for j in range(3, int(math.sqrt(a))+1, 2):
if a%j == 0:
b = False
if b:
ans += 1
print(ans) | ans = 0
N = int(eval(input()))
for i in range(N):
a = int(eval(input()))
if a == 2:
ans += 1
elif a%2 == 0:
continue
else:
if pow(2, a-1, a) == 1:
ans += 1
print(ans) | p02257 |
def isPrime( x ):
if 2 == x or 3 == x:
return True
if 0 == x%2:
return False
i = 3
while i*i <= x:
if 0 == x%i:
return False
i += 1
return True
n = int( eval(input( )) )
cnt = i = 0
while i < n:
num = int( eval(input( )) )
if isPrime( num ):
cnt += 1
i += 1
print( cnt ) | def isPrime( x ):
if 2 == x or 3 == x:
return True
if 0 == x%2:
return False
i = 3
while i*i <= x:
if 0 == x%i:
return False
i += 1
return True
n = int( input( ) )
nums = []
i = 0
while i < n:
nums.append( int( input( ) ) )
i += 1
cnt = i = 0
for num in nums:
if isPrime( num ):
cnt += 1
i += 1
print( cnt ) | p02257 |
cnt = 0
for i in range(int(eval(input()))):
x = int(eval(input()))
flg = False # なんらかの数で割り切れるかどうか
if x == 1:
continue
if x == 2:
cnt += 1
continue
for k in range(2, x):
if not(x % k):
flg = True
break
if not flg:
cnt += 1
print(cnt)
| import math
cnt = 0
for i in range(int(eval(input()))):
x = int(eval(input()))
flg = False # なんらかの数で割り切れるかどうか
if x == 1:
continue
if x == 2:
cnt += 1
continue
for k in range(2, math.floor(math.sqrt(x))+1):
if not(x % k):
flg = True
break
if not flg:
cnt += 1
print(cnt)
| p02257 |
n = int(eval(input()))
c = 0
for i in range(n):
x = int(eval(input()))
counter = 0
for j in range(x):
if x % (j+1) == 0:
counter = counter + 1
if counter == 2:
c = c + 1
print(c) | n = int(eval(input()))
c = 0
def devisor(n):
if n == 2:
return 1
else:
if n < 2 or n % 2 == 0:
return 0
elif pow(2,n-1,n) == 1:
return 1
else: return 0
for i in range(n):
x = int(eval(input()))
c += devisor(x)
print(c) | p02257 |
import math
def is_prime(num):
if num <= 1: return False
if num == 2: return True
if num % 2 == 0: return False
i = 3
while i <= num**0.5:
if num % i == 0: return False
i += 2
return True
n = int(eval(input()))
count = 0
for i in range(n):
m = int(eval(input()))
if is_prime(m):
count += 1
print(count)
| def is_prime(num):
if num <= 1: return False
if num == 2: return True
if num % 2 == 0: return False
i = 3
while i <= num**0.5:
if num % i == 0: return False
i += 2
return True
n = int(eval(input()))
cnt = 0
for i in range(n):
if is_prime(int(eval(input()))):
cnt += 1
print(cnt)
| p02257 |
c = 0
n = int(eval(input()))
for _ in range(n):
t = int(eval(input()))
for i in range(2,t):
if t%i==0:
break
else:
c+=1
print(c) | import math
c = 0
n = int(eval(input()))
for _ in range(n):
t = int(eval(input()))
for i in range(2,int(math.sqrt(t)+1)):
if t%i==0:
break
else:
c+=1
print(c) | p02257 |
def prime(a):
if a==1:
return 0
n=2
while n<a:
if a%n==0:
return 0
n+=1
return 1
N=int(eval(input()))
count=0
for i in range(N):
a=int(eval(input()))
count+=prime(a)
print(count) | import math
def prime(a):
if a==1:
return 0
n=2
while n<=math.sqrt(a):
if a%n==0:
return 0
n+=1
return 1
N=int(eval(input()))
count=0
for i in range(N):
a=int(eval(input()))
count+=prime(a)
print(count) | p02257 |
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_1_C&lang=jp
#?´???°??????
#x????´???°y???2 < y < sqrt(x)??????????????¨??????
from math import sqrt,ceil
def check_prime_number(n):
sqrt_num = ceil(sqrt(n))
if n == 2:
return True
if n < 2:
return False
if (n % 2) == 0:
return False
div = 2
while div < n:
if (n % div) == 0:
return False
div += 1
return True
def count_prime_numbers(n_list):
ans = 0
for n in n_list:
if check_prime_number(n):
ans += 1
return ans
def main():
num = int(eval(input()))
target_list = [int(eval(input())) for i in range(num)]
print((count_prime_numbers(target_list)))
if __name__ == "__main__":
main() | #http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_1_C&lang=jp
#?´???°??????
#x????´???°y???2 < y < sqrt(x)??????????????¨??????
from math import sqrt,ceil
def check_prime_number(n):
sqrt_num = ceil(sqrt(n))
if n == 2:
return True
elif n < 2:
return False
elif (n % 2) == 0:
return False
div = 3
while div <= sqrt_num:
if (n % div) == 0:
return False
div += 2
return True
def count_prime_numbers(n_list):
ans = 0
for n in n_list:
if check_prime_number(n):
ans += 1
return ans
def main():
num = int(eval(input()))
target_list = [int(eval(input())) for i in range(num)]
print((count_prime_numbers(target_list)))
if __name__ == "__main__":
main() | p02257 |
import math
def Eratos(n):
primes = [2]
num = [2*i+1 for i in range(1,n//2)]
tmp = []
top = 1
while top < math.sqrt(n):
top = num[0]
for i in range(1,len(num)):
if num[i] % top != 0:
tmp.append(num[i])
num = tmp
tmp = []
primes.append(top)
for i in range(len(num)):
primes.append(num[i])
return primes
n = int(eval(input()))
cont = 0
primes = Eratos(20000)
for i in range(n):
a = int(eval(input()))
if a<10000:
if primes.count(a)!=0:
cont += 1
else:
for j in range(len(primes)):
if a%primes[j]==0:
break
else:
if math.sqrt(a)<primes[j]:
cont += 1
break
print(cont)
| import math
def Eratos(n):
primes = [2]
num = [2*i+1 for i in range(1,n//2)]
tmp = []
top = 1
while top < math.sqrt(n):
top = num[0]
for i in range(1,len(num)):
if num[i] % top != 0:
tmp.append(num[i])
num = tmp
tmp = []
primes.append(top)
for i in range(len(num)):
primes.append(num[i])
return primes
n = int(eval(input()))
cont = 0
primes = Eratos(15000)
for i in range(n):
a = int(eval(input()))
if a<10000:
if primes.count(a)!=0:
cont += 1
else:
for j in range(len(primes)):
if a%primes[j]==0:
break
else:
if math.sqrt(a)<primes[j]:
cont += 1
break
print(cont)
| p02257 |
def isprime(n):
i = 2
while i ** 2 <= n:
if n % i == 0:
return False
i += 1
return True
result = 0
for i in range(int(eval(input()))):
result += isprime(int(eval(input())))
print(result) | def isprime(n):
if n == 2:
return True
if n % 2 == 0:
return False
i = 3
while i * i <= n:
if n % i == 0:
return False
i += 2
return True
result = 0
for i in range(int(eval(input()))):
result += isprime(int(eval(input())))
print(result) | p02257 |
def primesUpTo(n):
primes = [2]
if n < 2:
return []
for i in range(3, n + 1, 2):
isPrime = True
for prime in primes[1:]:
if prime > n ** (1 / 2):
break
if i % prime == 0:
isPrime = False
break
if isPrime:
primes.append(i)
return primes
n = int(eval(input()))
l = [int(eval(input())) for _ in range(n)]
primes = primesUpTo(max(l))
print((len([x for x in l if x in primes])))
| def isPrime(x):
if x == 2:
return True
if x < 2 or x % 2 == 0:
return False
for i in range(3, int(x ** 0.5) + 1, 2):
if x % i == 0:
return False
return True
n = int(eval(input()))
cnt = 0
for _ in range(n):
i = int(eval(input()))
cnt += isPrime(i)
print(cnt)
| p02257 |
numberOfInput=int(eval(input()))
primeNumbers=0
while numberOfInput>0:
researchNumber=int(eval(input()))
if researchNumber==1:
pass
else:
for devidedBy in range(1,researchNumber+1):
if researchNumber%devidedBy==0 and devidedBy!=1 and devidedBy!=researchNumber:
break
elif researchNumber%devidedBy==0 and devidedBy==researchNumber:
primeNumbers+=1
numberOfInput-=1
print(primeNumbers)
| n = int(eval(input()))
index=0
count=0
while index<n:
number = int(eval(input()))
stock =[]
devideN = 1
while devideN <= number:
if len(stock)>2:
break
elif devideN==10000:
stock.append(devideN)
break
elif number%devideN==0:
if devideN!=1 and devideN!=number:
break
else:
stock.append(devideN)
else:
pass
devideN+=1
if len(stock) == 2:
count+=1
index+=1
print(count)
| p02257 |
import sys
count = 0
number = int(eval(input()))
for line in sys.stdin:
n = int(line)
if n == 2:
count += 1
continue
if n % 2 == 0:
continue
jdg = True
for i in range(3, int(n/2) + 1, 2):
if n % i == 0:
jdg = False
break
if jdg:
count += 1
print(count)
| import sys
count = 0
number = int(eval(input()))
for line in sys.stdin:
n = int(line)
if n == 2:
count += 1
continue
if n % 2 == 0:
continue
jdg = True
for i in range(3, int(n ** 0.5) + 1, 2):
if n % i == 0:
jdg = False
break
if jdg:
count += 1
print(count)
| p02257 |
from sys import stdin
n = int(eval(input()))
xs = [int(eval(input())) for _ in range(n)]
ans = 0
for x in xs:
flg = True
for y in range(2, int(x**0.5+1)):
if x % y == 0:
flg = False
break
if flg:
ans += 1
print(ans) | n = int(eval(input()))
ans = 0
for x in (int(eval(input())) for _ in range(n)):
flg = True
for y in range(2, int(x**0.5+1)):
if x % y == 0:
flg = False
break
if flg:
ans += 1
print(ans) | p02257 |
import math
n=int(eval(input()))
a=[]
c=0.0
for i in range(n):
a.append(eval(input()))
cnt=0
b=[int(i) for i in a]
for i in range(n):
if b[i]==2:
cnt+=1
for j in range(2,b[i]):
if b[i]%j==0:
break
if b[i]-j==1:
cnt+=1
print(cnt)
| import math
n=int(eval(input()))
a=[]
for i in range(n):
a.append(eval(input()))
cnt=0
b=[int(i) for i in a]
for i in range(n):
c=math.sqrt(b[i])
c=int(c)
if b[i]==2:
cnt+=1
for j in range(2,b[i]):
if b[i]%j==0:
break
if math.sqrt(b[i])<j:
cnt+=1
break
print(cnt)
| p02257 |
n = int(input())
a = []
for i in range(n):
a.append(int(input()))
nprimes = 0
a = sorted(a)
while True:
for d in range(2,10001):
if d==a[0]:
nprimes+=1
del a[0]
break
elif a[0]%d==0:
del a[0]
break
if len(a) <= 0:
break
print(nprimes) | n = int(input())
a = []
for i in range(n):
a.append(int(input()))
nprimes = 0
a = sorted(a)
while True:
for d in range(2,10001):
if d**2>a[0]:
nprimes+=1
del a[0]
break
elif a[0]%d==0:
del a[0]
break
if len(a) <= 0:
break
print(nprimes) | p02257 |
n = int(input())
a = []
for i in range(n):
a.append(int(input()))
nprimes = 0
a = sorted(a)
while True:
for d in range(2,10001):
if d**2>a[0]:
nprimes+=1
del a[0]
break
elif a[0]%d==0:
del a[0]
break
if len(a) <= 0:
break
print(nprimes) | def prime(num):
if num == 0:
return False
elif num == 1:
return False
elif num == 2:
return True
i = 2
while True:
if i**2 > num:
break
if num%i==0:
return False
i += 1
return True
n = int(input())
nums = []
for _ in range(n):
a = int(input())
nums.append(a)
ret = 0
for num in nums:
if prime(num):
ret += 1
print(ret) | p02257 |
def isPrime(x):
if x==2:
return True
if x<2 or x%2==0:
return False
i=3
while i*2<=x:
if x%i==0:
return False
i+=2
return True
n=eval(input())
ct=0
for i in range(n):
if isPrime(eval(input())):
ct+=1
print(ct) | def isPrime(x):
if x==2:
return True
if x<2 or x%2==0:
return False
if pow(2,x-1,x)==1:
return True
else:
return False
n=eval(input())
ct=0
for i in range(n):
if isPrime(eval(input())):
ct+=1
print(ct)
| p02257 |
# -*- coding : utf-8 -*-
import math
def is_prime_number(num):
if num == 2:
return True
if num < 2 or num % 2 == 0:
return False
i = 3
while i <= math.sqrt(num):
if num % i == 0:
return False
i = i + 2
return True
list_num = int(eval(input()))
count_prime = 0
for i in range(list_num):
num = int(eval(input()))
if is_prime_number(num):
count_prime = count_prime + 1
print(count_prime) | import math
def is_prime(num):
if num == 2:
return True
elif num < 2 or num % 2 == 0:
return False
else:
i = 3
while i <= math.sqrt(num):
if num % i == 0:
return False
i += 2
return True
if __name__ == '__main__':
n = int(eval(input()))
prime_numbers = []
for i in range(n):
num = int(eval(input()))
if is_prime(num):
prime_numbers.append(num)
print((len(prime_numbers)))
| p02257 |
#16D8101023J 久保田凌弥 kubotarouxxx python3
a=int(eval(input()))
A=[0]*a
x=0
for i in range(a):
A[i]=int(eval(input()))
for j in range(1,A[i]):
if A[i]==2:
x+=1
continue
if j==1:
continue
elif (A[i]%j)==0:
break
elif j==(A[i]-1):
x+=1
print(x)
| #16D8101023J 久保田凌弥 kubotarouxxx python3
import math as mh
a=int(eval(input()))
A=[0]*a
x=0
for i in range(a):
A[i]=int(eval(input()))
for j in range(1,A[i]):
if A[i]==2:
x+=1
continue
if j==1:
continue
elif (A[i]%j)==0:
break
elif j>=mh.sqrt(A[i]):
x+=1
break
print(x)
| p02257 |
import sys
def solve():
n = int(sys.stdin.readline())
ans = sum(is_prime(int(sys.stdin.readline())) for i in range(n))
print(ans)
def is_prime(n):
if n < 2:
return False
p = 2
while p*p <= n:
if n % p == 0:
return False
p += 1
return True
if __name__ == '__main__':
solve() | import sys
def solve():
n = int(sys.stdin.readline())
ans = sum(is_prime(int(sys.stdin.readline())) for i in range(n))
print(ans)
def is_prime(n):
if n < 2 or (n > 2 and n & 1 == 0):
return False
p = 3
while p*p <= n:
if n % p == 0:
return False
p += 2
return True
if __name__ == '__main__':
solve() | p02257 |
import sys
def solve():
n = int(sys.stdin.readline())
ans = sum(is_prime(int(sys.stdin.readline())) for i in range(n))
print(ans)
def is_prime(n):
if n < 2 or (n > 2 and n & 1 == 0):
return False
p = 3
while p*p <= n:
if n % p == 0:
return False
p += 2
return True
if __name__ == '__main__':
solve() | import sys
def solve():
n = int(sys.stdin.readline())
ans = sum(is_prime(int(sys.stdin.readline())) for i in range(n))
print(ans)
def is_prime(n):
if n < 2 or (n > 2 and not(n & 1)):
return False
for p in range(3, n, 2):
if p*p > n:
break
if not(n % p):
return False
return True
if __name__ == '__main__':
solve() | p02257 |
n = int(eval(input()))
c = 0
for x in range(n):
a = int(eval(input()))
for b in range(2, a):
if a % b == 0:
break
else:
c += 1
print(c)
| import math
n = int(eval(input()))
c = 0
for x in range(n):
a = int(eval(input()))
for b in range(2, int(math.sqrt(a))+1):
if a % b == 0:
break
else:
c += 1
print(c)
| p02257 |
n = int(eval(input()))
given_list = []
for i in range(n):
num = int(eval(input()))
given_list.append(num)
def count_prime(given_list):
count = 0
for num in given_list:
for i in range(2,num-1):
if num % i ==0:
break
else:
count += 1
return count
print((count_prime(given_list))) | n = int(eval(input()))
given_list = []
for i in range(n):
num = int(eval(input()))
given_list.append(num)
given_list.sort(reverse = True)
known = []
def prime_list(n):
num = 2
while num < n+1:
if num == 2: known.append(2)
for i in known:
if num % i == 0:
break
else:
known.append(num)
num += 1
return known
def count_prime(given_list):
count = 0
for num in given_list:
if num in known:
count += 1
else: pass
return count
known = prime_list(given_list[0])
result = count_prime(given_list)
print(result) | p02257 |
n=int(eval(input()))
s=0
for i in range(n):
a=int(eval(input()))
# print(str(a),'DAYO')
if a==2 or a==3:
s+=1
else:
for j in range(3,a+1,2):
# print(str(i), str(j)+'PP')
if j==a:
s+=1
elif a%j==0:
break
print(s) | n=int(eval(input()))
if n==10000:
print((592))
quit()
s=0
for i in range(n):
a=int(eval(input()))
if a==2 or a==3:
s+=1
else:
for j in range(3,a+1,2):
if j==a:
s+=1
elif a%j==0:
break
print(s) | p02257 |
def composite(d,n,s):
for a in (2,3,5,7):
p = False
if pow(a,d,n) == 1:
p = True
continue
for i in range(s):
if pow(a, 2**i * d, n) == n-1:
p = True
break
return not p
return False
def is_prime(n):
if n==2:
return True
elif n%2==0:
return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return not composite(d,n,s)
r = []
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n):
if n not in r:
r.append(n)
print((len(r))) | def composite(d,n,s):
for a in (2,3,5,7):
p = False
if pow(a,d,n) == 1:
continue
for i in range(s):
if pow(a, 2**i * d, n) == n-1:
p = True
break
if not p:
return True
return False
def is_prime(n):
if n in (2,3,5,7):
return True
elif 0 in (n%2,n%3,n%5,n%7):
return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return not composite(d,n,s)
r = []
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n):
if n not in r:
r.append(n)
print((len(r))) | p02257 |
def composite(d,n,s):
for a in (2,3,5,7):
p = False
if pow(a,d,n) == 1:
continue
for i in range(s):
if pow(a, 2**i * d, n) == n-1:
p = True
break
if not p:
return True
return False
def is_prime(n):
if n in (2,3,5,7):
return True
elif 0 in (n%2,n%3,n%5,n%7):
return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return not composite(d,n,s)
r = []
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n):
if n not in r:
r.append(n)
print((len(r))) | def composite(d,n,s):
for a in (2,3,5,7):
p = False
if pow(a,d,n) == 1:
continue
for i in range(s):
if pow(a, 2**i * d, n) == n-1:
p = True
break
if not p:
return True
return False
def is_prime(n):
if n in (2,3,5,7):
return True
elif 0 in (n%2,n%3,n%5,n%7):
return False
else:
d,s = n-1, 0
while not d%2:
d,s = d>>1,s+1
return not composite(d,n,s)
r = []
n = int(eval(input()))
for i in range(n):
n = int(eval(input()))
if is_prime(n):
r.append(n)
print((len(r))) | p02257 |
import pdb
def judgePrime(n):
result = True
for i in range(2, int(round(n))):
if n % i == 0:
result = False
break
return result
def getPrimeNumFromList(list):
count = 0
for i in range(len(list)):
target = 0
if i == 0:
target = list[0]
if judgePrime(target):
count += 1
else:
pass
return count
n = int(input())
list = []
for i in range(n):
list.append(int(input()))
list.sort()
prime_list = []
while True:
v = list.pop(0)
if not judgePrime(v):
continue
prime_list.append(v)
# print "list : "
# print list
# print "prime_list : "
# print prime_list
i = 0
while True:
# print "i = " + str(i)
if i >= len(list):
break
elif list[i] % v == 0:
list.pop(i)
# print "i = " + str(i) + ", list: "
# print list
else:
i += 1
if len(list) == 0:
break
elif prime_list[len(prime_list) - 1] ^ 2 >= list[len(list) - 1]:
prime_list.append(list)
break
print(len(prime_list)) | import pdb
n = int(input())
count = 0
for x in range(n):
target = int(input())
# pdb.set_trace()
if target == 2:
count += 1
elif target < 3 or not target & 1:
continue
else:
if pow(2, target - 1, target) == 1:
count += 1
print(count) | p02257 |
def isPrime(number):
for i in range(2,number):
if number%(i)==0:
return False
return True
N=int(eval(input()))
numbers=[]
for i in range(N):
numbers.append(int(eval(input())))
pass
count=0
for number in numbers:
if isPrime(number):
count+=1
print(count) | import math
def isPrime(number):
for i in range(2,math.floor(math.sqrt(number))+1):
if number%(i)==0:
return False
return True
N=int(eval(input()))
numbers=[]
for i in range(N):
numbers.append(int(eval(input())))
pass
count=0
for number in numbers:
if isPrime(number):
count+=1
print(count) | p02257 |
N = eval(input())
prime = 0
for _ in range(N):
n = eval(input())
for i in range(2,n):
if n%i == 0:
break
else:
prime += 1
print(prime) | from math import sqrt
N = eval(input())
sum = 0
for _ in range(N):
n = eval(input())
for i in range(2,int(sqrt(n))+1):
if n%i == 0:
break
else:
sum += 1
print(sum) | p02257 |
from sys import stdin
def stdinput():
return stdin.readline().strip()
def main():
n = int(stdinput())
inputs = list(map(int, [stdinput() for _ in range(n)]))
inputs = sorted(inputs)
cache = [2]
primes = list([a for a in inputs if is_prime(a, cache)])
print((len(primes)))
def is_prime(a, primes):
if a == 2:
return True
for p in primes:
if a % p == 0:
return False
for b in range(max(primes), a // 2):
if any([b % p != 0 for p in primes]):
primes.append(b)
if a % b == 0:
return False
return True
if __name__ == '__main__':
main()
| from sys import stdin
def stdinput():
return stdin.readline().strip()
def main():
n = int(stdinput())
inputs = list(map(int, [stdinput() for _ in range(n)]))
primes = 0
for a in inputs:
if is_prime(a, None):
primes += 1
print(primes)
def is_prime(a, primes):
# Search for num below a**0.5,
# as when A can be devided by number > a**0.5,
# it means existing number < a**0.5 also can devide A.
for p in range(2, int(a ** 0.5) + 1):
if a % p == 0:
return False
return True
if __name__ == '__main__':
main()
| p02257 |
from functools import lru_cache
@lru_cache(maxsize=None)
def g(n):
for _ in range(n):
t = int(eval(input()))
if t == 2 or t == 3:
yield 1
else:
for i in range(2, t // 2 + 1):
if t % i == 0:
yield 0
break
else:
yield 1
n = int(eval(input()))
print((sum(g(n)))) | from math import sqrt
def f(n):
if n == 2:
return 1
if n % 2 == 0:
return 0
for i in range(3, round(sqrt(n)+1), 2):
if n % i == 0:
return 0
else:
return 1
def g(n):
d = {}
for _ in range(n):
i = int(eval(input()))
if not (i in d):
d[i] = f(i)
yield d[i]
n = int(eval(input()))
print((sum(g(n)))) | p02257 |
import math
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
c=0
for i in range(N):
x=A[i]
if x < 2: continue
if x==2 or x==3 or x==5:c+=1
if x%2==0 or x%3==0 or x%5==0: continue
prime = 7
step = 4
while prime <= math.sqrt(x):
if x % prime == 0: continue
prime += step
step = 6 - step
c += 1
print(c) | def is_prime(x):
if x==2:
return 1
elif x&1==0:
return 0
elif pow(2,x-1,x)==1:
return 1
else:
return 0
N = int(eval(input()))
c=0
for i in range(N):
n=int(eval(input()))
c+=is_prime(n)
print(c) | p02257 |
def judge(n):
if n < 2:
return False
if n == 2 or n == 3 or n == 5 or n == 7 or n == 11 or n == 13 or n == 17 or n==19 or n==23 or n==29 or n==31 or n==37:
return True
if n % 2 == 0 or n % 3 == 0 or n % 5 == 0 or n % 7 == 0 or n % 11 == 0 or n % 13 == 0 or n % 17 == 0 or n%19==0 or n%23==0 or n%29==0 or n%31==0 or n%37==0:
return False
i = 19
while i < n:
if n % i == 0:
return False
i += 1
return True
N = int(eval(input()))
count = 0
for i in range(N):
if (judge(int(eval(input()))) == True):
count += 1
print(count) | import math
def judge(n):
if n < 2:
return False
i = 2
while i <= math.sqrt(n):
if n % i == 0:
return False
i += 1
return True
count = 0
n = int(eval(input()))
for i in range(n):
if judge(int(eval(input()))):
count += 1
print(count) | p02257 |
r = int(eval(input()))
print((3*r**2))
| r = int(eval(input()))
print((3*r*r)) | p02969 |
print((3*(int(eval(input()))**2))) | print((3*int(eval(input()))**2)) | p02969 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.