problem_id
stringlengths 6
6
| buggy_code
stringlengths 8
526k
| fixed_code
stringlengths 12
526k
| labels
listlengths 0
15
⌀ | buggy_submission_id
int64 1
1.54M
| fixed_submission_id
int64 2
1.54M
| user_id
stringlengths 10
10
| language
stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p02795
|
h=int(input())
w=int(input())
n=int(input())
b=max(h,w)
print(b)
num=0
a=0
while a<n:
num+=1
a+=b
print(num)
|
h=int(input())
w=int(input())
n=int(input())
b=max(h,w)
num=0
a=0
while a<n:
num+=1
a+=b
print(num)
|
[
"call.remove"
] | 600,698
| 600,699
|
u343977188
|
python
|
p02795
|
import math
h = int(input())
w = int(input())
n = int(input())
print(math.ceil(n)//max(h, w))
|
import math
h = int(input())
w = int(input())
n = int(input())
print(math.ceil(n/max(h, w)))
|
[
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 600,729
| 600,730
|
u693933222
|
python
|
p02795
|
import math
h= int(input())
w= int(input())
n = int(input())
print(math.ceil(n//max(h,w)))
|
import math
h= int(input())
w= int(input())
n = int(input())
print(math.ceil(n/max(h,w)))
|
[
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 600,735
| 600,736
|
u204842730
|
python
|
p02795
|
H = int(input())
W = int(input())
N = int(input())
A = max(H,W)
print((N-1)%A+1)
|
H = int(input())
W = int(input())
N = int(input())
A = max(H,W)
print((N-1)//A+1)
|
[
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 600,737
| 600,738
|
u513900925
|
python
|
p02795
|
H = int(input())
W = int(input())
N = int(input())
print((N+1) // max(H,W))
|
H = int(input())
W = int(input())
N = int(input())
print((N-1) // max(H,W) + 1)
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 600,741
| 600,742
|
u942033906
|
python
|
p02795
|
import math
h = int(input())
w = int(input())
n= int(input())
print(math.ceil(n // max(h, w)))
|
import math
h = int(input())
w = int(input())
n= int(input())
print(math.ceil(n / max(h, w)))
|
[
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 600,747
| 600,748
|
u081193942
|
python
|
p02788
|
from math import ceil
from collections import deque
N,D,A = map(int,input().split())
monsters = sorted([list(map(int,input().split())) for _ in range(N)])
q = deque([])
s = 0
ans = 0
for i in range(N):
print(q)
while len(q) > 0 and q[0][0] < monsters[i][0]:
s -= q[0][1]
q.popleft()
h = monsters[i][1] - s * A
if h > 0:
num_bombs = ceil(h / A)
q.append((monsters[i][0] + 2 * D, num_bombs))
s += num_bombs
ans += num_bombs
print(ans)
|
from math import ceil
from collections import deque
N,D,A = map(int,input().split())
monsters = sorted([list(map(int,input().split())) for _ in range(N)])
q = deque([])
s = 0
ans = 0
for i in range(N):
while len(q) > 0 and q[0][0] < monsters[i][0]:
s -= q[0][1]
q.popleft()
h = monsters[i][1] - s * A
if h > 0:
num_bombs = ceil(h / A)
q.append((monsters[i][0] + 2 * D, num_bombs))
s += num_bombs
ans += num_bombs
print(ans)
|
[
"call.remove"
] | 600,801
| 600,802
|
u638057737
|
python
|
p02788
|
from math import ceil
from collections import deque
N,D,A = map(int,input().split())
monsters = sorted([list(map(int,input().split())) for _ in range(N)])
q = deque([])
s = 0
ans = 0
for i in range(N):
while len(q) > 0 and q[0][0] < monsters[i][0]:
s -= q[0][1]
q.popleft()
h = monsters[i][1] - s * A
num_bombs = ceil(h / A)
q.append((monsters[i][0] + 2 * D, num_bombs))
s += num_bombs
ans += num_bombs
print(ans)
|
from math import ceil
from collections import deque
N,D,A = map(int,input().split())
monsters = sorted([list(map(int,input().split())) for _ in range(N)])
q = deque([])
s = 0
ans = 0
for i in range(N):
while len(q) > 0 and q[0][0] < monsters[i][0]:
s -= q[0][1]
q.popleft()
h = monsters[i][1] - s * A
if h > 0:
num_bombs = ceil(h / A)
q.append((monsters[i][0] + 2 * D, num_bombs))
s += num_bombs
ans += num_bombs
print(ans)
|
[
"control_flow.branch.if.add"
] | 600,803
| 600,802
|
u638057737
|
python
|
p02788
|
from collections import deque
n, d, a = map(int, input().split())
monster = []
for i in range(n):
monster.append(list(map(int, input().split())))
d *= 2
monster.sort()
count = 0
damage_total = 0
q = deque([])
for i in range(n):
x = monster[i][0]
h = monster[i][1]
if len(q) > 0 and q[0][0] < x:
damage_total -= q[0][1]
q.popleft()
h -= damage_total
if h > 0:
count_now = (h + a - 1) // a
count += count_now
damage_now = a * count_now
damage_total += damage_now
q.append([x + d, damage_now])
print(count)
|
from collections import deque
n, d, a = map(int, input().split())
monster = []
for i in range(n):
monster.append(list(map(int, input().split())))
d *= 2
monster.sort()
count = 0
damage_total = 0
q = deque([])
for i in range(n):
x = monster[i][0]
h = monster[i][1]
while len(q) > 0 and q[0][0] < x:
damage_total -= q[0][1]
q.popleft()
h -= damage_total
if h > 0:
count_now = (h + a - 1) // a
count += count_now
damage_now = a * count_now
damage_total += damage_now
q.append([x + d, damage_now])
print(count)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 600,820
| 600,821
|
u255382385
|
python
|
p02788
|
from collections import deque
n, d, a = map(int, input().split())
monster = []
for i in range(n):
monster.append(list(map(int, input().split())))
d *= 2
monster.sort()
count = 0
damage_total = 0
q = deque([])
for i in range(n):
x = monster[i][0]
h = monster[i][1]
if len(q) > 0 and q[0][0] < x:
damage_total -= q[0][1]
q.popleft()
h -= damage_total
if h > 0:
count_now = (h + a - 1) // a
count += count_now
damage_now = a * count_now
damage_total += damage_now
q.append([x + d, damage_now])
print(count)
|
from collections import deque
n, d, a = map(int, input().split())
monster = []
for i in range(n):
monster.append(list(map(int, input().split())))
d *= 2
monster.sort()
count = 0
damage_total = 0
q = deque([])
for i in range(n):
x = monster[i][0]
h = monster[i][1]
while len(q) > 0 and q[0][0] < x:
damage_total -= q[0][1]
q.popleft()
h -= damage_total
if h > 0:
count_now = (h + a - 1) // a
count += count_now
damage_now = a * count_now
damage_total += damage_now
q.append([x + d, damage_now])
print(count)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 600,822
| 600,821
|
u255382385
|
python
|
p02788
|
import sys
import math
def main():
n_d_a = sys.stdin.readline().strip().split(' ')
n, d, a = [int(s) for s in n_d_a]
xh = [[]] * n
for i in range(n):
x, h = [int(s) for s in sys.stdin.readline().strip().split(' ')]
xh[i] = [x, h]
xh.sort()
cur = 0
right_indices = [0] * n
for i in range(n):
cur = max(cur, i)
x, h = xh[i]
right_val = x + d * 2
while cur < n-1 and xh[cur+1][1] <= right_val:
cur += 1
right_indices[i] = cur
imos = [0] * (n+1)
ans = 0
for i in range(n):
if imos[i] < xh[i][1]:
need = math.ceil((xh[i][1] - imos[i]) / a)
ans += need
imos[i] += need * a
right_idx = right_indices[i]
imos[right_idx+1] -= need * a
imos[i+1] += imos[i]
print(ans)
if __name__ == '__main__':
main()
|
import sys
import math
def main():
n_d_a = sys.stdin.readline().strip().split(' ')
n, d, a = [int(s) for s in n_d_a]
xh = [[]] * n
for i in range(n):
x, h = [int(s) for s in sys.stdin.readline().strip().split(' ')]
xh[i] = [x, h]
# n = 3
# d = 1
# a = 1
# xh = [[1, 4], [2, 1], [3, 100]]
xh.sort()
cur = 0
right_indices = [0] * n
for i in range(n):
cur = max(cur, i)
x, h = xh[i]
right_val = x + d * 2
while cur < n-1 and xh[cur+1][0] <= right_val:
cur += 1
right_indices[i] = cur
imos = [0] * (n+1)
ans = 0
for i in range(n):
if imos[i] < xh[i][1]:
need = math.ceil((xh[i][1] - imos[i]) / a)
ans += need
imos[i] += need * a
right_idx = right_indices[i]
imos[right_idx+1] -= need * a
imos[i+1] += imos[i]
print(ans)
if __name__ == '__main__':
main()
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"control_flow.loop.condition.change"
] | 600,915
| 600,916
|
u922965680
|
python
|
p02796
|
N = int(input())
XL = [tuple(map(int,input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
right = -float('inf')
ans = 0
for x,l in XL:
s,t = x-l+1, x+l-1
if s >= right:
right = t
ans += 1
print(ans)
|
N = int(input())
XL = [tuple(map(int,input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
right = -float('inf')
ans = 0
for x,l in XL:
s,t = x-l, x+l
if s >= right:
right = t
ans += 1
print(ans)
|
[
"expression.operation.binary.remove"
] | 600,944
| 600,945
|
u285443936
|
python
|
p02796
|
N = int(input())
se = [()] * N
for i in range(N):
x, l = map(int, input().split())
se[i] = (x-l, x+l)
se = sorted(se, key=lambda x: x[1])
ans = N
for i in range(1, N):
if se[i-1][1] > se[i][0]:
se[i][1] = se[i-1][1]
ans -= 1
print(ans)
|
N = int(input())
se = [[]] * N
for i in range(N):
x, l = map(int, input().split())
se[i] = [x-l, x+l]
se = sorted(se, key=lambda x: x[1])
ans = N
for i in range(1, N):
if se[i-1][1] > se[i][0]:
se[i][1] = se[i-1][1]
ans -= 1
print(ans)
|
[
"assignment.value.change"
] | 600,950
| 600,951
|
u054473438
|
python
|
p02796
|
n = int(input())
robot_list = []
for i in range(n):
x, l = list(map(int, input().split()))
robot_list.append([x+l, x-l, l])
delete_robot = 0
robot_list.sort()
temp_robot = robot_list[0]
for i in range(n-1):
if temp_robot[0] < robot_list[i+1][1]:
delete_robot += 1
else:
temp_robot = robot_list[i+1]
print(n - delete_robot)
|
n = int(input())
robot_list = []
for i in range(n):
x, l = list(map(int, input().split()))
robot_list.append([x+l, x-l, l])
delete_robot = 0
robot_list.sort()
temp_robot = robot_list[0]
for i in range(n-1):
if temp_robot[0] > robot_list[i+1][1]:
delete_robot += 1
else:
temp_robot = robot_list[i+1]
print(n - delete_robot)
|
[
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 600,959
| 600,960
|
u917872021
|
python
|
p02796
|
n = int(input())
robot_list = []
for i in range(n):
x, l = list(map(int, input().split()))
robot_list.append([x+l, x-l, l])
delete_robot = 0
robot_list.sort()
temp_robot = robot_list[0]
for i in range(n-1):
if temp_robot[0]-1 > robot_list[i+1][1]+1:
delete_robot += 1
else:
temp_robot = robot_list[i+1]
print(n - delete_robot)
|
n = int(input())
robot_list = []
for i in range(n):
x, l = list(map(int, input().split()))
robot_list.append([x+l, x-l, l])
delete_robot = 0
robot_list.sort()
temp_robot = robot_list[0]
for i in range(n-1):
if temp_robot[0] > robot_list[i+1][1]:
delete_robot += 1
else:
temp_robot = robot_list[i+1]
print(n - delete_robot)
|
[
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 600,961
| 600,960
|
u917872021
|
python
|
p02796
|
# -*- coding: utf-8 -*-
N = int(input())
items = [list(map(int, input().split())) for i in range(N)]
items = sorted(items, key=lambda x:x[0]+x[1])
res = 0
bf = -1
for x, l in items:
if bf <= x:
res += 1
bf = x + l
print(res)
|
# -*- coding: utf-8 -*-
N = int(input())
items = [list(map(int, input().split())) for i in range(N)]
items = sorted(items, key=lambda x:x[0]+x[1])
res = 0
bf = -10**9
for x, l in items:
if bf <= x - l:
res += 1
bf = x + l
print(res)
|
[
"literal.number.integer.change",
"assignment.value.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 600,975
| 600,976
|
u804182086
|
python
|
p02796
|
n = int(input())
ls = [(0, 0)] * n
for i in range(n):
x, ln = map(int, input().split())
l = x - ln
r = x + ln
ls[i] = (l, x)
#print(ls)
ls.sort(key=lambda x: x[1])
#print(ls)
last = -float('inf')
count = 0
for i in ls:
if last <= i[0]:
count += 1
last = i[1]
print(count)
|
n = int(input())
ls = [(0, 0)] * n
for i in range(n):
x, ln = map(int, input().split())
l = x - ln
r = x + ln
ls[i] = (l, r)
#print(ls)
ls.sort(key=lambda x: x[1])
#print(ls)
last = -float('inf')
count = 0
for i in ls:
if last <= i[0]:
count += 1
last = i[1]
print(count)
|
[
"assignment.value.change",
"identifier.change"
] | 600,985
| 600,986
|
u137226361
|
python
|
p02796
|
n = int(input())
ls = [(0, 0)] * n
for i in range(n):
x, ln = map(int, input().split())
l = x - ln
r = x + ln
ls[i] = (l, x)
#print(ls)
ls.sort(key=lambda x: x[1])
#print(ls)
last = -float('inf')
count = 0
for i in ls:
if last <= i[0]:
count += 1
last = i[1]
print(count)
|
n = int(input())
ls = [(0, 0)] * n
for i in range(n):
x, ln = map(int, input().split())
l = x - ln
r = x + ln
ls[i] = (l, r)
#print(ls)
ls.sort(key=lambda x: x[1])
#print(ls)
last = -float('inf')
count = 0
for i in ls:
if last <= i[0]:
count += 1
last = i[1]
print(count)
|
[
"assignment.value.change",
"identifier.change"
] | 600,987
| 600,986
|
u137226361
|
python
|
p02796
|
N = int(input())
robo = []
for _ in range(N):
X, L = map(int, input().split())
robo.append([X-L, X+L])
robo = sorted(robo, key=lambda x:x[1])
last = robo[0][1]
cnt = 1
for r in robo[1:]:
if r[0] >= last:
cnt += 1
last = r[0]
print(cnt)
|
N = int(input())
robo = []
for _ in range(N):
X, L = map(int, input().split())
robo.append([X-L, X+L])
robo = sorted(robo, key=lambda x:x[1])
last = robo[0][1]
cnt = 1
for r in robo[1:]:
if r[0] >= last:
cnt += 1
last = r[1]
print(cnt)
|
[
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 600,993
| 600,994
|
u642012866
|
python
|
p02796
|
n=int(input())
A=[[] for i in range(n)]
for i in range(n):
x,l=map(int,input().split())
A[i]=[x-l,x+l]
A=sorted(A, key=lambda x :x[1])
print(A)
ans=0
last=-float("INF")
for i in range(n):
if last<=A[i][0]:
ans+=1
last=A[i][1]
print(ans)
|
n=int(input())
A=[[] for i in range(n)]
for i in range(n):
x,l=map(int,input().split())
A[i]=[x-l,x+l]
A=sorted(A, key=lambda x :x[1])
#print(A)
ans=0
last=-float("INF")
for i in range(n):
if last<=A[i][0]:
ans+=1
last=A[i][1]
print(ans)
|
[
"call.remove"
] | 600,997
| 600,998
|
u023229441
|
python
|
p02796
|
n=int(input())
itv=[]
for i in range(n):
x,l=map(int,input().split())
itv+=[(x+l-1,x-l+1)]
itv=sorted(itv)
l=-10**18
cnt=0
for t,s in itv:
if l<s:
l=t
cnt+=1
print(cnt)
|
n=int(input())
itv=[]
for i in range(n):
x,l=map(int,input().split())
itv+=[(x+l,x-l)]
itv=sorted(itv)
l=-10**18
cnt=0
for t,s in itv:
if l<=s:
l=t
cnt+=1
print(cnt)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 600,999
| 601,000
|
u730769327
|
python
|
p02796
|
N = int(input())
R = []
for i in range(N):
x, l = map(int, input().split())
R.append((x - l, x + l))
R.sort()
l = -(1 << 40)
cnt = 0
for r in R:
if l <= r[0]:
cnt += 1
l = r[1]
print(cnt)
|
N = int(input())
R = []
for i in range(N):
x, l = map(int, input().split())
R.append((x + l, x - l))
R.sort()
l = -(1 << 40)
cnt = 0
for r in R:
if l <= r[1]:
cnt += 1
l = r[0]
print(cnt)
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.integer.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 601,008
| 601,009
|
u726872801
|
python
|
p02796
|
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
n = INT()
x = [[0]*2 for i in range(n)]
for i in range(n):
x[i][0], x[i][1] = MAP()
x.sort()
tmp = -inf
ans = n
for i in range(n):
if tmp > x[i][0] - x[i][1]:
ans -= 1
tmp = min(tmp, x[i][0] + x[i][1])
print(i)
else:
tmp = x[i][0] + x[i][1]
print(ans)
|
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
n = INT()
x = [[0]*2 for i in range(n)]
for i in range(n):
x[i][0], x[i][1] = MAP()
x.sort()
tmp = -inf
ans = n
for i in range(n):
if tmp > x[i][0] - x[i][1]:
ans -= 1
tmp = min(tmp, x[i][0] + x[i][1])
else:
tmp = x[i][0] + x[i][1]
print(ans)
|
[
"call.remove"
] | 601,028
| 601,029
|
u603958124
|
python
|
p02796
|
n = int(input())
xlt = []
for i in range(n):
xi,li = map(int,input().split())
xlt.append((xi+li,xi-li))
xlt.sort()
ans = 0
x = -float("INF")
for i in range(n):
if x <= xlt[i][1]:
ans += 1
x = xlt[0][0]
print(ans)
|
n = int(input())
xlt = []
for i in range(n):
xi,li = map(int,input().split())
xlt.append((xi+li,xi-li))
xlt.sort()
ans = 0
x = -float("INF")
for i in range(n):
if x <= xlt[i][1]:
ans += 1
x = xlt[i][0]
print(ans)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 601,037
| 601,038
|
u867826040
|
python
|
p02796
|
from collections import deque
n = int(input())
cou = n
l_h = []
for i in range(n):
x,l = map(int,input().split())
l_h.append([x-l,x+l])
l_h.sort(key=lambda x: x[1])
d = deque(l_h)
t= d.popleft()
a,b = t[0],t[1]
for i in range(n-1):
m= d.popleft()
c,e= m[0],m[1]
if b<=c:
b = d
else:
cou -= 1
print(cou)
|
from collections import deque
n = int(input())
cou = n
l_h = []
for i in range(n):
x,l = map(int,input().split())
l_h.append([x-l,x+l])
l_h.sort(key=lambda x: x[1])
d = deque(l_h)
t= d.popleft()
a,b = t[0],t[1]
for i in range(n-1):
m= d.popleft()
c,e= m[0],m[1]
if b<=c:
b = e
else:
cou -= 1
print(cou)
|
[
"assignment.value.change",
"identifier.change"
] | 601,045
| 601,046
|
u288430479
|
python
|
p02796
|
from collections import deque
n = int(input())
cou = n
l_h = []
for i in range(n):
x,l = map(int,input().split())
l_h.append([x-l,x+l])
l_h.sort(key=lambda x: x[1])
d = deque(l_h)
t= d.popleft()
a,b = t[0],t[1]
for i in range(n-1):
m= d.popleft()
c,e= m[0],m[1]
if b<=c:
b = c
else:
cou -= 1
print(cou)
|
from collections import deque
n = int(input())
cou = n
l_h = []
for i in range(n):
x,l = map(int,input().split())
l_h.append([x-l,x+l])
l_h.sort(key=lambda x: x[1])
d = deque(l_h)
t= d.popleft()
a,b = t[0],t[1]
for i in range(n-1):
m= d.popleft()
c,e= m[0],m[1]
if b<=c:
b = e
else:
cou -= 1
print(cou)
|
[
"assignment.value.change",
"identifier.change"
] | 601,047
| 601,046
|
u288430479
|
python
|
p02796
|
def solve(XL, N):
XL.sort(key=lambda x:x[0])
count = N
for i in range(1, N):
if XL[i][0] < XL[i-1][1]:
XL[i][1] = XL[i-1][1]
count -= 1
return count
N = int(input())
XL = []
for i in range(N):
x, l = map(int, input().split(' '))
XL.append([x-l, x+l])
print(solve(XL, N))
|
def solve(XL, N):
XL.sort(key=lambda x:x[1])
count = N
for i in range(1, N):
if XL[i][0] < XL[i-1][1]:
XL[i][1] = XL[i-1][1]
count -= 1
return count
N = int(input())
XL = []
for i in range(N):
x, l = map(int, input().split(' '))
XL.append([x-l, x+l])
print(solve(XL, N))
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 601,048
| 601,049
|
u509150616
|
python
|
p02796
|
n = int(input())
r = [list(map(int,input().split())) for _ in range(n)]
for i in range(n):
r[i] = [r[i][0] - r[i][1], r[i][0] + r[i][1]]
r.sort(key = lambda x:x[1])
print(r)
cur = -1001001001
ans = 0
for i in range(n):
if cur <= r[i][0]:
ans += 1
cur = r[i][1]
print(ans)
|
n = int(input())
r = [list(map(int,input().split())) for _ in range(n)]
for i in range(n):
r[i] = [r[i][0] - r[i][1], r[i][0] + r[i][1]]
r.sort(key = lambda x:x[1])
#print(r)
cur = -1001001001
ans = 0
for i in range(n):
if cur <= r[i][0]:
ans += 1
cur = r[i][1]
print(ans)
|
[
"call.remove"
] | 601,052
| 601,053
|
u389007679
|
python
|
p02796
|
N = int(input())
XL = [tuple(map(int, input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0])
right = -10**9
removed = 0
for x, l in XL:
if x-l < right:
removed += 1
else:
right = x+l
print(N-removed)
|
N = int(input())
XL = [tuple(map(int, input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
right = -10**9
removed = 0
for x, l in XL:
if x-l < right:
removed += 1
else:
right = x+l
print(N-removed)
|
[
"expression.operation.binary.add"
] | 601,058
| 601,059
|
u814986259
|
python
|
p02796
|
N = int(input())
robot = []
for _ in range(N):
r = []
x, l = map(int, input().split())
a = x + l
b = x - l
r += [a, b]
robot.append(r)
Robot = sorted(robot)
robot_count = [Robot[0]]
for i in range(1, N):
if Robot[i][1] > robot_count[-1][0]:
robot_count.append(Robot[i])
print(len(robot_count))
|
N = int(input())
robot = []
for _ in range(N):
r = []
x, l = map(int, input().split())
a = x + l
b = x - l
r += [a, b]
robot.append(r)
Robot = sorted(robot)
robot_count = [Robot[0]]
for i in range(1, N):
if Robot[i][1] >= robot_count[-1][0]:
robot_count.append(Robot[i])
print(len(robot_count))
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,060
| 601,061
|
u241159583
|
python
|
p02796
|
N = int(input())
robot = []
for _ in range(N):
r = []
x, l = map(int, input().split())
a = x + l - 1
b = x - l + 1
r += [a, b]
robot.append(r)
Robot = sorted(robot)
robot_count = [Robot[0]]
for i in range(1, N):
if Robot[i][1] > robot_count[-1][0]:
robot_count.append(Robot[i])
print(len(robot_count))
|
N = int(input())
robot = []
for _ in range(N):
r = []
x, l = map(int, input().split())
a = x + l
b = x - l
r += [a, b]
robot.append(r)
Robot = sorted(robot)
robot_count = [Robot[0]]
for i in range(1, N):
if Robot[i][1] >= robot_count[-1][0]:
robot_count.append(Robot[i])
print(len(robot_count))
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,062
| 601,061
|
u241159583
|
python
|
p02796
|
n = int(input())
data = []
for i in range(n):
x, l = map(int, input().split())
data.append([x, l])
data = sorted(data, key = lambda x: x[0])
ans = 0
pre = -(10 ** 10)
for i in range(n):
if data[i][0] - data[i][1] >= pre:
ans += 1
pre = data[i][0] + data[i][1]
print(ans)
|
n = int(input())
data = []
for i in range(n):
x, l = map(int, input().split())
data.append([x, l])
data = sorted(data, key = lambda x: x[0] + x[1])
ans = 0
pre = -(10 ** 10)
for i in range(n):
if data[i][0] - data[i][1] >= pre:
ans += 1
pre = data[i][0] + data[i][1]
print(ans)
|
[
"assignment.change"
] | 601,063
| 601,064
|
u502731482
|
python
|
p02796
|
N = int(input())
XL = [list(map(int, input().split())) for x in range(N)]
XL = sorted(XL, key=lambda x: x[0]+x[1])
cnt = 0
prev_right = -10**9+10
for x, l in XL:
left = x - l + 1
right = x + l - 1
if left > prev_right:
cnt += 1
prev_right = right
print(cnt)
|
N = int(input())
XL = [list(map(int, input().split())) for x in range(N)]
XL = sorted(XL, key=lambda x: x[0]+x[1])
cnt = 0
prev_right = -10**9+10
for x, l in XL:
left = x - l
right = x + l
if left >= prev_right:
cnt += 1
prev_right = right
print(cnt)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,065
| 601,066
|
u758411830
|
python
|
p02796
|
N=int(input())
XL=[]
for _ in range(N):
a=list(map(int,input().split()))
XL.append(a)
XL = sorted(XL, key=lambda x:x[0])
#前から順に取っていく
#DP[i]:i番目までのロボットで残せるロボットの最大数
#i番目のロボットがどこまでをカバーしているかを格納する必要がある
DP=[[0,0] for i in range(N)]
DP[0][0]=1#個数
DP[0][1]=XL[0][0]+XL[0][1]#カバーしている距離
for i in range(1,N):
if XL[i][0]-XL[i][1]>=DP[i-1][1]:
DP[i][0]=DP[i-1][0]+1
DP[i][1]=XL[i][0]+XL[i][1]
else:
DP[i][0]=DP[i-1][0]
DP[i][1]=DP[i-1][1]
print(DP[-1][0])
|
N=int(input())
XL=[]
for _ in range(N):
a=list(map(int,input().split()))
XL.append(a)
XL = sorted(XL, key=lambda x:x[0]+x[1])
#前から順に取っていく
#DP[i]:i番目までのロボットで残せるロボットの最大数
#i番目のロボットがどこまでをカバーしているかを格納する必要がある
DP=[[0,0] for i in range(N)]
DP[0][0]=1#個数
DP[0][1]=XL[0][0]+XL[0][1]#カバーしている距離
for i in range(1,N):
if XL[i][0]-XL[i][1]>=DP[i-1][1]:
DP[i][0]=DP[i-1][0]+1
DP[i][1]=XL[i][0]+XL[i][1]
else:
DP[i][0]=DP[i-1][0]
DP[i][1]=DP[i-1][1]
print(DP[-1][0])
|
[
"assignment.change"
] | 601,067
| 601,068
|
u753386263
|
python
|
p02796
|
if __name__ == '__main__':
n = int(input())
robots = []
for i in range(n):
x, l = map(int, input().split())
robots.append((x, l, x + l))
robots = sorted(robots, key=lambda x: x[2])
ans = []
for i in range(n):
if i == 0:
ans.append(robots[i][2])
else:
if robots[i][0] >= ans[-1]:
ans.append(robots[i][2])
print(len(ans))
|
if __name__ == '__main__':
n = int(input())
robots = []
for i in range(n):
x, l = map(int, input().split())
robots.append((x - l, x + l))
robots = sorted(robots, key=lambda x: x[1])
ans = []
for i in range(n):
if i == 0:
ans.append(robots[i][1])
else:
if robots[i][0] >= ans[-1]:
ans.append(robots[i][1])
print(len(ans))
|
[
"call.arguments.change",
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 601,075
| 601,076
|
u505420467
|
python
|
p02796
|
N = int(input())
XL = [list(map(int,input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
M = XL[0][0]+XL[0][1]-1
ans = N
for i in range(1,N):
if M >= XL[i][0]-XL[i][1]+1:
ans -= 1
else:
M = XL[i][0]+XL[i][1]-1
print(ans)
|
N = int(input())
XL = [list(map(int,input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
M = XL[0][0]+XL[0][1]-1
ans = 0
for i in range(1,N):
if M >= XL[i][0]-XL[i][1]:
ans += 1
else:
M = XL[i][0]+XL[i][1]-1
print(N-ans)
|
[
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"expression.operator.change"
] | 601,077
| 601,078
|
u747602774
|
python
|
p02796
|
n = int(input())
xl = [list(map(int,input().split())) for i in range(n)]
xl = sorted(xl)
pre = 0
cnt = 0
for x, l in xl:
if pre == 0:
pre = x + l
continue
if x - l < pre and pre < x + l:
cnt += 1
elif x + l < pre:
cnt += 1
pre = x + l
else:
pre = x + l
print(n - cnt)
|
n = int(input())
xl = [list(map(int,input().split())) for i in range(n)]
xl = sorted(xl)
pre = 0
cnt = 0
for x, l in xl:
if pre == 0:
pre = x + l
continue
if x - l < pre <= x + l:
cnt += 1
elif x + l < pre:
cnt += 1
pre = x + l
else:
pre = x + l
print(n - cnt)
|
[
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 601,088
| 601,089
|
u867848444
|
python
|
p02796
|
def main():
n=int(input())
xs=[0]*n
ls=[0]*n
ranges=[0]*n
for i in range(n):
xs[i],ls[i]=map(int,input().split())
ranges[i]=[xs[i]-ls[i],xs[i]+ls[i]]
ranges.sort(key=lambda x:x[1])
count=0
point=-10000
for irange in ranges:
if irange[0]>=point:
count+=1
point=irange[1]
print(count)
if __name__ == "__main__":
main()
|
def main():
n=int(input())
xs=[0]*n
ls=[0]*n
ranges=[0]*n
for i in range(n):
xs[i],ls[i]=map(int,input().split())
ranges[i]=[xs[i]-ls[i],xs[i]+ls[i]]
ranges.sort(key=lambda x:x[1])
count=0
point=-1000000000000
for irange in ranges:
if irange[0]>=point:
count+=1
point=irange[1]
print(count)
if __name__ == "__main__":
main()
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 601,100
| 601,099
|
u608355135
|
python
|
p02796
|
N = int(input())
arm = []
for n in range(N):
i, L = map(int, input().split())
arm.append([i-L, i+L])
sarm = sorted(arm)
pre = -10**10
count = 0
for a in sarm:
if pre <= a[0]:
count += 1
pre = a[1]
print(count)
|
N = int(input())
arm = []
for n in range(N):
i, L = map(int, input().split())
arm.append([i+L, i-L])
sarm = sorted(arm)
pre = -10**10
count = 0
for a in sarm:
if pre <= a[1]:
count += 1
pre = a[0]
print(count)
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.integer.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 601,103
| 601,104
|
u038887660
|
python
|
p02796
|
N = int(input())
robots = []
for _ in range(N):
x, l = map(int, input().split())
robots.append((x-l, x+l))
robots.sort(key=lambda x: x[1]) # 終端を昇順ソート
# print(robots)
cnt = 0
last = -10**18 # 最初、最右のものははるか左側にあると考える
for left, right in robots:
if left+1 > last-1: # 残せるのであれば
cnt += 1
last = right
print(cnt)
|
N = int(input())
robots = []
for _ in range(N):
x, l = map(int, input().split())
robots.append((x-l, x+l))
robots.sort(key=lambda x: x[1]) # 終端を昇順ソート
# print(robots)
cnt = 0
last = -10**18 # 最初、最右のものははるか左側にあると考える
for left, right in robots:
if left >= last: # 残せるのであれば
cnt += 1
last = right
print(cnt)
|
[
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 601,131
| 601,132
|
u708255304
|
python
|
p02796
|
def solve(N, XL):
XL_re = [[xl[0] - xl[1], xl[0] + xl[1]] for xl in XL]
XL_re = sorted(XL_re, key=lambda x: x[1])
cnt = 0
for i, xl in enumerate(XL_re):
if i == 0:
tmp = xl[1]
cnt += 1
else:
if tmp <= xl[0]:
tmp = xl[1]
cnt += 1
return cnt
def test():
assert solve(4, [[2, 4], [4, 3], [9, 3], [100, 5]]) == 3
def main():
N = int(input())
XL = [list(map(int, input().split())) for _ in range(N)]
ans = main(N, XL)
print(ans)
if __name__ == "__main__":
# test()
main()
|
def solve(N, XL):
XL_re = [[xl[0] - xl[1], xl[0] + xl[1]] for xl in XL]
XL_re = sorted(XL_re, key=lambda x: x[1])
cnt = 0
for i, xl in enumerate(XL_re):
if i == 0:
tmp = xl[1]
cnt += 1
else:
if tmp <= xl[0]:
tmp = xl[1]
cnt += 1
return cnt
def test():
assert solve(4, [[2, 4], [4, 3], [9, 3], [100, 5]]) == 3
def main():
N = int(input())
XL = [list(map(int, input().split())) for _ in range(N)]
ans = solve(N, XL)
print(ans)
if __name__ == "__main__":
# test()
main()
|
[
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 601,142
| 601,143
|
u362771726
|
python
|
p02796
|
import sys
readline = sys.stdin.buffer.readline
from collections import deque
from copy import copy,deepcopy
from itertools import permutations,combinations
from pprint import pprint
def myinput():
return map(int,readline().split())
def mycol(data,col):
return [ row[col] for row in data ]
def mysort(data,col):
return data.sort(key=lambda x:x[col],reverse=True)
n = int(input())
xl = [ list(myinput()) for _ in range(n) ]
ls = []
for i in range(n):
x = xl[i][0]
l = xl[i][1]
s = x - l
e = x + l
d= [s,e]
ls.append(d)
# print(ls)
ls.sort(key=lambda x:x[1],reverse=False)
# print(ls)
count = 0
e = -1*float("inf")
for i in range(n):
ns,ne = ls[i]
if ns>=e:
count += 1
e = copy(ne)
else:
pass
print(count)
|
import sys
readline = sys.stdin.buffer.readline
from collections import deque
from copy import copy,deepcopy
from itertools import permutations,combinations
from pprint import pprint
def myinput():
return map(int,input().split())
def mycol(data,col):
return [ row[col] for row in data ]
def mysort(data,col):
return data.sort(key=lambda x:x[col],reverse=True)
n = int(input())
xl = [ list(myinput()) for _ in range(n) ]
# print(xl)
ls = []
for i in range(n):
x = xl[i][0]
l = xl[i][1]
s = x - l
e = x + l
d = [s,e]
ls.append(d)
# print(ls)
ls.sort(key=lambda x:x[1],reverse=False)
# print(ls)
count = 0
e = -1*float("inf")
for i in range(n):
ns,ne = ls[i]
if ns>=e:
count += 1
e = copy(ne)
else:
pass
print(count)
|
[
"identifier.change",
"call.function.change",
"call.arguments.change",
"function.return_value.change"
] | 601,150
| 601,151
|
u255673886
|
python
|
p02796
|
n=int(input())
hani=[]
for i in range(n):
x,l=map(int,input().split())
hani.append([x,l])
hani2=sorted(hani)
#print(hani2)
no=0 #削除するロボット
bef=0
af=1
for i in range(n-1):
a,b,a2,b2=hani2[bef][0],hani2[bef][1],hani2[af][0],hani2[af][1]
if a<=a2<b:
no+=1
if b<b2: #前者を採用
af+=1
else:
bef=af
af+=1
else:
bef=af
af+=1
print(n-no)
|
n=int(input())
hani=[]
for i in range(n):
x,l=map(int,input().split())
hani.append([x-l,x+l])
hani2=sorted(hani)
#print(hani2)
no=0 #削除するロボット
bef=0
af=1
for i in range(n-1):
a,b,a2,b2=hani2[bef][0],hani2[bef][1],hani2[af][0],hani2[af][1]
if a<=a2<b:
no+=1
if b<b2: #前者を採用
af+=1
else:
bef=af
af+=1
else:
bef=af
af+=1
print(n-no)
|
[
"expression.operation.binary.add"
] | 601,157
| 601,158
|
u548303713
|
python
|
p02796
|
n=int(input())
hani=[]
for i in range(n):
x,l=map(int,input().split())
hani.append([x-l,x+l])
hani2=sorted(hani)
#print(hani2)
no=0 #削除するロボット
bef=0
af=1
for i in range(n-1):
a,b,a2,b2=hani2[bef][0],hani2[bef][1],hani2[af][0],hani2[af][1]
if a<=a2<b:
no+=1
if b<b2: #前者を採用
af+=1
else:
bef+=1
af+=1
else:
bef+=1
af+=1
print(n-no)
|
n=int(input())
hani=[]
for i in range(n):
x,l=map(int,input().split())
hani.append([x-l,x+l])
hani2=sorted(hani)
#print(hani2)
no=0 #削除するロボット
bef=0
af=1
for i in range(n-1):
a,b,a2,b2=hani2[bef][0],hani2[bef][1],hani2[af][0],hani2[af][1]
if a<=a2<b:
no+=1
if b<b2: #前者を採用
af+=1
else:
bef=af
af+=1
else:
bef=af
af+=1
print(n-no)
|
[] | 601,159
| 601,158
|
u548303713
|
python
|
p02796
|
N = int(input())
arm = []
for i in range(N):
X, L = map(int, input().split())
arm.append((X - L, X + L))
arm = sorted(arm, key=lambda x: x[1])
print(arm)
count = 0
i = arm[0][0]
for start, end in arm:
if start < i:
continue
i = end
count += 1
print(count)
|
N = int(input())
arm = []
for i in range(N):
X, L = map(int, input().split())
arm.append((X - L, X + L))
arm = sorted(arm, key=lambda x: x[1])
count = 0
i = arm[0][0]
for start, end in arm:
if start < i:
continue
i = end
count += 1
print(count)
|
[
"call.remove"
] | 601,160
| 601,161
|
u255821449
|
python
|
p02796
|
n = int(input())
XL = [[int(x) for x in input().split()] for _ in range(n)]
XL.sort(key=lambda xl: xl[0] - xl[1])
count = 0
while len(XL) > 0:
count += 1
limit = XL[0][0] + XL[0][1]
while len(XL) > 0 and XL[0][0] - XL[0][1] < limit:
XL.pop(0)
print(count)
|
n = int(input())
XL = [[int(x) for x in input().split()] for _ in range(n)]
XL.sort(key=lambda xl: xl[0] + xl[1])
count = 0
while len(XL) > 0:
count += 1
limit = XL[0][0] + XL[0][1]
while len(XL) > 0 and XL[0][0] - XL[0][1] < limit:
XL.pop(0)
print(count)
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 601,181
| 601,182
|
u392220578
|
python
|
p02796
|
N = int(input())
R = []
for _ in range(N):
x, l = map(int, input().split())
R.append([x-l, x+l])
R = sorted(R, key=lambda x: x[1])
ans = 0
tmp = -float('inf')
for l, r in R:
if tmp <= r:
ans += 1
tmp = l
print(ans)
|
N = int(input())
R = []
for _ in range(N):
x, l = map(int, input().split())
R.append([x-l, x+l])
R = sorted(R, key=lambda x: x[1])
ans = 0
tmp = -float('inf')
for l, r in R:
if tmp <= l:
ans += 1
tmp = r
print(ans)
|
[
"identifier.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 601,187
| 601,188
|
u375616706
|
python
|
p02796
|
n=int(input())
l=[]
for i in range(n):
x,y=map(int,input().split())
l.append([x-y+1,x+y-1])
count=0
l=sorted(l)
l=l[::-1]
count+=1
now=l[0][0]
for i in range(1,n):
if now>l[i][1]:
now=l[i][0]
count+=1
else:
pass
print(count)
|
n=int(input())
l=[]
for i in range(n):
x,y=map(int,input().split())
l.append([x-y,x+y])
count=0
l=sorted(l)
l=l[::-1]
count+=1
now=l[0][0]
for i in range(1,n):
if now>=l[i][1]:
now=l[i][0]
count+=1
else:
pass
print(count)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,216
| 601,217
|
u518042385
|
python
|
p02796
|
from sys import stdin
N = int(stdin.readline().rstrip())
data = []
for i in range(N):
X,L = [int(x) for x in stdin.readline().rstrip().split()]
data.append((X-L,X+L))
ans = 0
left = -10**9-1
for j,k in sorted(data):
if j >= left:
left = k
ans += 1
print(ans)
|
from sys import stdin
N = int(stdin.readline().rstrip())
data = []
for i in range(N):
X,L = [int(x) for x in stdin.readline().rstrip().split()]
data.append((X+L,X-L))
ans = 0
left = -10**9-1
for k,j in sorted(data):
if j >= left:
left = k
ans += 1
print(ans)
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 601,229
| 601,230
|
u405256066
|
python
|
p02796
|
n = int(input())
xl = [list(map(int, input().split())) for _ in range(n)]
ran = [[xl[i][0]-xl[i][1], xl[i][0]+xl[i][1]] for i in range(n)]
ran = sorted(ran, key=lambda x:x[1])
ans = n
right = ran[0][1]
for i in range(1, n):
l, r = ran[i]
if l < right < r:
ans -= 1
else:
right = r
print(ans)
|
n = int(input())
xl = [list(map(int, input().split())) for _ in range(n)]
ran = [[xl[i][0]-xl[i][1], xl[i][0]+xl[i][1]] for i in range(n)]
ran = sorted(ran, key=lambda x:x[1])
ans = n
right = ran[0][1]
for i in range(1, n):
l, r = ran[i]
if l < right:
ans -= 1
else:
right = r
print(ans)
|
[
"control_flow.loop.for.condition.change"
] | 601,236
| 601,237
|
u844646164
|
python
|
p02796
|
from operator import itemgetter
N = int(input())
R = [0]*N
for i in range(N):
X_i, L_i = map(int, input().split())
R[i] = (X_i-L_i+1,X_i+L_i-1)
R.sort(key=itemgetter(1))
ans, loc = 0, -(float('inf'))
for i in range(len(R)):
if loc < R[i][0]:
ans += 1
loc = R[i][1]
print(ans)
|
from operator import itemgetter
N = int(input())
R = [0]*N
for i in range(N):
X_i, L_i = map(int, input().split())
R[i] = (X_i-L_i,X_i+L_i)
R.sort(key=itemgetter(1))
ans, loc = 0, -(float('inf'))
for i in range(len(R)):
if loc <= R[i][0]:
ans += 1
loc = R[i][1]
print(ans)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,251
| 601,252
|
u273010357
|
python
|
p02796
|
N = int(input())
a = sorted([(x + l, x - l) for x, l in (map(int, l.split()) for l in sys.stdin)])
last = a[0][0]
ans = 1
for r, l in a[1:]:
if last <= l:
ans += 1
last = r
print(ans)
|
import sys
N = int(input())
a = sorted([(x + l, x - l) for x, l in (map(int, l.split()) for l in sys.stdin)])
last = a[0][0]
ans = 1
for r, l in a[1:]:
if last <= l:
ans += 1
last = r
print(ans)
|
[] | 601,253
| 601,254
|
u546104065
|
python
|
p02796
|
import sys
input=sys.stdin.buffer.readline
L=[]
for _ in range(int(input())):
x,l=map(int,input().split())
L.append((x-l,x+l))
L.sort(key=lambda x:x[1])
ans=0
cur=-1
for a,b in L:
if a>=cur:
cur=b
ans+=1
print(ans)
|
import sys
input=sys.stdin.buffer.readline
L=[]
for _ in range(int(input())):
x,l=map(int,input().split())
L.append((x-l,x+l))
L.sort(key=lambda x:x[1])
ans=0
cur=-11111111111111111
for a,b in L:
if a>=cur:
cur=b
ans+=1
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 601,255
| 601,256
|
u670180528
|
python
|
p02796
|
n = int(input())
xl = []
for i in range(n):
x,l = map(int,input().split())
xl.append([x+l,x-l])
xl.sort()
ans = -10**10
count = 0
for j in range(n):
if xl[i][1] > ans:
count +=1
ans = xl[i][0]
print(count)
|
n = int(input())
xl = []
for i in range(n):
x,l = map(int,input().split())
xl.append([x+l,x-l])
xl.sort()
ans = -10**10
count = 0
for j in range(n):
if xl[j][1] >= ans:
count +=1
ans = xl[j][0]
print(count)
|
[
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"assignment.value.change"
] | 601,257
| 601,258
|
u934788990
|
python
|
p02796
|
n = int(input())
xl = []
for i in range(n):
x,l = map(int,input().split())
xl.append([x-l,x+l])
xl.sort()
ans = -10**10
count = 0
for j in range(n):
if xl[i][1] > ans:
count +=1
ans = xl[i][0]
print(count)
|
n = int(input())
xl = []
for i in range(n):
x,l = map(int,input().split())
xl.append([x+l,x-l])
xl.sort()
ans = -10**10
count = 0
for j in range(n):
if xl[j][1] >= ans:
count +=1
ans = xl[j][0]
print(count)
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"assignment.value.change"
] | 601,259
| 601,258
|
u934788990
|
python
|
p02796
|
N = int(input())
R = sorted([list(map(int, input().split())) for _ in range(N)], key=lambda x:x[0])
remain = list(range(N))
ans = N
left = 0
i = 1
while i < N:
x_l, length_l = R[left]
x, length = R[i]
if x-x_l < length_l+length:
ans -= 1
else:
left = i
i += 1
print(ans)
|
N = int(input())
R = sorted([list(map(int, input().split())) for _ in range(N)], key=lambda x:x[0]+x[1])
remain = list(range(N))
ans = N
left = 0
i = 1
while i < N:
x_l, length_l = R[left]
x, length = R[i]
if x-x_l < length_l+length:
ans -= 1
else:
left = i
i += 1
print(ans)
|
[
"assignment.change"
] | 601,273
| 601,274
|
u978178314
|
python
|
p02796
|
n = int(input())
l = []
for _ in range(n):
x,y = map(int, input().split())
l.append([x+y,x-y])
l.sort()
temp = l[0][1]
count = n
i = 1
for i in range(1,n):
if temp <= l[i][1]:
temp = l[i][0]
else:
temp = min(temp,l[i][1])
count -= 1
print(count)
|
n = int(input())
l = []
for _ in range(n):
x,y = map(int, input().split())
l.append([x+y,x-y])
l.sort()
temp = l[0][0]
count = n
i = 1
for i in range(1,n):
if temp <= l[i][1]:
temp = l[i][0]
else:
temp = min(temp,l[i][0])
count -= 1
print(count)
|
[
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 601,277
| 601,278
|
u127499732
|
python
|
p02796
|
n = int(input())
lis = []
for _ in range(n):
x, l= list(input().split(" "))
p_d = int(x) + int(l)
m_d = int(x) - int(l)
lis.append([m_d, p_d])
lis.sort()
a = -10 ** 10
x = 0
for b in range(n):
if lis[b][1] >= a:
x += 1
a = lis[b][0]
print(x)
|
n = int(input())
lis = []
for _ in range(n):
x, l= list(input().split(" "))
p_d = int(x) + int(l)
m_d = int(x) - int(l)
lis.append([p_d, m_d])
lis.sort()
a = -10 ** 10
x = 0
for b in range(n):
if lis[b][1] >= a:
x += 1
a = lis[b][0]
print(x)
|
[] | 601,283
| 601,284
|
u840570107
|
python
|
p02796
|
n = int(input())
lis = []
for _ in range(n):
x, l= list(input().split(" "))
p_d = int(x) + int(l)
m_d = int(x) - int(l)
lis.append([m_d, p_d])
lis.sort()
a = -10 ** 10
x = 0
for b in range(n):
if lis[b][0] >= a:
x += 1
a = lis[b][1]
print(x)
|
n = int(input())
lis = []
for _ in range(n):
x, l= list(input().split(" "))
p_d = int(x) + int(l)
m_d = int(x) - int(l)
lis.append([p_d, m_d])
lis.sort()
a = -10 ** 10
x = 0
for b in range(n):
if lis[b][1] >= a:
x += 1
a = lis[b][0]
print(x)
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 601,285
| 601,284
|
u840570107
|
python
|
p02796
|
N = int(input())
XL = [list(map(int, input().split())) for _ in range(N)]
RL = [[0, 0] for _ in range(N)]
for i in range(N):
left = XL[i][0] - XL[i][1] + 1
right = XL[i][0] + XL[i][1] - 1
RL[i][0] = left
RL[i][1] = right
RL.sort(key=lambda x: x[1])
now_right = RL[0][1]
cnt = 0
for i in range(1, N):
if now_right <= RL[i][0]:
now_right = RL[i][1]
else:
cnt += 1
print(N - cnt)
|
N = int(input())
XL = [list(map(int, input().split())) for _ in range(N)]
RL = [[0, 0] for _ in range(N)]
for i in range(N):
left = XL[i][0] - XL[i][1]
right = XL[i][0] + XL[i][1]
RL[i][0] = left
RL[i][1] = right
RL.sort(key=lambda x: x[1])
now_right = RL[0][1]
cnt = 0
for i in range(1, N):
if now_right <= RL[i][0]:
now_right = RL[i][1]
else:
cnt += 1
print(N - cnt)
|
[
"expression.operation.binary.remove"
] | 601,305
| 601,306
|
u379959788
|
python
|
p02796
|
length = int(input())
target = []
for i in range(length):
s, e = map(int, input().split(" "))
target.append([s - e, s + e])
target.sort(key = lambda x: x[1])
answer = 0
before_e = -1
for s, e in target:
# print(before_e, s, e)
if s < before_e:
answer += 1
else:
before_e = e
print(length - answer)
|
length = int(input())
target = []
for i in range(length):
s, e = map(int, input().split(" "))
target.append([s - e, s + e])
target.sort(key = lambda x: x[1])
answer = 0
before_e = -float("inf")
for s, e in target:
# print(before_e, s, e)
if s < before_e:
answer += 1
else:
before_e = e
print(length - answer)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.add"
] | 601,324
| 601,325
|
u594567187
|
python
|
p02796
|
length = int(input())
target = []
for i in range(length):
s, e = map(int, input().split(" "))
target.append([s, s + e])
target.sort(key = lambda x: x[1])
answer = 0
before_e = float("inf")
# print(target)
for s, e in target:
# print(before_s, before_e, s, e)
if s >= before_e:
# print(1, before_s, before_e, s, e)
answer += 1
else:
before_e = e
print(length - answer)
|
length = int(input())
target = []
for i in range(length):
s, e = map(int, input().split(" "))
target.append([s - e, s + e])
target.sort(key = lambda x: x[1])
answer = 0
before_e = -float("inf")
for s, e in target:
# print(before_e, s, e)
if s < before_e:
answer += 1
else:
before_e = e
print(length - answer)
|
[
"expression.operation.unary.add",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,326
| 601,325
|
u594567187
|
python
|
p02796
|
input = sys.stdin.readline
n = int(input())
robots = []
for i in range(n):
x, l = [int(item) for item in input().split()]
robots.append((x+l, x-l))
robots.sort()
cnt = 0
node = -10**12
for end, start in robots:
if start >= node:
node = end
cnt += 1
print(cnt)
|
import sys
input = sys.stdin.readline
n = int(input())
robots = []
for i in range(n):
x, l = [int(item) for item in input().split()]
robots.append((x+l, x-l))
robots.sort()
cnt = 0
node = -10**12
for end, start in robots:
if start >= node:
node = end
cnt += 1
print(cnt)
|
[] | 601,334
| 601,335
|
u808799019
|
python
|
p02796
|
import sys
input = sys.stdin.readline
N = int(input())
R = []
for i in range(N):
x,l = map(int, input().split())
R.append([max(x-l+1,0),x+l-1])
R.sort(key = lambda r : r[1])
ans = N
lr = -1
for i in range(N):
if(lr >= R[i][0]):
ans -=1
continue
else:
lr = R[i][1]
print(ans)
|
import sys
input = sys.stdin.readline
N = int(input())
R = []
for i in range(N):
x,l = map(int, input().split())
R.append([max(x-l,0),x+l])
R.sort(key = lambda r : r[1])
ans = N
lr = -1
for i in range(N):
if(lr > R[i][0]):
ans -=1
continue
else:
lr = R[i][1]
print(ans)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,339
| 601,340
|
u624696727
|
python
|
p02796
|
import sys
import math
sys.setrecursionlimit(1000000000)
def solve(robots):
total = len(robots)
prev = None
for current in robots:
if prev and prev[0] + prev[1] > current[0] - current[1]:
total -= 1
else:
prev = current
return total
N, = map(int, input().split())
ROBOTS = [list(map(int, input().split())) for _ in range(N)]
ROBOTS = sorted(ROBOTS, key=lambda x: x[0])
print(solve(ROBOTS))
|
import sys
import math
sys.setrecursionlimit(1000000000)
def solve(robots):
total = len(robots)
prev = None
for current in robots:
if prev and prev[0] + prev[1] > current[0] - current[1]:
total -= 1
else:
prev = current
return total
N, = map(int, input().split())
ROBOTS = [list(map(int, input().split())) for _ in range(N)]
ROBOTS = sorted(ROBOTS, key=lambda x: x[0] + x[1])
print(solve(ROBOTS))
|
[
"assignment.change"
] | 601,343
| 601,344
|
u692515710
|
python
|
p02796
|
n=int(input())
lis=[]
for _ in range(n):
x,l=map(int,input().split())
lis.append([x-l,x+l])
lis.sort(key=lambda x:x[0])
count = 0
tmp = - 10 ** 18
for i in lis:
if tmp <= i[0]:
count += 1
tmp = i[1]
print(count)
|
n=int(input())
lis=[]
for _ in range(n):
x,l=map(int,input().split())
lis.append([x-l,x+l])
lis.sort(key=lambda x:x[1])
count = 0
tmp = - 10 ** 18
for i in lis:
if tmp <= i[0]:
count += 1
tmp = i[1]
print(count)
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 601,345
| 601,346
|
u172147273
|
python
|
p02796
|
n=int(input())
lis=[]
for _ in range(n):
x,l=map(int,input().split())
#print(x,l)
lis.append([x-l,x+l])
lis.sort(key=lambda x:x[0])
#print(lis)
count = 0
tmp = - 10 ** 18
for i in lis:
#print(i,i[0],i[1])
if tmp <= i[0]:
count += 1
tmp = i[1]
print(count)
|
n=int(input())
lis=[]
for _ in range(n):
x,l=map(int,input().split())
lis.append([x-l,x+l])
lis.sort(key=lambda x:x[1])
count = 0
tmp = - 10 ** 18
for i in lis:
if tmp <= i[0]:
count += 1
tmp = i[1]
print(count)
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 601,347
| 601,346
|
u172147273
|
python
|
p02796
|
N = int(input())
p = []
for i in range(N):
a,b = map(int,input().split())
p.append([max(0,a - b),a + b])
q = sorted(p,key=lambda x:x[0])
cnt = 0
d = q[0][1]
for j,k in q[1:]:
if j < d:
cnt += 1
else:
d = k
print(N-cnt)
|
N = int(input())
p = []
for i in range(N):
a,b = map(int,input().split())
p.append([max(0,a - b),a + b])
q = sorted(p,key=lambda x:x[1])
cnt = 0
d = q[0][1]
for j,k in q[1:]:
if j < d:
cnt += 1
else:
d = k
print(N-cnt)
|
[
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 601,362
| 601,363
|
u822044226
|
python
|
p02796
|
import sys
input = sys.stdin.readline
N = int(input())
XL = []
for _ in range(N):
tmp = [int(x) for x in input().split()]
XL.append(tmp)
LR = []
for i in XL:
LR.append([i[0] - i[1], i[0] + i[1]])
LR.sort()
ans = N
last = LR[0][1]
for i in range(1, N - 1):
if last > LR[i][0]:
if last > LR[i][1]:
last = LR[i][1]
ans -= 1
else:
last = LR[i][1]
print(ans)
|
import sys
input = sys.stdin.readline
N = int(input())
XL = []
for _ in range(N):
tmp = [int(x) for x in input().split()]
XL.append(tmp)
LR = []
for i in XL:
LR.append([i[0] - i[1], i[0] + i[1]])
LR.sort()
ans = N
last = LR[0][1]
for i in range(1, N):
if last > LR[i][0]:
if last > LR[i][1]:
last = LR[i][1]
ans -= 1
else:
last = LR[i][1]
print(ans)
|
[
"expression.operation.binary.remove"
] | 601,389
| 601,390
|
u609061751
|
python
|
p02796
|
n = int(input())
h = [list(map(int,input().split()))for _ in range(n)]
x = []*n
y = []*2
for i in range(n):
y.append(h[i][0]-h[i][1]) #腕が届く地点の最小値
y.append(h[i][0]+h[i][1]) #腕が届く地点の最大値
x.append(y) #xに保存
y = []*2 #yを初期化
x.sort(key = lambda x:x[1]) #腕が届く地点の最大値が小さい順にソート
for i in range(n-1):
k = 0 #配列xのtale
if x[k][1] > x[k+1][0]: #k番目の最大値よりもk+1の最小値の方が小さい時(つまり腕が重なる時)
x.pop(k+1) #k+1番目を取り出す
else:
k += 1 #taleを一個後ろに下げる
print(len(x)) #要素数(残ったロボットの数)を出力
|
n = int(input())
h = [list(map(int,input().split()))for _ in range(n)]
x = []*n
y = []*2
for i in range(n):
y.append(h[i][0]-h[i][1]) #腕が届く地点の最小値
y.append(h[i][0]+h[i][1]) #腕が届く地点の最大値
x.append(y) #xに保存
y = []*2 #yを初期化
x.sort(key = lambda x:x[1]) #腕が届く地点の最大値が小さい順にソート
k = 0 #配列xのtale
for i in range(n-1):
if x[k][1] > x[k+1][0]: #k番目の最大値よりもk+1の最小値の方が小さい時(つまり腕が重なる時)
x.pop(k+1) #k+1番目を取り出す
else:
k += 1 #taleを一個後ろに下げる
print(len(x)) #要素数(残ったロボットの数)を出力
|
[
"assignment.add",
"assignment.remove"
] | 601,395
| 601,396
|
u053856575
|
python
|
p02796
|
n = int(input())
xl =[]
for i in range(n):
x,l = map(int,input().split())
xl.append([x-l+1,x+l-1])
xl.sort(key=lambda x: x[1])
arm = xl[0][1]
cnt = 1
for i in range(1,n):
x,l = xl[i][0],xl[i][1]
if arm < xl[i][0]:
arm = xl[i][1]
cnt +=1
print(cnt)
|
n = int(input())
xl =[]
for i in range(n):
x,l = map(int,input().split())
xl.append([x-l,x+l])
xl.sort(key=lambda x: x[1])
arm = xl[0][1]
cnt = 1
for i in range(1,n):
x,l = xl[i][0],xl[i][1]
if arm <= xl[i][0]:
arm = xl[i][1]
cnt +=1
print(cnt)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,397
| 601,398
|
u445404615
|
python
|
p02796
|
n = int(input())
scope = []
for _ in range(n):
x, l = map(int, input().split())
scope.append([x+l, x-l])
scope.sort()
ans = 1
border = scope[0][0]
for i, r in enumerate(scope[1:]):
if border <= r[0]:
ans += 1
border = r[1]
print(ans)
|
n = int(input())
scope = []
for _ in range(n):
x, l = map(int, input().split())
scope.append([x+l, x-l])
scope.sort()
ans = 1
border = scope[0][0]
for i, r in enumerate(scope[1:]):
if border <= r[1]:
ans += 1
border = r[0]
print(ans)
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 601,403
| 601,404
|
u950825280
|
python
|
p02796
|
n = int(input())
ls = []
for i in range(n):
x,l = map(int,input().split())
ls.append([x-l,l+x])
ls = sorted(ls, key=lambda x: x[1])
ans = n
print(ls)
for i in range(1,n):
if ls[i][0] < ls[i-1][1]:
ls[i][1] = ls[i-1][1]
ans -=1
print(ans)
|
n = int(input())
ls = []
for i in range(n):
x,l = map(int,input().split())
ls.append([x-l,l+x])
ls = sorted(ls, key=lambda x: x[1])
ans = n
for i in range(1,n):
if ls[i][0] < ls[i-1][1]:
ls[i][1] = ls[i-1][1]
ans -=1
print(ans)
|
[
"call.remove"
] | 601,411
| 601,412
|
u794910686
|
python
|
p02796
|
n = int(input())
machines = []
for i in range(n):
x, l = map(int, input().split())
machines.append([x+l, x-l])
machines.sort()
ans = 1
first = machines.pop(0)
stock_r = first[0]
for r,l in machines:
if stock_r > l:
break
else:
ans += 1
stock_r = r
print(ans)
|
n = int(input())
machines = []
for i in range(n):
x, l = map(int, input().split())
machines.append([x+l, x-l])
machines.sort()
ans = 1
first = machines.pop(0)
stock_r = first[0]
for r,l in machines:
if stock_r > l:
continue
else:
ans += 1
stock_r = r
print(ans)
|
[
"control_flow.break.remove",
"control_flow.continue.add"
] | 601,421
| 601,422
|
u238956837
|
python
|
p02796
|
n = int(input())
machines = []
for i in range(n):
x, l = map(int, input().split())
machines.append([x+l, x-l])
machines.sort()
ans = 1
first = machines.pop(0)
stock_r = first[1]
for r,l in machines:
if stock_r > l:
break
else:
ans += 1
stock_r = r
print(ans)
|
n = int(input())
machines = []
for i in range(n):
x, l = map(int, input().split())
machines.append([x+l, x-l])
machines.sort()
ans = 1
first = machines.pop(0)
stock_r = first[0]
for r,l in machines:
if stock_r > l:
continue
else:
ans += 1
stock_r = r
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"control_flow.break.remove",
"control_flow.continue.add"
] | 601,423
| 601,422
|
u238956837
|
python
|
p02796
|
INF = 2 * (10 ** 9) - 1
n = int(input())
xl = [[0] * 2 for i in range(n)]
for i in range(n) :
x, l = map(int, input().split())
xl[i][0] = x-l+1
xl[i][1] = x+l-1
xl.sort(key=lambda x:x[1])
cnt = 0
#print(xl)
cur = -10 ** 10
ans = 0
for i in range(n) :
if cur <= xl[i][0] :
#print(i)
ans += 1
cur = xl[i][1]
#prinst(xl[i])
print(ans)
|
INF = 2 * (10 ** 9) - 1
n = int(input())
xl = [[0] * 2 for i in range(n)]
for i in range(n) :
x, l = map(int, input().split())
xl[i][0] = x-l+1
xl[i][1] = x+l-1
xl.sort(key=lambda x:x[1])
cnt = 0
#print(xl)
cur = -10 ** 10
ans = 0
for i in range(n) :
if cur+1 < xl[i][0] :
#print(i)
ans += 1
cur = xl[i][1]
#prinst(xl[i])
print(ans)
|
[
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 601,424
| 601,425
|
u438662618
|
python
|
p02796
|
INF = 2 * (10 ** 9) - 1
n = int(input())
xl = [[0] * 2 for i in range(n)]
for i in range(n) :
x, l = map(int, input().split())
xl[i][0] = x-l+1
xl[i][1] = x+l-1
xl.sort(key=lambda x:x[1])
cnt = 0
#print(xl)
cur = -10 ** 10
ans = 0
for i in range(n) :
if cur < xl[i][0] :
#print(i)
ans += 1
cur = xl[i][1]
#prinst(xl[i])
print(ans)
|
INF = 2 * (10 ** 9) - 1
n = int(input())
xl = [[0] * 2 for i in range(n)]
for i in range(n) :
x, l = map(int, input().split())
xl[i][0] = x-l+1
xl[i][1] = x+l-1
xl.sort(key=lambda x:x[1])
cnt = 0
#print(xl)
cur = -10 ** 10
ans = 0
for i in range(n) :
if cur+1 < xl[i][0] :
#print(i)
ans += 1
cur = xl[i][1]
#prinst(xl[i])
print(ans)
|
[
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 601,426
| 601,425
|
u438662618
|
python
|
p02796
|
INF = 2 * (10 ** 9) - 1
n = int(input())
xl = [[0] * 2 for i in range(n)]
for i in range(n) :
x, l = map(int, input().split())
xl[i][0] = x-l+1
xl[i][1] = x+l-1
xl.sort(key=lambda x:x[1])
cnt = 0
#print(xl)
cur = -1
ans = 0
for i in range(n) :
if cur < xl[i][0] :
#print(i)
ans += 1
cur = xl[i][1]
#prinst(xl[i])
print(ans)
|
INF = 2 * (10 ** 9) - 1
n = int(input())
xl = [[0] * 2 for i in range(n)]
for i in range(n) :
x, l = map(int, input().split())
xl[i][0] = x-l+1
xl[i][1] = x+l-1
xl.sort(key=lambda x:x[1])
cnt = 0
#print(xl)
cur = -10 ** 10
ans = 0
for i in range(n) :
if cur+1 < xl[i][0] :
#print(i)
ans += 1
cur = xl[i][1]
#prinst(xl[i])
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 601,427
| 601,425
|
u438662618
|
python
|
p02796
|
INF = 2 * (10 ** 9) - 1
n = int(input())
xl = [[0] * 2 for i in range(n)]
for i in range(n) :
x, l = map(int, input().split())
xl[i][0] = x-l+1
xl[i][1] = x+l-1
xl.sort(key=lambda x:x[1])
cnt = 0
#print(xl)
cur = -10 ** 10
ans = 0
for i in range(n) :
if cur < xl[i][0] :
#print(i)
ans += 1
cur = xl[i][1]
#prinst(xl[i])
print(ans)
|
INF = 2 * (10 ** 9) - 1
n = int(input())
xl = [[0] * 2 for i in range(n)]
for i in range(n) :
x, l = map(int, input().split())
xl[i][0] = x-l
xl[i][1] = x+l
xl.sort(key=lambda x:x[1])
cnt = 0
#print(xl)
cur = -10 ** 10
ans = 0
for i in range(n) :
if cur <= xl[i][0] :
#print(i)
ans += 1
cur = xl[i][1]
#prinst(xl[i])
print(ans)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,426
| 601,428
|
u438662618
|
python
|
p02796
|
def main():
n = int(input())
x = []
xl = {}
tmp = []
ans = 0
maxtmp = 0
for i in range(n):
xx, ll = map(int,input().split())
if maxtmp < xx:
maxtmp = xx
low = xx-ll+1
high = xx+ll-1
lmh = [high,xx,low]
tmp.append(lmh)
tmp.sort()
high = tmp[0][0]
ans = 1
for i in range(1,len(tmp)):
a = tmp[i]
if a[2] > high:
high = a[0]
ans += 1
else:
continue
print(ans)
return
if __name__=='__main__':
main()
|
def main():
n = int(input())
x = []
xl = {}
tmp = []
ans = 0
maxtmp = 0
for i in range(n):
xx, ll = map(int,input().split())
if maxtmp < xx:
maxtmp = xx
low = xx-ll
high = xx+ll
lmh = [high,xx,low]
tmp.append(lmh)
tmp.sort()
high = tmp[0][0]
ans = 1
for i in range(1,len(tmp)):
a = tmp[i]
if a[2] >= high:
high = a[0]
ans += 1
else:
continue
print(ans)
return
if __name__=='__main__':
main()
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,433
| 601,434
|
u321035578
|
python
|
p02796
|
N = int(input())
MAX_list = []
ans = 0
A = -10**9-2
for _ in range(N):
X, L = map(int, input().split())
MAX_list.append(((X + L ), (X - L )))
MAX_list = sorted(MAX_list)
for m, l in MAX_list:
if l > A:
ans += 1
A = m
print(ans)
|
N = int(input())
MAX_list = []
ans = 0
A = -10**9-2
for _ in range(N):
X, L = map(int, input().split())
MAX_list.append(((X + L), (X - L)))
MAX_list = sorted(MAX_list)
for m, l in MAX_list:
if l >= A:
ans += 1
A = m
print(ans)
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,439
| 601,440
|
u185966380
|
python
|
p02796
|
N = int(input())
MAX_list = []
ans = 0
A = -10**9-2
for _ in range(N):
X, L = map(int, input().split())
MAX_list.append(((X + L - 1), (X - L + 1)))
MAX_list = sorted(MAX_list)
for m, l in MAX_list:
if l > A:
ans += 1
A = m
print(ans)
|
N = int(input())
MAX_list = []
ans = 0
A = -10**9-2
for _ in range(N):
X, L = map(int, input().split())
MAX_list.append(((X + L), (X - L)))
MAX_list = sorted(MAX_list)
for m, l in MAX_list:
if l >= A:
ans += 1
A = m
print(ans)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,441
| 601,440
|
u185966380
|
python
|
p02796
|
def acinput():
return list(map(int, input().split(" ")))
N=int(input())
bars=[]
for i in range(N):
tmp = acinput()
tmp.extend([tmp[0]-tmp[1],tmp[0]+tmp[1]])
bars.append(tmp)
bars=sorted(bars,key=lambda x:x[3])
print(bars)
count=0
R=-10000000000
for i in range(0,N):
if R<=bars[i][2]:
R=bars[i][3]
count+=1
print(count)
|
def acinput():
return list(map(int, input().split(" ")))
N=int(input())
bars=[]
for i in range(N):
tmp = acinput()
tmp.extend([tmp[0]-tmp[1],tmp[0]+tmp[1]])
bars.append(tmp)
bars=sorted(bars,key=lambda x:x[3])
#print(bars)
count=0
R=-10000000000
for i in range(0,N):
if R<=bars[i][2]:
R=bars[i][3]
count+=1
print(count)
|
[
"call.remove"
] | 601,449
| 601,450
|
u346308892
|
python
|
p02796
|
N = int(input())
XL = []
for i in range(N):
x,l = map(int,input().split())
XL.append((x-l+1,x+l-1))
XL.sort(key=lambda x: x[1])
ans = 0
t = -10**10
for i in range(N):
if t < XL[i][0]:
ans += 1
t = XL[i][1]
print(ans)
|
N = int(input())
XL = []
for i in range(N):
x,l = map(int,input().split())
XL.append((x-l,x+l-1))
XL.sort(key=lambda x: x[1])
ans = 0
t = -10**10
for i in range(N):
if t < XL[i][0]:
ans += 1
t = XL[i][1]
print(ans)
|
[
"expression.operation.binary.remove"
] | 601,466
| 601,467
|
u032267656
|
python
|
p02796
|
N = int(input())
XL = []
for i in range(N):
x,l = map(int,input().split())
XL.append((x-l+1,x+l-1))
XL.sort(key=lambda x: (x[1]))
ans = 0
t = -10**9
for i in range(N):
if t <= XL[i][0]:
ans += 1
t = XL[i][1]
print(ans)
|
N = int(input())
XL = []
for i in range(N):
x,l = map(int,input().split())
XL.append((x-l,x+l-1))
XL.sort(key=lambda x: x[1])
ans = 0
t = -10**10
for i in range(N):
if t < XL[i][0]:
ans += 1
t = XL[i][1]
print(ans)
|
[
"expression.operation.binary.remove",
"call.arguments.change",
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,468
| 601,467
|
u032267656
|
python
|
p02796
|
# -*- coding: utf-8 -*-
N = int(input())
robot_number = 0
arm_ranges = []
for n in range(N):
[x, l] = [int(i) for i in input().split()]
minimum = x - l
maximum = x + l
arm_ranges.append((maximum, minimum))
# 腕の届く端が小さいもの順にソート
arm_ranges_sorted = sorted(arm_ranges)
(ma, mi) = arm_ranges_sorted[0]
now_max = ma
robot_number += 1
for arm_range in arm_ranges_sorted[1:]:
(ma, mi) = arm_range
if mi >= now_max:
robot_number += 1
print(robot_number)
|
# -*- coding: utf-8 -*-
N = int(input())
robot_number = 0
arm_ranges = []
for n in range(N):
[x, l] = [int(i) for i in input().split()]
minimum = x - l
maximum = x + l
arm_ranges.append((maximum, minimum))
# 腕の届く端が小さいもの順にソート
arm_ranges_sorted = sorted(arm_ranges)
(ma, mi) = arm_ranges_sorted[0]
now_max = ma
robot_number += 1
for arm_range in arm_ranges_sorted[1:]:
(ma, mi) = arm_range
if mi >= now_max:
robot_number += 1
now_max = ma
print(robot_number)
|
[
"assignment.add"
] | 601,472
| 601,471
|
u169501420
|
python
|
p02796
|
import numpy as np
N=int(input())
XL=[]
for i in range(N):
XL.append(list(map(int,list(input().split()))))
XL=np.asarray(XL)
XLs=XL[np.argsort(XL[:,0])]
right=XLs[0][0]+XLs[0][1]
ans=1
for i in range(N-1):
if right-(XLs[i+1][0]+XLs[i+1][1])>0:
right=XLs[i+1][0]+XLs[i+1][1]
elif XLs[i+1][0]-XLs[i+1][1]-right>=0:
ans+=1
right=XLs[i+1][0]-XLs[i+1][1]
print(ans)
|
import numpy as np
N=int(input())
XL=[]
for i in range(N):
XL.append(list(map(int,list(input().split()))))
XL=np.asarray(XL)
XLs=XL[np.argsort(XL[:,0])]
right=XLs[0][0]+XLs[0][1]
ans=1
for i in range(N-1):
if right-(XLs[i+1][0]+XLs[i+1][1])>0:
right=XLs[i+1][0]+XLs[i+1][1]
elif XLs[i+1][0]-XLs[i+1][1]-right>=0:
ans+=1
right=XLs[i+1][0]+XLs[i+1][1]
print(ans)
|
[
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 601,484
| 601,485
|
u193657135
|
python
|
p02796
|
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def s(x): #圧縮
a = []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(map(max,x))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if x[mid] >= n:
rr = mid
else:
ll = mid+1
n = onem()
a = []
b = []
for i in range(n):
x,c = m()
a.append([x-c-1,x+c-1])
b.append([x-c-1,x+c-1])
a.sort(key = lambda x:(x[1]))
b.sort()
aa = []
for i in range(n):
if not aa:
aa.append(a[0])
bbb = a[0][1]
else:
if bbb <= a[i][0]:
aa.append(a[i])
bbb = a[i][1]
else:
continue
print(aa)
print(len(aa))
|
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def s(x): #圧縮
a = []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(map(max,x))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if x[mid] >= n:
rr = mid
else:
ll = mid+1
n = onem()
a = []
b = []
for i in range(n):
x,c = m()
a.append([x-c-1,x+c-1])
b.append([x-c-1,x+c-1])
a.sort(key = lambda x:(x[1]))
b.sort()
aa = []
for i in range(n):
if not aa:
aa.append(a[0])
bbb = a[0][1]
else:
if bbb <= a[i][0]:
aa.append(a[i])
bbb = a[i][1]
else:
continue
print(len(aa))
|
[
"call.remove"
] | 601,496
| 601,497
|
u807772568
|
python
|
p02796
|
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def s(x): #圧縮
a = []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(map(max,x))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if x[mid] >= n:
rr = mid
else:
ll = mid+1
n = onem()
a = []
b = []
for i in range(n):
x,c = m()
a.append([x-c-1,x+c-1])
b.append([x-c-1,x+c-1])
a.sort(key = lambda x:(x[1]))
b.sort()
aa = []
for i in range(n):
if not aa:
aa.append(a[0])
bbb = a[0][1]
else:
if bbb <= a[i][0]:
aa.append(a[i])
bbb = a[0][1]
else:
continue
print(aa)
print(len(aa))
|
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def s(x): #圧縮
a = []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(map(max,x))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if x[mid] >= n:
rr = mid
else:
ll = mid+1
n = onem()
a = []
b = []
for i in range(n):
x,c = m()
a.append([x-c-1,x+c-1])
b.append([x-c-1,x+c-1])
a.sort(key = lambda x:(x[1]))
b.sort()
aa = []
for i in range(n):
if not aa:
aa.append(a[0])
bbb = a[0][1]
else:
if bbb <= a[i][0]:
aa.append(a[i])
bbb = a[i][1]
else:
continue
print(len(aa))
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.remove"
] | 601,498
| 601,497
|
u807772568
|
python
|
p02796
|
N = int(input())
arr = [list(map(int,input().split())) for i in range(N)]
arr = sorted(arr, key=lambda x: x[0])
F = [True]*N
P = [0]*N
for i in range(N):
P[i] = [arr[i][0]-arr[i][1], arr[i][0]+arr[i][1]]
P = sorted(P,key=lambda x:x[1])
ind = 0
for i in range(1,N):
if P[i][0] < P[ind][1]:
F[i] = False
else:
ind += 1
print(F.count(True))
|
N = int(input())
arr = [list(map(int,input().split())) for i in range(N)]
arr = sorted(arr, key=lambda x: x[0])
F = [True]*N
P = [0]*N
for i in range(N):
P[i] = [arr[i][0]-arr[i][1], arr[i][0]+arr[i][1]]
P = sorted(P,key=lambda x:x[1])
ind = 0
for i in range(1,N):
if P[i][0] < P[ind][1]:
F[i] = False
else:
ind = i
print(F.count(True))
|
[] | 601,516
| 601,517
|
u957872856
|
python
|
p02796
|
from itertools import groupby
from operator import itemgetter
import numpy as np
N = int(input())
arm = []
for i in range(N):
x, l = map(int, input().split())
a = [x-l+1, x+l-1]
arm.append(a)
arm = sorted(arm, key=lambda x: x[1])
now = arm[0][1]
count = 1
for i in range(1,N):
if now < arm[i][0]:
count += 1
now = arm[i][1]
print(count)
|
from itertools import groupby
from operator import itemgetter
import numpy as np
N = int(input())
arm = []
for i in range(N):
x, l = map(int, input().split())
a = [x-l, x+l]
arm.append(a)
arm = sorted(arm, key=lambda x: x[1])
now = arm[0][1]
count = 1
for i in range(1,N):
if now <= arm[i][0]:
count += 1
now = arm[i][1]
print(count)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,526
| 601,527
|
u025287757
|
python
|
p02796
|
from operator import itemgetter
N= int(input())
ans = 1
a = []
for i in range(N):
tmpa, tmpb = map(int,input().split())
a.append([tmpa+tmpb, tmpa-tmpb])
a.sort()
tmp = a[0][1]
for i in range(1, N):
if a[i][0] >= tmp:
ans += 1
tmp = a[i][1]
print(ans)
|
from operator import itemgetter
N= int(input())
ans = 1
a = []
for i in range(N):
tmpa, tmpb = map(int,input().split())
a.append([tmpa+tmpb, tmpa-tmpb])
a.sort()
tmp = a[0][0]
for i in range(1, N):
if a[i][1] >= tmp:
ans += 1
tmp = a[i][0]
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 601,531
| 601,532
|
u143903328
|
python
|
p02796
|
N = int(input())
XL = []
for i in range(N):
tmp = list(map(int, input().split()))
XL.append(tmp)
XL = sorted(XL, key=lambda x:x[0])
i = 0
now = 0
count = 0
while i <= len(XL)-2:
now_arm = XL[now][0] + XL[now][1]
if now_arm > XL[i+1][0] - XL[i+1][1]:
count += 1
if XL[i+1][0] + XL[i+1][0] < now_arm:
now = i+1
else:
pass
else:
now = i+1
i += 1
#print(XL)
print(len(XL) - count)
|
N = int(input())
XL = []
for i in range(N):
tmp = list(map(int, input().split()))
XL.append(tmp)
XL = sorted(XL, key=lambda x:x[0])
i = 0
now = 0
count = 0
while i <= len(XL)-2:
now_arm = XL[now][0] + XL[now][1]
if now_arm > XL[i+1][0] - XL[i+1][1]:
count += 1
if XL[i+1][0] + XL[i+1][1] < now_arm:
now = i+1
else:
pass
else:
now = i+1
i += 1
#print(XL)
print(len(XL) - count)
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 601,539
| 601,540
|
u572193732
|
python
|
p02796
|
N = int(input())
XL = []
for i in range(N):
tmp = list(map(int, input().split()))
XL.append(tmp)
XL = sorted(XL, key=lambda x:x[0])
i = 0
now = 0
count = 0
while i <= len(XL)-2:
now_arm = XL[now][0] + XL[now][1]
if now_arm > XL[i+1][0] - XL[i+1][1]:
count += 1
if XL[i+1][0] + XL[i+1][0] < now_arm:
now = i
else:
pass
else:
now = i
i += 1
#print(XL)
print(len(XL) - count)
|
N = int(input())
XL = []
for i in range(N):
tmp = list(map(int, input().split()))
XL.append(tmp)
XL = sorted(XL, key=lambda x:x[0])
i = 0
now = 0
count = 0
while i <= len(XL)-2:
now_arm = XL[now][0] + XL[now][1]
if now_arm > XL[i+1][0] - XL[i+1][1]:
count += 1
if XL[i+1][0] + XL[i+1][1] < now_arm:
now = i+1
else:
pass
else:
now = i+1
i += 1
#print(XL)
print(len(XL) - count)
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 601,541
| 601,540
|
u572193732
|
python
|
p02796
|
import sys
input = sys.stdin.readline
N = int(input())
start = []
end = []
itv = []
for i in range(N):
X, L = (int(i) for i in input().split())
itv.append([X+L-1, X-L+1])
#start.append(X-L)
#end.append(X+L)
#XL = [[int(i) for i in input().split()] for i in range(N)]
#line = [0] * (2*(10**9) +1)
itv.sort()
#print(itv)
ass = 0
tt = 0-10**9
for i in range(N):
if tt < itv[i][1]:
ass += 1
tt = itv[i][0]
print(ass)
|
import sys
input = sys.stdin.readline
N = int(input())
start = []
end = []
itv = []
for i in range(N):
X, L = (int(i) for i in input().split())
itv.append([X+L, X-L])
#start.append(X-L)
#end.append(X+L)
#XL = [[int(i) for i in input().split()] for i in range(N)]
#line = [0] * (2*(10**9) +1)
itv.sort()
#print(itv)
ass = 0
tt = 0-10**9
for i in range(N):
if tt <= itv[i][1]:
ass += 1
tt = itv[i][0]
print(ass)
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,544
| 601,545
|
u077141270
|
python
|
p02796
|
N = int(input())
li = []
for i in range(N):
hontai, ude = map(int, input().split())
li.append([hontai, ude, hontai-ude, hontai+ude])
li.sort(key=lambda x:x[3])
#print(li)
count = 1
now = li[0][3]
for i in range(1, N):
if now <= li[i][2]:
count += 1
now = li[i][2]
#print(now, count)
print(count)
|
N = int(input())
li = []
for i in range(N):
hontai, ude = map(int, input().split())
li.append([hontai, ude, hontai-ude, hontai+ude])
li.sort(key=lambda x:x[3])
#print(li)
count = 1
now = li[0][3]
for i in range(1, N):
if now <= li[i][2]:
count += 1
now = li[i][3]
#print(now, count)
print(count)
|
[
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 601,552
| 601,553
|
u133566678
|
python
|
p02796
|
# -*- coding: utf-8 -*-
def main():
n = int(input())
y = list()
for i in range(n):
xi, li = map(int, input().split())
y.append((xi - li + 1, xi + li - 1))
count = 1
sorted_y = sorted(y, key=lambda x: x[1])
end_point = sorted_y[0][1]
for left, right in sorted_y[1:]:
if left > end_point:
end_point = right
count += 1
print(count)
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
def main():
n = int(input())
y = list()
for i in range(n):
xi, li = map(int, input().split())
# y.append((xi - li + 1, xi + li - 1))
y.append((xi - li, xi + li))
count = 1
sorted_y = sorted(y, key=lambda x: x[1])
end_point = sorted_y[0][1]
for left, right in sorted_y[1:]:
if left >= end_point:
end_point = right
count += 1
print(count)
if __name__ == '__main__':
main()
|
[
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 601,598
| 601,599
|
u226108478
|
python
|
p02796
|
import sys
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
N=int(input())
l=[]
for i in range(N):
a,b=map(int,input().split())
st,fin=(a-b,a+b)
l.append([fin,st])
list=sorted(l)
pt=list[0][0]
cnt=1
print(list)
for j in range(1,N):
if pt<= list[j][1]:
cnt+=1
pt=list[j][0]
print(cnt)
|
import sys
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
N=int(input())
l=[]
for i in range(N):
a,b=map(int,input().split())
st,fin=(a-b,a+b)
l.append([fin,st])
list=sorted(l)
pt=list[0][0]
cnt=1
for j in range(1,N):
if pt<= list[j][1]:
cnt+=1
pt=list[j][0]
print(cnt)
|
[
"call.remove"
] | 601,600
| 601,601
|
u474925961
|
python
|
p02796
|
import sys
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
N=int(input())
l=[]
for i in range(N):
a,b=map(int,input().split())
st,fin=(a-b,a+b)
l.append([fin,st])
list=sorted(l)
pt=list[0][1]
cnt=1
for j in range(1,N):
if pt<= list[j][1]:
cnt+=1
pt=list[j][0]
print(cnt)
|
import sys
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
N=int(input())
l=[]
for i in range(N):
a,b=map(int,input().split())
st,fin=(a-b,a+b)
l.append([fin,st])
list=sorted(l)
pt=list[0][0]
cnt=1
for j in range(1,N):
if pt<= list[j][1]:
cnt+=1
pt=list[j][0]
print(cnt)
|
[
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 601,602
| 601,601
|
u474925961
|
python
|
p02796
|
n=int(input())
AB=[]
for i in range(n):
x,l=map(int,input().split())
a=x-l
b=x+l
AB.append((a,b))
cnt=1
AB.sort(key=lambda L:L[1], reverse=True)
simekiri=AB[0][0]
for i in range(1,n):
migi=AB[i][1]
hidari=AB[i][0]
if migi<=simekiri:
cnt+=1
simekiri=hidari
print(cnt)
|
n=int(input())
AB=[]
for i in range(n):
x,l=map(int,input().split())
a=x-l
b=x+l
AB.append((a,b))
cnt=1
AB.sort(key=lambda L:L[0],reverse=True)
simekiri=AB[0][0]
for i in range(1,n):
migi=AB[i][1]
hidari=AB[i][0]
if migi<=simekiri:
cnt+=1
simekiri=hidari
print(cnt)
|
[
"literal.number.integer.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 601,603
| 601,604
|
u994521204
|
python
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.