A sequence $(b_1, b_2, \ldots, b_k)$ is called strange, if the absolute difference between any pair of its elements is greater than or equal to the maximum element in the sequence. Formally speaking, it's strange if for every pair $(i, j)$ with $1 \le i<j \le k$, we have $|a_i-a_j|\geq MAX$, where $MAX$ is the largest element of the sequence. In particular, any sequence of length at most $1$ is strange.

For example, the sequences $(-2021, -1, -1, -1)$ and $(-1, 0, 1)$ are strange, but $(3, 0, 1)$ is not, because $|0 - 1| < 3$.

Sifid has an array $a$ of $n$ integers. Sifid likes everything big, so among all the strange subsequences of $a$, he wants to find the length of the longest one. Can you help him?

A sequence $c$ is a subsequence of an array $d$ if $c$ can be obtained from $d$ by deletion of several (possibly, zero or all) elements.


-----Input-----

The first line contains an integer $t$ $(1\le t\le 10^4)$ — the number of test cases. The description of the test cases follows.

The first line of each test case contains an integer $n$ $(1\le n\le 10^5)$ — the length of the array $a$.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ $(-10^9\le a_i \le 10^9)$ — the elements of the array $a$.

It is guaranteed that the sum of $n$ over all test cases doesn't exceed $10^5$.


-----Output-----

For each test case output a single integer — the length of the longest strange subsequence of $a$.


-----Examples-----

Input
6
4
-1 -2 0 0
7
-3 4 -2 0 -4 6 1
5
0 5 -3 2 -5
3
2 3 1
4
-3 0 2 0
6
-3 -2 -1 1 1 1
Output
4
5
4
1
3
4


-----Note-----

In the first test case, one of the longest strange subsequences is $(a_1, a_2, a_3, a_4)$

In the second test case, one of the longest strange subsequences is $(a_1, a_3, a_4, a_5, a_7)$.

In the third test case, one of the longest strange subsequences is $(a_1, a_3, a_4, a_5)$.

In the fourth test case, one of the longest strange subsequences is $(a_2)$.

In the fifth test case, one of the longest strange subsequences is $(a_1, a_2, a_4)$.

Difficulty: EASY
Tags: Sorting

Mathematics

Greedy algorithms
Skill types: Sorting

Greedy algorithms

Starter code:

Solutions:
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	(p, q) = (float('-inf'), float('inf'))
	i = 1
	while i < n:
		p = max(p, a[i])
		q = min(abs(a[i] - a[i - 1]), q)
		if p > q:
			break
		i += 1
	print(i)


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	ans = 0
	dif = 10 ** 10
	mark = None
	for (i, aa) in enumerate(a):
		if aa <= 0:
			ans += 1
		else:
			mark = aa
			break
		if i:
			dif = min(dif, a[i] - a[i - 1])
	if not mark is None:
		if dif >= mark:
			ans += 1
	print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	a = sorted([int(x) for x in input().split()])
	dis = 10 ** 10
	for i in range(1, n):
		dis = min(dis, a[i] - a[i - 1])
		if a[i] > 0:
			print(i + 1 if a[i] <= dis else i)
			break
	else:
		print(n)


from sys import stdin as sin

def aint():
	return int(input())

def amap():
	return map(int, sin.readline().split())

def alist():
	return list(map(int, sin.readline().split()))

def astr():
	return input()
for _ in range(aint()):
	n = aint()
	l = alist()
	l.sort()
	m = float('inf')
	ans = 1
	for i in range(n - 1):
		if l[i] <= 0 and l[i + 1] <= 0:
			ans += 1
			m = min(m, abs(l[i + 1] - l[i]))
		elif l[i] <= 0 and l[i + 1] > 0 and (l[i + 1] <= m):
			ans += 1
			m = min(m, abs(l[i + 1] - l[i]))
		else:
			break
	print(ans)


for _ in range(int(input())):
	N = int(input())
	arr = list(map(int, input().split()))
	L = 0
	pos = float('inf')
	pf = False
	neg = set()
	nL = 0
	zero = 0
	temp = []
	mD = float('inf')
	arr.sort()
	for i in range(len(arr)):
		if arr[i] < 0:
			neg.add(arr[i])
			nL += 1
			temp.append(arr[i])
		elif arr[i] == 0:
			zero += 1
			temp.append(arr[i])
		else:
			pf = True
			pos = min(pos, arr[i])
	for i in range(1, len(temp)):
		mD = min(mD, abs(temp[i] - temp[i - 1]))
	if nL == 0:
		L = zero
	else:
		L = nL + zero
	if mD >= pos and zero < 2 and (pf == True):
		L += 1
	print(L)


def main():
	import sys
	n = int(sys.stdin.readline())
	b = int(sys.stdin.readline())
	lines = sys.stdin.readlines()
	for i in range(0, len(lines), 2):
		x = [int(a) for a in lines[i].split()]
		neg = [a for a in x if a <= 0]
		pos = [a for a in x if a > 0]
		neg = list(sorted(neg))
		o = len(neg) + 1
		if len(pos) == 0:
			o = len(neg)
		else:
			min_element = min(pos)
			for j in range(len(neg) - 1):
				if neg[j + 1] - neg[j] < min_element:
					o = len(neg)
		sys.stdout.write(str(o) + '\n')
main()


import sys
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	c = 0
	mindiff = sys.maxsize - 1
	mini = sys.maxsize
	for i in range(len(l)):
		if l[i] <= 0:
			c += 1
		else:
			mini = min(mini, l[i])
	l.sort()
	for i in range(1, n):
		if l[i] <= 0:
			mindiff = min(mindiff, l[i] - l[i - 1])
	if mindiff >= mini:
		c += 1
	print(c)


def res(m):
	ans = 0
	for i in range(1, n):
		m = min(m, a[i] - a[i - 1])
		if a[i] <= m:
			ans += 1
		else:
			break
	print(ans + 1)
for t in range(int(input())):
	n = int(input())
	a = sorted(list(map(int, input().split())))
	m = a[-1]
	res(m)


t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split(' ')))
	c = 0
	b = []
	for i in range(n):
		if a[i] <= 0:
			c += 1
			b.append(a[i])
	b.sort()
	mindiff = 10 ** 20
	for i in range(len(b) - 1):
		if abs(b[i] - b[i + 1]) < mindiff:
			mindiff = abs(b[i] - b[i + 1])
	for i in range(n):
		if a[i] > 0 and mindiff >= a[i]:
			c += 1
			break
	print(c)


t = int(input())
out = []
for i in range(t):
	n = int(input())
	l = list(map(int, input().split(' ')))
	min_pos = -1
	neg_list = []
	diff = -1
	count = 0
	for j in l:
		if j <= 0:
			neg_list.append(j)
			count += 1
		elif j > 0:
			if min_pos == -1 or min_pos > j:
				min_pos = j
	neg_list.sort()
	for j in range(len(neg_list) - 1):
		if diff == -1 or diff > abs(neg_list[j] - neg_list[j + 1]):
			diff = abs(neg_list[j] - neg_list[j + 1])
	if min_pos != -1 and (diff == -1 or diff >= min_pos):
		count += 1
	out.append(count)
for i in range(len(out)):
	print(out[i])


for _ in range(int(input())):
	n = int(input())
	arr = sorted(list(map(int, input().split())))
	m = arr[-1]
	if n == 1:
		print(1)
	else:
		i = 1
		while i < n:
			m = min(m, arr[i] - arr[i - 1])
			if m < arr[i]:
				break
			i += 1
		print(i)


from sys import stdin
T = int(stdin.readline())
while T:
	n = int(stdin.readline())
	l = list(map(int, stdin.readline().split()))
	p = 0
	ne = 0
	z = 0
	pa = []
	na = []
	for i in range(n):
		if l[i] > 0:
			p += 1
			pa.append(l[i])
		elif l[i] == 0:
			z += 1
		else:
			ne += 1
			na.append(l[i])
	if z > 0:
		na.append(0)
	na = sorted(na)
	diff = []
	for i in range(len(na) - 1):
		diff.append(abs(na[i + 1] - na[i]))
	a1 = ne + z
	a2 = 1
	try:
		if min(diff) >= min(pa):
			a2 = ne + min(1, p) + min(1, z)
	except:
		a2 = 1
	if ne == 0:
		a2 = max(a2, min(1, p) + min(1, z))
	elif ne == 1:
		a2 = max(a2, min(1, ne) + min(1, p))
	print(max(a1, a2))
	T -= 1


from collections import defaultdict as df
from collections import deque as dq
import sys
from math import gcd
from math import factorial as fa
import bisect
from heapq import heappush, heappop
input = lambda : sys.stdin.readline().rstrip()
t = int(input())
mod = pow(10, 9) + 7
for _ in range(t):
	n = int(input().rstrip())
	arr = [int(i) for i in input().split()]
	cnt = df(int)
	ans = 0
	for i in arr:
		cnt[i] += 1
	neg = []
	for i in arr:
		if i < 0:
			neg.append(i)
	pos = []
	for i in arr:
		if i > 0:
			pos.append(i)
	if neg == []:
		if cnt[0] >= 1 and len(pos) >= 1:
			print(max(cnt[0], 2))
		else:
			print(max(cnt[0], 1))
	elif pos == []:
		print(len(neg) + cnt[0])
	else:
		neg.sort()
		pos.sort()
		min_interval = 10000000000000
		for i in range(1, len(neg)):
			min_interval = min(min_interval, abs(neg[i] - neg[i - 1]))
		if cnt[0] == 0:
			if len(neg) <= 1:
				print(2)
			elif min_interval >= pos[0]:
				print(len(neg) + 1)
			else:
				print(len(neg))
		elif cnt[0] > 1:
			print(len(neg) + cnt[0])
		elif len(neg) <= 1:
			if abs(neg[-1]) >= pos[0]:
				print(3)
			else:
				print(2)
		elif min_interval >= pos[0]:
			print(len(neg) + 2)
		else:
			print(len(neg) + 1)


def solve(numbers):
	if len(numbers) == 1:
		return 1
	numbers_pos = [x for x in numbers if x > 0]
	if len(numbers_pos) == 0:
		return len(numbers)
	res = len(numbers) - len(numbers_pos)
	min_pos = min(numbers_pos)
	numbers_rest = [x for x in numbers if x < min_pos] + [min_pos]
	numbers_rest.sort()
	diff = [0] * (len(numbers_rest) - 1)
	for i in range(len(numbers_rest) - 1):
		diff[i] = abs(numbers_rest[i + 1] - numbers_rest[i])
	if len(diff) == 0 or min(diff) >= min_pos:
		return res + 1
	else:
		return res
T = int(input())
for t in range(T):
	N = int(input())
	numbers = [int(x) for x in input().split(' ')]
	res = solve(numbers)
	print(res, flush=True)


import math
t = int(input())

def solve(a):
	a.sort()
	L = len(a)
	if a[0] > 0 or L == 1:
		return 1
	min_diff = math.inf
	idx = 1
	while idx < L and a[idx] <= 0:
		curr = a[idx] - a[idx - 1]
		if min_diff > curr:
			min_diff = curr
		idx += 1
	if idx < L:
		return idx if min_diff < a[idx] else idx + 1
	return idx
for test in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	print(solve(a))


t = int(input())
sizes = []
nums = []
for i in range(t):
	size = int(input())
	l = list(map(int, input().split()))
	sizes.append(size)
	nums.append(l)
for i in range(t):
	flag = 0
	currentArr = nums[i]
	currentArr.sort()
	right = sizes[i] - 1
	for left in range(sizes[i] - 1):
		minDiff = abs(currentArr[left] - currentArr[left + 1])
		while right > left and currentArr[right] > minDiff:
			right -= 1
		if left == right:
			flag = 1
			break
	if flag:
		print(left + 1)
	else:
		print(sizes[i])


def Solve():
	for t in range(int(input())):
		n = int(input())
		l = sorted(list(map(int, input().split())))
		p = 99999999999999999
		k = 0
		for i in range(1, n):
			x = l[i - 1]
			y = l[i]
			if y - x < y or y > p:
				break
			else:
				p = min(p, y - x)
				k += 1
		print(k + 1)
Solve()


t = int(input())
for _ in range(t):
	n = int(input())
	a = sorted(map(int, input().split()))
	k = 0
	p = -10000000000000
	m_dif = 1000000000000
	for x in a:
		if x > 0:
			break
		k += 1
		m_dif = min(m_dif, x - p)
		p = x
	if k < n and m_dif >= a[k]:
		k += 1
	print(max(k, 1))


T = int(input())
while T:
	T -= 1
	n = int(input())
	s = list(map(int, input().split()))
	s.sort()
	cnt = 0
	p = -1
	for i in range(n):
		if s[i] <= 0:
			cnt += 1
		else:
			p = i
			break
	if p != -1:
		tag = True
		for i in range(p):
			if s[i + 1] - s[i] < s[p]:
				tag = False
		if tag:
			cnt += 1
	print(max(1, cnt))


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l.sort()
	x = float('inf')
	for i in range(n - 1):
		x = min(x, l[i + 1] - l[i])
		if l[i + 1] > x:
			print(i + 1)
			break
	else:
		print(n)


for s in [*open(0)][2::2]:
	a = sorted(map(int, s.split()))
	m = 1000000000.0
	i = 1
	for (x, y) in zip(a, a[1:]):
		m = min(m, y - x)
		i += m >= y
	print(i)


t = int(input())
temp1 = []
temp2 = []

def reg(a):
	a.sort()
	negatives = [item for item in a if item <= 0]
	positives = [item for item in a if item > 0]
	if len(positives) != 0:
		num = positives[0]
		negatives.append(num)
	return negatives

def isStrange(a):
	a = reg(a)
	i = 0
	n = len(a) - 1
	maxx = max(a)
	if a[-1] == 0:
		print(len(a))
	else:
		while i < n:
			if abs(a[i] - a[i + 1]) < maxx:
				a.remove(max(a))
				break
			i = i + 1
		print(len(a))
for f in range(t):
	n = int(input())
	temp1 = [int(x) for x in input().split()]
	isStrange(temp1)


import sys
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7

def solve():

	def II():
		return int(sys.stdin.readline())

	def LI():
		return list(map(int, sys.stdin.readline().split()))

	def LC():
		return list(input())

	def IC():
		return [int(c) for c in input()]

	def MI():
		return map(int, sys.stdin.readline().split())
	T = II()
	for t in range(T):
		N = II()
		A = LI()
		A.sort()
		Minabs = INF
		MAX = A[0]
		Ans = 1
		for n in range(1, N):
			if Minabs > abs(A[n] - A[n - 1]):
				Minabs = abs(A[n] - A[n - 1])
			MAX = A[n]
			if Minabs >= MAX:
				Ans += 1
		print(Ans)
	return
solve()


t = int(input())
for _ in range(t):
	n = int(input())
	a = list((int(x) for x in input().split()))
	neg = [x for x in a if x <= 0]
	pos = [x for x in a if x > 0]
	neg.sort()
	ans = len(neg)
	if len(pos) > 0:
		ans += 1
		r = min(pos)
		for i in range(len(neg) - 1):
			if neg[i + 1] - neg[i] < r:
				ans -= 1
				break
	print(ans)


import sys
MOD = 1000000007
inp = sys.stdin.readline

def ii():
	return int(inp())

def iis():
	return [int(i) for i in inp().split()]
t = ii()
for _ in range(t):
	n = ii()
	a = iis()
	a.sort()
	MAX = float('-inf')
	min_diff = float('inf')
	i = 1
	while i < n:
		MAX = max(a[i], MAX)
		min_diff = min(min_diff, a[i] - a[i - 1])
		if min_diff < MAX:
			break
		i += 1
	print(i)


def main():
	n = int(input())
	arr = list(map(int, input().split()))
	arr.sort()
	fpos = False
	f1 = 0
	x = 0
	for i in range(n):
		if arr[i] > 0:
			fpos = True
			f1 = arr[i]
			break
		x += 1
	if fpos == False:
		print(n)
		return
	maxi = x
	pre = arr[0]
	ans = 1
	if x:
		ans += 1
	for i in range(1, x):
		if abs(arr[i] - pre) >= f1:
			ans += 1
			pre = arr[i]
	maxi = max(maxi, ans)
	print(maxi)
t = int(input())
for i in range(t):
	main()


from sys import stdin, stdout
from collections import defaultdict
import math
import bisect
t = int(input())
for i in range(t):
	n = int(input())
	l = [int(x) for x in stdin.readline().split()]
	c = 0
	m = 1000000007
	l1 = []
	for i in l:
		if i > 0:
			c += 1
			m = min(m, i)
	l1.append(n - c)
	l = [x for x in l if x <= m]
	mi = min(l)
	l.sort()
	v = 0
	for i in range(0, len(l) - 1):
		if abs(l[i] - l[i + 1]) >= m:
			v += 1
	v += 1
	l1.append(v)
	print(max(l1))


T = int(input())
for t in range(T):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	i = 0
	while i < n and a[i] <= 0:
		i += 1
	if i == n:
		print(n)
		continue
	for j in range(1, i):
		if a[j] - a[j - 1] < a[i]:
			i -= 1
			break
	print(i + 1)


import sys
for _ in range(int(sys.stdin.readline())):
	n = int(sys.stdin.readline())
	data = list(map(int, sys.stdin.readline().split()))
	data.sort()
	(ans, diff) = ([data[0]], float('inf'))
	for i in range(1, len(data)):
		diff = min(diff, abs(ans[-1] - data[i]))
		if data[i] > diff:
			break
		ans.append(data[i])
	print(len(ans))


from collections import defaultdict, deque
from heapq import heappush, heappop
from math import inf
ri = lambda : map(int, input().split())
ro = lambda : int(input())

def solve():
	n = ro()
	A = list(ri())
	A.sort()
	ans = 0
	mn = inf
	for x in A:
		if x <= 0:
			ans += 1
		else:
			mn = x
			break
	good = True
	for i in range(1, n):
		if A[i] <= 0:
			if A[i] - A[i - 1] < mn:
				good = False
				break
	if mn != inf and good:
		ans += 1
	print(ans)
t = 1
t = int(input())
while t:
	t -= 1
	solve()


t = int(input())
for t in range(t):
	q = int(input())
	lst = list(map(int, input().split()))
	lst.sort()
	j = 0
	if q <= 1:
		print(1)
	else:
		max1 = lst[-1]
		for i in range(1, len(lst)):
			if max1 > lst[i] - lst[i - 1]:
				max1 = lst[i] - lst[i - 1]
			if max1 >= lst[i]:
				j += 1
			else:
				break
		print(j + 1)


for __ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l.sort(reverse=True)
	c = 0
	j = 0
	ans = 1
	i = 1
	while i < n:
		d = abs(l[i - 1] - l[i])
		while d < l[j] and j < i:
			j += 1
			d = abs(l[i - 1] - l[i])
		if d >= l[j]:
			ans = max(ans, i - j + 1)
		i += 1
	print(ans)


from sys import stdin

def main():
	input = lambda : stdin.readline()[:-1]
	T = int(input())
	for _ in [0] * T:
		N = int(input())
		A = map(int, input().split())
		(a, b) = ([], [])
		for ai in A:
			if ai <= 0:
				a.append(ai)
			else:
				b.append(ai)
		if not a or N == 1:
			print(1)
			continue
		if len(a) == 1:
			print(2)
			continue
		a.sort()
		ans = len(a)
		d = float('inf')
		for i in range(1, ans):
			d = min(d, a[i] - a[i - 1])
		for bi in b:
			if bi <= d:
				print(ans + 1)
				break
		else:
			print(ans)
main()


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	arr.sort()
	neg = []
	pos = []
	for i in arr:
		if i <= 0:
			neg.append(i)
		else:
			pos.append(i)
			break
	if len(pos) > 0:
		mx = pos[0]
		flag = False
		for i in range(len(neg) - 1):
			if abs(arr[i] - arr[i + 1]) < mx:
				flag = True
				break
		if flag:
			print(len(neg))
		else:
			print(len(neg) + 1)
	else:
		print(len(neg))


import os
import sys
from io import BytesIO, IOBase
from bisect import bisect_left, bisect_right
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def scanf(datatype=str):
	return datatype(sys.stdin.readline().rstrip())

def printf(answer=''):
	return sys.stdout.write(str(answer) + '\n')

def prints(answer):
	return sys.stdout.write(str(answer) + ' ')

def map_input(datatype=str):
	return map(datatype, sys.stdin.readline().split())

def list_input(datatype=str):
	return list(map(datatype, sys.stdin.readline().split()))

def testcase(number: int, solve_function):
	for _ in range(number):
		printf(solve_function())

def solve():
	n = scanf(int)
	arr = list_input(int)
	mini = sys.maxsize
	count = 0
	for i in arr:
		if i <= 0:
			count += 1
		else:
			mini = min(mini, i)
	arr.sort()
	mindiff = sys.maxsize - 1
	for i in range(n - 1):
		if arr[i + 1] <= 0:
			mindiff = min(mindiff, arr[i + 1] - arr[i])
	ans = count
	if mindiff >= mini:
		ans += 1
	return ans
t = scanf(int)
testcase(t, solve)


t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	if a[0] > 0:
		print(1)
		continue
	ans = 0
	for i in a:
		if i <= 0:
			ans += 1
	a.sort()
	mn = 1000000002
	for i in a:
		if i > 0:
			mn = min(mn, i)
	if mn < 1000000002:
		flag = 1
	else:
		flag = 0
	for i in range(1, n):
		if a[i] <= 0:
			if flag == 1 and a[i] - a[i - 1] >= mn:
				flag = 1
			elif flag == 1 and a[i] - a[i - 1] < mn:
				flag = 0
	if flag == 1:
		print(ans + 1)
	else:
		print(max(ans, 1))


from sys import stdin, stdout
from collections import defaultdict as dd
from collections import deque
from math import gcd, ceil, comb, perm
input = stdin.readline
flush = stdout.flush
tc = 1
tc = int(input())
for _ in range(tc):
	n = int(input())
	l = list(map(int, input().split()))
	l.sort()
	(neg, zero, pos) = (0, 0, 0)
	maxneg = float('-inf')
	for i in l:
		if i > 0:
			pos += 1
		elif i < 0:
			neg += 1
		else:
			zero += 1
	ans1 = neg + zero
	mn = float('inf')
	i = 1
	while i < n and l[i] <= 0:
		mn = min(mn, abs(l[i] - l[i - 1]))
		i += 1
	if i == n:
		print(max(ans1, 1))
		continue
	if mn >= l[i]:
		print(ans1 + 1)
		continue
	print(max(1, ans1))


from sys import stdin
input = stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	a.sort()
	c = 0
	d = float('inf')
	f = False
	for i in range(n):
		if a[i] > 0:
			if a[i] <= d:
				f = True
				break
		else:
			c += 1
			if i == 0:
				continue
			d = min(d, abs(a[i] - a[i - 1]))
	ans = c + f
	print(ans)


def solve(n, a):
	neg = []
	pos = []
	for i in range(n):
		if a[i] <= 0:
			neg.append(a[i])
		else:
			pos.append(a[i])
	if not neg:
		return 1
	mini = 10 ** 10
	for i in range(1, len(neg)):
		mini = min(mini, abs(neg[i] - neg[i - 1]))
	ans = len(neg)
	for i in pos:
		if i <= mini:
			ans += 1
			break
	return ans
for _ in range(int(input())):
	n = int(input())
	a = sorted(list(map(int, input().split())))
	print(solve(n, a))


from sys import stdin
t = int(stdin.readline())
for e in range(t):
	n = int(stdin.readline())
	l = stdin.readline().split()
	p = 0
	ne = 0
	z = 0
	pa = []
	na = []
	for i in range(n):
		l[i] = int(l[i])
		if l[i] > 0:
			p += 1
			pa.append(l[i])
		elif l[i] == 0:
			z += 1
		else:
			ne += 1
			na.append(l[i])
	if z > 0:
		na.append(0)
	na.sort()
	d = []
	for i in range(len(na) - 1):
		d.append(abs(na[i + 1] - na[i]))
	a1 = ne + z
	a2 = 0
	try:
		if min(d) >= min(pa):
			a2 = ne + min(1, p) + min(1, z)
	except:
		pass
	if ne == 0:
		a2 = max(a2, min(1, p) + min(1, z))
	elif ne == 1:
		a2 = max(a2, min(1, ne) + min(1, p))
	print(max(a1, a2, 1))


from collections import defaultdict
from functools import reduce
from bisect import bisect_right
from bisect import bisect_left
import copy

def main():
	for _ in range(int(input())):
		n = int(input())
		l = list(map(int, input().split()))
		l.sort()
		p = 2 * 10 ** 9 + 7
		c = 1
		m = 1
		if l[0] > 0:
			print(1)
			continue
		for i in range(1, n):
			if l[i] <= 0:
				p = min(p, abs(l[i] - l[i - 1]))
				c += 1
			else:
				m = 0
				break
		if m:
			print(n)
		elif l[i] <= p:
			print(c + 1)
		else:
			print(c)

def primes1(n):
	sieve = [True] * (n // 2)
	for i in range(3, int(n ** 0.5) + 1, 2):
		if sieve[i // 2]:
			sieve[i * i // 2::i] = [False] * ((n - i * i - 1) // (2 * i) + 1)
	return [2] + [2 * i + 1 for i in range(1, n // 2) if sieve[i]]

def GCD(a, b):
	if b == 0:
		return a
	else:
		return GCD(b, a % b)
main()


inp = int(input())
for _ in range(inp):
	n = int(input())
	a = list(map(int, input().split(' ')))
	a.sort()
	m = a[-1]
	count = 0
	while count < n and a[count] <= 0:
		count += 1
	if count == n:
		print(count)
		continue
	for i in range(1, count):
		if a[i] - a[i - 1] < a[count]:
			count -= 1
			break
	print(count + 1)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	cnt = []
	flag = []
	for i in range(n):
		if a[i] <= 0:
			cnt.append(a[i])
		else:
			flag.append(a[i])
	if len(cnt) == 0:
		print(1)
	elif len(flag) == 0:
		print(len(cnt))
	elif cnt.count(0) > 1:
		print(len(cnt))
	else:
		flag.sort()
		cnt.sort()
		mark = 0
		for k in range(len(cnt)):
			if abs(cnt[k] - flag[0]) < flag[0]:
				mark += 1
		for j in range(len(cnt) - 1):
			if abs(cnt[j] - cnt[j + 1]) < flag[0]:
				mark += 1
		if mark == 0:
			print(len(cnt) + 1)
		else:
			print(len(cnt))


for tests in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().split()]
	a.sort()
	t = None
	while len(a) > 0 and a[-1] > 0:
		t = a.pop()
	if t != None:
		a.append(t)
	c = [a[i + 1] - a[i] for i in range(len(a) - 1)]
	if c == []:
		print(1)
	else:
		cm = min(c)
		if cm < a[-1]:
			a.pop()
		print(len(a))


from sys import stdin
input = stdin.readline
from collections import Counter

def solve():
	n = int(input())
	smallest_positive_num = float('inf')
	negative_arr = []
	for char in input().split():
		num = int(char)
		if num <= 0:
			negative_arr.append(num)
		else:
			smallest_positive_num = min(smallest_positive_num, num)
	if len(negative_arr) == n:
		return n
	smallest_positive_diff = float('inf')
	negative_arr.sort()
	for i in range(len(negative_arr) - 1):
		smallest_positive_diff = min(smallest_positive_diff, negative_arr[i + 1] - negative_arr[i])
	ans = len(negative_arr)
	if smallest_positive_diff >= smallest_positive_num:
		ans += 1
	return ans
for _ in range(int(input())):
	print(solve())


import sys, os, io
from sys import stdin, stdout
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import math
MOD = 1000000000 + 7
alphabets = list('abcdefghijklmnopqrstuvwxyz')

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def si():
	return input()

def prefix_sum(arr):
	r = [0] * (len(arr) + 1)
	for (i, el) in enumerate(arr):
		r[i + 1] = r[i] + el
	return r

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')

def power_set(L):
	cardinality = len(L)
	n = 2 ** cardinality
	powerset = []
	for i in range(n):
		a = bin(i)[2:]
		subset = []
		for j in range(len(a)):
			if a[-j - 1] == '1':
				subset.append(L[j])
		powerset.append(subset)
	powerset_orderred = []
	for k in range(cardinality + 1):
		for w in powerset:
			if len(w) == k:
				powerset_orderred.append(w)
	return powerset_orderred

def fastPlrintNextLines(a):
	print('\n'.join(map(str, a)))

def sortByFirstAndSecond(A):
	A = sorted(A, key=lambda x: x[0])
	A = sorted(A, key=lambda x: x[1])
	return list(A)
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
for _ in range(int(input())):
	n = int(input())
	li = list(map(int, input().split()))
	zc = pc = nc = 0
	pl = []
	nl = []
	for i in range(n):
		if li[i] <= 0:
			nc += 1
			nl.append(li[i])
		else:
			pc += 1
			pl.append(li[i])
	nl.sort()
	pl.sort()
	ans = nc
	if pc == 0:
		print(nc)
	elif nc == 1:
		print(2)
	elif nc == 0:
		print(1)
	else:
		pv = pl[0]
		flag = 0
		for i in range(nc - 1):
			if abs(nl[i] - nl[i + 1]) < pv:
				flag = 1
				break
		if flag == 0:
			print(nc + 1)
		else:
			print(nc)


import sys
import math
from bisect import bisect_left
from collections import Counter, defaultdict
L = lambda : list(map(int, input().split()))
I = lambda : int(input())
S = lambda : input()
mod = 10 ** 9 + 7

def solve():
	n = I()
	a = L()
	ans = 0
	m = mod
	x = []
	a.sort()
	for i in range(n):
		ans += a[i] <= 0
		if a[i] > 0:
			m = min(m, a[i])
		else:
			x += [a[i]]
	for i in range(len(x) - 1):
		if m == mod:
			ans -= 1
			break
		if abs(x[i] - x[i + 1]) < m:
			ans -= 1
			break
	print(min(n, ans + 1))
for _ in range(I()):
	solve()


import io, os
from sys import stdin, stdout
from math import ceil, floor, sqrt, log, log2, log10
from collections import Counter

def solve():
	pass
t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	arr.sort()
	total = 0
	zeroCount = 0
	output = []
	for i in range(n):
		if arr[i] < 0:
			output.append(arr[i])
			total += 1
		if arr[i] == 0:
			output.append(arr[i])
			total += 1
			zeroCount += 1
		if arr[i] > 0:
			if zeroCount > 1:
				break
			else:
				output.append(arr[i])
				break
	if len(output) >= 3:
		if output[-1] > 0:
			if abs(output[-2] - output[-3]) >= output[-1]:
				pass
			else:
				output.pop(-1)
	minnDiff = float('inf')
	for i in range(len(output) - 1):
		minnDiff = min(minnDiff, abs(output[i] - output[i + 1]))
	if output[-1] <= minnDiff:
		print(len(output))
	else:
		print(len(output) - 1)


def check(arr):
	for i in arr:
		if i > 0:
			return i
		else:
			continue
	return 0
t = int(input())
for i in range(t):
	n = int(input())
	lst = list(map(int, input().split()))
	lst.sort()
	a = check(lst)
	count = 0
	if a == 0:
		print(n)
	else:
		for j in range(0, lst.index(a) - 1):
			x = lst[j]
			y = lst[j + 1]
			if y - x >= a:
				continue
			else:
				count = count + 1
				break
		if count > 0:
			print(lst.index(a))
		else:
			print(lst.index(a) + 1)


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	neg = []
	pos = []
	for i in a:
		if i <= 0:
			neg.append(i)
		else:
			pos.append(i)
	res = len(neg)
	if res:
		if len(pos):
			m = min(pos)
			neg.sort()
			if len(neg) > 1:
				good = True
				for i in range(1, len(neg)):
					if abs(neg[i - 1] - neg[i]) < m:
						good = False
						break
				print(res + (1 if good else 0))
			else:
				print(res + 1)
		else:
			print(res)
	else:
		print(1)


import math
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	if n == 1:
		print(1)
		continue
	a.sort()
	cnt = 0
	mp = 0
	for i in range(n):
		if a[i] <= 0:
			cnt += 1
		else:
			mp = a[i]
			break
	if cnt == 0:
		print(1)
		continue
	if cnt == 1:
		print(2)
		continue
	if cnt == n:
		print(n)
		continue
	flag = True
	for i in range(1, n):
		if a[i] <= 0 and a[i] - a[i - 1] < mp:
			flag = False
			break
		elif a[i] > 0:
			break
	if flag:
		print(cnt + 1)
	else:
		print(cnt)


import sys
t = int(sys.stdin.readline())
for i in range(t):
	n = int(sys.stdin.readline())
	data = list(map(int, sys.stdin.readline().split()))
	data.sort()
	cnt = 1
	prev = data[0]
	diff = float('INF')
	for j in range(1, len(data)):
		temp = data[j]
		if diff > abs(prev - temp):
			diff = abs(prev - temp)
		if diff >= temp:
			cnt += 1
			prev = temp
	print(cnt)


for test in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	c0 = 0
	pp = 0
	pi = -1
	ne = a[0]
	nd = 0
	for i in range(n):
		if a[i] == 0:
			c0 += 1
		elif a[i] > 0 and pp == 0:
			pi = i
			pp = 1
	if pi != -1:
		for j in range(1, pi):
			if abs(a[j - 1] - a[j]) < a[pi]:
				nd = 1
				break
	if a[-1] <= 0:
		print(n)
	elif a[0] >= 1:
		print(1)
	elif a[0] == 0:
		print(c0)
	elif pp == 1:
		if nd == 1:
			print(pi)
		else:
			print(pi + 1)


for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	cnt = 0
	if n <= 1:
		print(1)
	else:
		max1 = a[-1]
		for i in range(1, len(a)):
			if max1 > a[i] - a[i - 1]:
				max1 = a[i] - a[i - 1]
			if max1 >= a[i]:
				cnt += 1
			else:
				break
		print(cnt + 1)


t = int(input())
while t:
	n = int(input())
	l = [int(i) for i in input().split()]
	pos = []
	neg = []
	zero = []
	for i in l:
		if i < 0:
			neg.append(i)
		elif i == 0:
			zero.append(i)
		else:
			pos.append(i)
	if len(zero) >= 2:
		print(len(neg) + len(zero))
	elif len(pos) >= 1:
		neg.sort()
		mini = float('inf')
		for i in range(len(neg) - 1):
			mini = min(mini, abs(neg[i] - neg[i + 1]))
		if len(zero) == 1 and len(neg) > 0:
			negi = neg[-1]
			mini = min(mini, abs(0 - negi))
		pos.sort()
		if mini >= pos[0]:
			print(len(neg) + len(zero) + 1)
		else:
			print(len(neg) + len(zero))
	else:
		print(len(neg) + len(zero))
	t -= 1


import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	pos = 0
	ans = 0
	y = []
	for i in a:
		if i > 0:
			pos += 1
			y.append(i)
		else:
			ans += 1
	y.sort()
	temp = []
	temp2 = []
	for i in a:
		if i <= 0:
			temp.append(i)
		if i < 0:
			temp2.append(i)
	temp.sort()
	temp1 = list(set(temp))
	temp1.sort()
	if temp1 == temp:
		if pos > 0:
			if len(temp) > 1:
				min_diff = temp[1] - temp[0]
				for i in range(1, len(temp)):
					min_diff = min(min_diff, temp[i] - temp[i - 1])
				if min_diff >= y[0]:
					ans += 1
			else:
				ans += 1
	print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	ans = 0
	last = mindiff = float('inf')
	for i in a:
		if abs(last - i) < mindiff:
			mindiff = abs(last - i)
		if i <= mindiff:
			ans += 1
		else:
			break
		last = i
	print(ans)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	mn = 1000000001
	a.sort()
	c = 0
	for i in a:
		if i > 0:
			mn = min(mn, i)
		else:
			c += 1
	f = mn < 1000000001
	for i in range(1, n):
		if a[i] <= 0:
			f &= a[i] - a[i - 1] >= mn
	if f:
		print(c + 1)
	else:
		print(c)


t = int(input())
for i in range(0, t):
	n = int(input())
	a = []
	a = list(map(int, input().split()))
	a.sort()
	min1 = 0
	if n >= 2:
		min1 = abs(a[1] - a[0])
	else:
		min1 = a[0]
	j = 1
	index1 = 0
	while j < n and min1 >= a[j]:
		if abs(a[j] - a[j - 1]) < min1:
			min1 = abs(a[j] - a[j - 1])
		if a[j] <= min1:
			index1 = j
		j += 1
	print(index1 + 1)


import sys
t = int(sys.stdin.readline())
for k in range(t):
	n = int(sys.stdin.readline())
	strnums = sys.stdin.readline().replace('\n', '').split()
	nums = list(map(int, strnums))
	nums.sort()
	maximum = 10000000000
	len_max = 1
	for i in range(1, n):
		maximum = min(maximum, nums[i] - nums[i - 1])
		if nums[i] > maximum:
			break
		len_max += 1
	print(len_max)


for t in range(int(input())):
	n = int(input())
	count = 1
	ar = [*map(int, input().split())]
	ar.sort()
	d = 1000000008
	for i in range(1, n):
		d = min(abs(ar[i] - ar[i - 1]), d)
		if ar[i] <= d:
			count = count + 1
	print(count)


t = int(input())
for i in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	neg = 0
	f = 0
	z = 0
	x = max(l)
	g = []
	for j in range(n):
		if l[j] < 0:
			neg = neg + 1
			g.append(l[j])
		if l[j] == 0:
			z = z + 1
			g.append(l[j])
		if l[j] > 0:
			if x > l[j]:
				x = l[j]
			f = 1
	g.append(x)
	if z <= 1:
		g.sort()
		c = 1
		for k in range(len(g) - 1):
			if abs(g[k + 1] - g[k]) < x:
				c = 0
				break
		if f == 1:
			print(neg + z + c)
		else:
			print(neg + z)
	else:
		print(neg + z)


cases = int(input())
for _ in range(cases):
	n = int(input())
	mylist = [int(i) for i in input().split(' ')]
	mylist.sort()
	ans = 0
	if mylist[0] > 0:
		print(1)
		continue
	min_diff = 1000000000
	for i in range(0, n):
		if mylist[i] < 0:
			if i > 0:
				if abs(mylist[i] - mylist[i - 1]) < min_diff:
					min_diff = abs(mylist[i] - mylist[i - 1])
			ans += 1
		else:
			if abs(mylist[i] - mylist[i - 1]) < min_diff:
				min_diff = abs(mylist[i] - mylist[i - 1])
			if min_diff >= mylist[i]:
				ans += 1
			else:
				break
	print(ans)


def mindiff(a, m):
	for i in range(len(a) - 1):
		if abs(a[i] - a[i + 1]) < m:
			return True
			break
	return False

def weird(l):
	if len(l) == 1:
		return 1
	else:
		a = sorted(l)
		cond = False
		i = 0
		m = 0
		while cond == False and i <= len(a) - 1:
			if a[i] > 0:
				m = a[i]
				cond = True
			else:
				i = i + 1
		if mindiff(a[0:i + 1], m) == True:
			return len(a[0:i])
		else:
			return len(a[0:i + 1])
x = int(input())
m = []
for i in range(x):
	y = input()
	z = input()
	z1 = z.split(' ')
	z2 = [int(t) for t in z1]
	m.append(z2)
for j in range(x):
	print(weird(m[j]))


from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from itertools import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
(graph, mod, szzz) = ({}, 10 ** 9 + 7, lambda : sorted(zzz()))

def getStr():
	return input()

def getInt():
	return int(input())

def listStr():
	return list(input())

def getStrs():
	return input().split()

def isInt(s):
	return '0' <= s[0] <= '9'

def input():
	return stdin.readline().strip()

def zzz():
	return [int(i) for i in input().split()]

def output(answer, end='\n'):
	stdout.write(str(answer) + end)

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
num = getInt()
for _ in range(num):
	n = getInt()
	arr = szzz()
	pos = []
	neg = []
	for i in arr:
		if i > 0:
			pos.append(i)
		else:
			neg.append(i)
	ans = len(neg)
	if len(pos):
		ans += 1
		mn = min(pos)
		for i in range(len(neg) - 1):
			if neg[i + 1] - neg[i] < mn:
				ans -= 1
				break
	print(ans)


L = []

def get_input(t):
	for i in range(t):
		n = int(input())
		a = list(map(int, input().strip().split()))[:n]
		a = sorted(a)
		longest_sub(a, n)

def longest_sub(arr, n):
	global L
	m = arr[n - 1]
	if n == 1:
		L.append(1)
		return
	else:
		i = 1
		while i < n:
			m = min(m, arr[i] - arr[i - 1])
			if m < arr[i]:
				break
			i += 1
		L.append(i)
t = int(input())
get_input(t)
for i in L:
	print(i)


import sys
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l.sort()
	a = 0
	ans = 1
	m = 1
	diff = 10000000000
	for i in range(n - 1):
		diff = min(diff, l[i + 1] - l[i])
		if l[i + 1] <= diff:
			ans += 1
		else:
			ans = 1
			diff = 10000000000
		m = max(ans, m)
	print(m)


def solution(n, a):
	a.sort()
	min_diff = 10 ** 10
	fin_idx = 0
	for i in range(1, len(a)):
		if abs(a[i] - a[i - 1]) < min_diff:
			min_diff = abs(a[i] - a[i - 1])
		if a[i] > 0:
			if a[i] > min_diff:
				break
			fin_idx = i
			break
		fin_idx = i
	return fin_idx + 1
t = int(input())
for tt in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	print(solution(n, a))


for tt in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l.sort()
	if l[0] > 0:
		print(1)
		continue
	neg = 1
	mi = 10 ** 9 + 7
	idx = -1
	for i in range(1, n):
		if l[i] <= 0:
			neg += 1
			mi = min(mi, l[i] - l[i - 1])
		else:
			idx = i
			break
	if neg == n:
		print(neg)
		continue
	if mi >= l[idx]:
		print(neg + 1)
	else:
		print(neg)


import math
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	a = []
	for x in l:
		if x < 0:
			a.append(x)
	a.sort()
	b = l.count(0)
	c = len(a)
	if b > 1:
		print(b + c)
	else:
		if b == 1:
			a.append(0)
			c += 1
		mi = 1000000001
		i = 0
		while i < c - 1:
			mi = min(mi, abs(a[i] - a[i + 1]))
			i += 1
		k = 0
		for x in l:
			if x > 0 and x <= mi:
				k = 1
		print(c + k)


t = int(input())
for _ in range(t):
	N = int(input())
	arr = sorted(list(map(int, input().split())))
	res = 1
	from collections import defaultdict
	counts = defaultdict(int)
	counts[arr[0]] += 1
	maximum = float('inf')
	for i in range(1, N):
		d = abs(arr[i] - arr[i - 1])
		maximum = min(maximum, d)
		if d >= arr[i] and arr[i] <= maximum:
			res += 1
		else:
			break
	second = sorted(set(arr))
	N2 = len(second)
	res2 = 1
	maximum = float('inf')
	for i in range(1, N2):
		d = abs(second[i] - second[i - 1])
		maximum = min(maximum, d)
		if d >= second[i] and second[i] <= maximum:
			res2 += 1
		else:
			break
	print(max(res, res2))


import sys
import math
import collections
dy = [1, 0, -1, 0]
dx = [0, 1, 0, -1]
r = sys.stdin.readline
for _ in range(int(r())):
	N = int(r())
	L = list(map(int, r().split()))
	L.sort()
	for i in range(N):
		if L[i] > 0:
			L = L[:i + 1]
			break
	m = 12482814212241424142
	for i in range(len(L) - 1):
		m = min(L[i + 1] - L[i], m)
	if L[-1] > m:
		L.pop()
	print(len(L))


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	cnt = 0
	l.sort()
	x = None
	for i in l:
		if i <= 0:
			cnt = cnt + 1
		else:
			x = i
			break
	f = 1
	if cnt == 0:
		print(1)
		continue
	if x == None:
		print(cnt)
		continue
	for i in range(len(l) - 1):
		if l[i + 1] <= 0:
			if abs(l[i] - l[i + 1]) < x:
				f = 0
				break
	if f == 0:
		print(cnt)
	else:
		print(cnt + 1)


import collections
import functools
import math
import sys

def In():
	return map(int, sys.stdin.readline().split())
input = sys.stdin.readline
import functools
import math
import sys

def In():
	return map(int, sys.stdin.readline().split())
input = sys.stdin.readline

def strange():
	for _ in range(int(input())):
		n = int(input())
		last = -float('inf')
		mindiff = float('inf')
		c = 0
		for i in sorted(In()):
			if last == -float('inf'):
				last = i
			else:
				mindiff = min(i - last, mindiff)
				last = i
			if i > 0:
				if mindiff < i:
					break
			c += 1
		print(c)
strange()


for z in [*open(0)][2::2]:
	b = 1000000000.0
	i = 1
	for (x, y) in zip((a := sorted(map(int, z.split()))), a[1:]):
		b = min(b, y - x)
		i += b >= y
	print(i)


for _ in range(int(input())):
	length = int(input())
	arr = sorted(list(map(int, input().split())))
	negative = list(filter(lambda x: x <= 0, arr))
	if len(negative) == length:
		print(len(negative))
	elif not negative or length == 1:
		print(1)
	else:
		c = 0
		minimum = arr[len(negative)]
		for i in range(len(negative) - 1):
			if abs(negative[i] - negative[i + 1]) < minimum:
				c = 1
				break
		if c == 1:
			print(len(negative))
		else:
			print(len(set(negative)) + 1)


from sys import stdin
from bisect import bisect
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	arr = list(map(int, stdin.readline().split()))
	arr.sort()
	x = bisect(arr, 0)
	if n == 1:
		print(1)
	else:
		m = abs(arr[0] - arr[1])
		for i in range(x - 1):
			m = min(m, abs(arr[i] - arr[i + 1]))
		if (x == n or arr[x] > min(m, abs(arr[x] - arr[x - 1]))) and x != 0:
			ans = x
		else:
			ans = x + 1
		print(ans)


t = int(input())
for i in range(t):
	n = int(input())
	elements = input()
	arr = elements.split(' ')
	ints = map(int, arr)
	L = list(ints)
	flagPos = False
	if max(L) > 0:
		flagPos = True
	seq = []
	smallestPos = []
	for j in range(n):
		if L[j] <= 0:
			seq.append(L[j])
		elif len(smallestPos) == 0:
			smallestPos.append(L[j])
		elif smallestPos[len(smallestPos) - 1] > L[j]:
			smallestPos.append(L[j])
	seqLength = len(seq)
	if not flagPos:
		print(seqLength)
	elif seq.count(0) > 1:
		print(seqLength)
	elif seqLength >= 2:
		seq.sort()
		minDiff = abs(seq[1] - seq[0])
		for j in range(2, seqLength):
			minDiff = min(minDiff, abs(seq[j] - seq[j - 1]))
		if seq.count(0) == 1:
			if minDiff >= smallestPos[len(smallestPos) - 1]:
				print(seqLength + 1)
			else:
				print(seqLength)
		elif minDiff >= smallestPos[len(smallestPos) - 1]:
			print(seqLength + 1)
		else:
			print(seqLength)
	else:
		print(seqLength + 1)


_ = int(input())
for i in range(_):
	l = int(input())
	word = [int(x) for x in input().split()]
	word.sort()
	for i in range(0, l - 1):
		if word[i] >= 1:
			l = i + 1
			break
	done = 0
	for i in range(0, l - 1):
		if word[i + 1] - word[i] < word[l - 1]:
			l = l - 1
			break
	print(l)


from sys import stdin
import math

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())

def si():
	return stdin.readline()
t = 1
t = ii()
for _ in range(t):
	n = ii()
	l1 = li()
	cnt = 0
	min1 = 1000000000000
	min1_dif = min1 - 1
	for i in l1:
		if i <= 0:
			cnt += 1
		else:
			min1 = min(min1, i)
	l1.sort()
	for i in range(1, n):
		if l1[i] > 0:
			break
		else:
			min1_dif = min(min1_dif, abs(l1[i] - l1[i - 1]))
	if min1_dif >= min1:
		cnt += 1
	print(cnt)


import sys
input = sys.stdin.readline

def solution():
	for _ in range(int(input())):
		n = int(input())
		li = list(map(int, input().split()))
		li.sort(reverse=1)
		if li[-1] > 0:
			print(1)
		elif li[-1] == 0:
			res = li.count(0)
			if res == 1 and len(li) > 1:
				res += 1
			print(res)
		else:
			n_li = []
			m_cnt = 0
			min_gap = int(10000000000.0)
			if li and li[-1] <= 0:
				if not n_li:
					min_num = li.pop()
					m_cnt += 1
			while li and li[-1] <= 0:
				next_min_num = li.pop()
				min_gap = min(min_gap, next_min_num - min_num)
				min_num = next_min_num
				m_cnt += 1
			if li and min_gap >= li[-1]:
				m_cnt += 1
			print(m_cnt)
solution()


for _ in range(int(input())):
	n = int(input())
	a = sorted(list(map(int, input().split())))
	cnt = 0
	mn = 10 ** 9 + 2
	nxt = -1
	for i in range(n):
		if a[i] <= 0:
			cnt += 1
			if i > 0:
				mn = min(mn, a[i] - a[i - 1])
		elif nxt == -1:
			nxt = a[i]
	if mn >= nxt and nxt > 0:
		cnt += 1
	print(cnt)


import math
for _ in range(int(input())):
	n = int(input())
	a = sorted(map(int, input().split()))
	(i, m) = (1, 1000000000.0)
	while i < len(a) and (m := min(m, a[i] - a[i - 1])) >= a[i]:
		i += 1
	print(i)


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	mapper = {}
	for i in arr:
		if i in mapper:
			mapper[i] += 1
		else:
			mapper[i] = 1
	neg = 0
	z = 0
	mex = 0
	cnt = 0
	brr = []
	for i in mapper:
		if i < 0:
			brr.append(i)
			neg += mapper[i]
		if i == 0:
			z = mapper[i]
		if i > 0:
			mex = max(mex, mapper[i])
			cnt = 1
	ans = 0
	if brr == []:
		ans = max(ans, z, min(1, mex) + min(1, z))
	else:
		brr.sort()
		p = 0
		cnt = 10 ** 10
		for i in range(1, len(brr)):
			diff = brr[i] - brr[i - 1]
			cnt = min(cnt, diff)
		for i in mapper:
			if i > 0 and i <= cnt:
				p = 1
		ans = max(ans, neg + min(1, z) + p)
		ans = max(ans, neg + z)
	print(ans)


import math
import sys
import queue

def solve():
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	res = 0
	negative = 0
	last = -10 ** 18
	min_diff = 10 ** 18
	for i in range(n):
		if a[i] <= 0:
			negative += 1
		min_diff = min(min_diff, abs(last - a[i]))
		if min_diff >= a[i]:
			last = a[i]
			res += 1
	print(max(negative, res))
multi_test = 1
if multi_test:
	t = int(input())
	for _ in range(t):
		solve()
else:
	solve()


import sys, os.path
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	l = a[0]
	r = a[0]
	ans = 1
	m = 10 ** 9
	for i in range(1, n):
		if abs(a[i] - r) >= a[i] and m >= a[i]:
			m = min(abs(a[i] - r), m)
			r = a[i]
			ans += 1
		else:
			break
	print(ans)


import math, copy
from collections import defaultdict, Counter

def fact(n):
	return 1 if n == 1 or n == 0 else n * fact(n - 1)

def prime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def inp():
	l = list(map(int, input().split()))
	return l

def main():
	for _ in range(int(input())):
		n = int(input())
		l = inp()
		l.sort()
		i = 0
		z = 0
		m = 9999999999999999999999999
		while i < n:
			if l[i] <= 0:
				if i - 1 >= 0:
					m = min(m, abs(l[i] - l[i - 1]))
				if l[i] == 0:
					z += 1
				i += 1
			else:
				break
		if i < n and z == 1 and (i - 2 >= 0) and (m >= l[i]):
			i += 1
		elif z == 0 and i < n and (l[i] <= m):
			i += 1
		print(max(i, 1))
import os, sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)


n = int(input())
for i in range(n):
	m = int(input())
	a = list(map(int, input().split()))
	a.sort()
	b = 1
	if m > 1:
		tt = abs(a[1] - a[0])
		for i in range(1, m - 1):
			if tt >= a[i]:
				tt = min(abs(a[i + 1] - a[i]), tt)
				b += 1
			else:
				break
		if tt >= a[-1]:
			b += 1
	print(b)


tests = int(input())
for case in range(tests):
	n = int(input())
	a = list(map(int, input().split()))
	if max(a) <= 0:
		print(n)
	else:
		p = []
		for e in a:
			if e > 0:
				p.append(e)
		x = min(p)
		a.sort()
		a = a[:-len(p)]
		for i in range(len(a) - 1):
			if a[i + 1] - a[i] < x:
				print(len(a))
				break
		else:
			print(len(a) + 1)


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	c = 1
	m = float('inf')
	a.sort()
	for i in range(1, len(a)):
		if a[i] - a[i - 1] < m:
			m = a[i] - a[i - 1]
		if a[i] <= m:
			c += 1
		else:
			break
	print(c)


def arr_in():
	return list(map(int, input().split()))

def mapIn():
	return map(int, input().split())
for ii in range(int(input())):
	n = int(input())
	arr = arr_in()
	arr.sort()
	fpos = False
	f1 = 0
	x = 0
	for i in range(n):
		if arr[i] > 0:
			fpos = True
			f1 = arr[i]
			break
		x += 1
	if fpos == False:
		print(n)
		continue
	maxi = x
	pre = arr[0]
	ans = 1
	if x:
		ans += 1
	for i in range(1, x):
		if abs(arr[i] - pre) >= f1:
			ans += 1
			pre = arr[i]
	maxi = max(maxi, ans)
	print(maxi)


def get_ans(n, l):
	curr_ans = 0
	for i in range(n):
		if l[i] <= 0:
			curr_ans += 1
	curr_max = curr_ans
	if curr_ans == n:
		return curr_ans
	if curr_ans == 0:
		return 1
	l.sort()
	curr_min = float('inf')
	for i in range(1, n):
		if l[i] <= 0:
			curr_min = min(curr_min, abs(l[i] - l[i - 1]))
		else:
			break
	pos = curr_ans - 1
	if l[curr_ans] <= curr_min:
		pos += 1
	curr_max = max(curr_max, pos + 1)
	return curr_max
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	print(get_ans(n, l))


t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(d) for d in input().split()]
	a.sort()
	idx = 0
	flag = False
	for i in range(0, len(a)):
		if a[i] > 0:
			idx = i
			flag = True
			break
	if flag == False:
		print(len(a))
	else:
		prev = a[idx]
		diff = a[idx]
		j = idx - 1
		c = 1
		while j >= 0:
			if abs(a[j] - prev) >= diff:
				c = c + 1
				prev = a[j]
			j = j - 1
		print(max(c, idx))


from __future__ import division, print_function
import bisect
import math
import heapq
import itertools
import sys
from collections import deque
from atexit import register
from collections import Counter
from functools import reduce
if sys.version_info[0] < 3:
	from io import BytesIO as stream
else:
	from io import StringIO as stream

def sync_with_stdio(sync=True):
	global input, flush
	if sync:
		flush = sys.stdout.flush
	else:
		sys.stdin = stream(sys.stdin.read())
		input = lambda : sys.stdin.readline().rstrip('\r\n')
		sys.stdout = stream()
		register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	if max(a) <= 0 or (max(a) == 0 and min(a) == 0):
		print(n)
	elif max(a) > 0 and min(a) > 0:
		print(1)
	elif n == 2 and min(a) <= 0:
		print(2)
	else:
		c = 0
		neg = []
		pos = []
		for i in a:
			if i <= 0:
				c += 1
				neg.append(i)
			else:
				pos.append(i)
		neg.sort()
		q = min(pos)
		flag = 0
		for i in range(len(neg) - 1):
			if q > abs(neg[i] - neg[i + 1]):
				flag = 1
				break
		if flag == 0:
			print(c + 1)
		else:
			print(c)


import time

def main():
	t = i_input()
	for tt in range(t):
		n = i_input()
		a = li_input()
		neg = []
		zeros = 0
		min_pos = 10 ** 10
		for aa in a:
			if aa == 0:
				zeros += 1
				neg.append(0)
			elif aa < 0:
				neg.append(aa)
			else:
				min_pos = min(aa, min_pos)
		if not neg:
			out = 1
		else:
			out = len(neg)
			if min_pos != 10 ** 10:
				neg.sort()
				for i in range(1, len(neg)):
					if neg[i] - neg[i - 1] < min_pos:
						break
				else:
					out += 1
		print(out)

def i_input():
	return int(input())

def l_input():
	return input().split()

def li_input():
	return list(map(int, l_input()))

def il_input():
	return list(map(int, l_input()))
TT = time.time()
main()


import math
t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	count = 0
	arr.sort()
	min = arr[0]
	i = 0
	flag = False
	for i in range(n):
		if arr[i] > 0:
			flag = True
			break
		count += 1
	if flag:
		flag2 = False
		max = i
		max2 = arr[max]
		for i in range(1, max + 1, 1):
			if arr[i] - arr[i - 1] < max2:
				flag2 = True
				break
		if flag2:
			print(count)
		else:
			print(count + 1)
	else:
		print(count)


import sys

def ints():
	return list(map(int, sys.stdin.readline().strip().split()))
tc = int(input())
while tc:
	tc -= 1
	n = int(input())
	ls = ints()
	ls.sort()
	(ans, c0, cp) = (1, 0, 9999999999999999)
	for i in range(1, n):
		if ls[i] <= 0:
			cp = min(cp, abs(ls[i] - ls[i - 1]))
			ans += 1
		elif ls[i] <= cp and ls[i - 1] < 1:
			ans += 1
			break
	print(ans)


def solve(n, a):
	a.sort()
	b = []
	for elem in a:
		if elem < 0:
			b.append(elem)
		if elem == 0:
			b.append(elem)
		if elem > 0:
			for i in range(1, len(b)):
				if b[i] - b[i - 1] < elem:
					return len(b)
			return len(b) + 1
	return len(b)
t = int(input())
for test in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	print(solve(n, a))


def main():
	num_tests = int(input())
	count = 0
	while count < num_tests:
		length = int(input())
		array = [int(num) for num in input().strip().split()]
		array = sorted(array)
		(negative_nums, postive_nums) = ([], [])
		for num in array:
			if num <= 0:
				negative_nums.append(num)
			else:
				postive_nums.append(num)
		if len(negative_nums) == 0:
			print(1)
		elif len(postive_nums) == 0:
			print(len(negative_nums))
		elif len(negative_nums) == 1 and len(postive_nums) >= 1:
			print(2)
		else:
			for i in range(0, len(negative_nums) - 1):
				if negative_nums[i + 1] - negative_nums[i] < postive_nums[0]:
					break
				if i == len(negative_nums) - 2:
					negative_nums.append(postive_nums[0])
			print(len(negative_nums))
		count += 1
main()


import sys, math
import io, os
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
from itertools import permutations, combinations

def data():
	return sys.stdin.readline().strip()

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write(' '.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
INF = float('inf')
mod = int(1000000000.0) + 7
for t in range(int(data())):
	n = int(data())
	a = mdata()
	a.sort(reverse=True)
	if a[0] > 0:
		l = []
		for i in a[::-1]:
			if i > 0:
				break
			else:
				l.append(a.pop())
		m = INF
		for i in range(len(l) - 1):
			if abs(l[i] - l[i + 1]) < m:
				m = abs(l[i] - l[i + 1])
		if len(l) == 1:
			out(min(n, 2))
		elif a and m >= a[-1]:
			out(len(l) + 1)
		else:
			out(len(l))
	else:
		out(n)


t = int(input())

def main():
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	for (i, x) in enumerate(a):
		if x > 0:
			j = i
			break
		else:
			j = -1
	if j == 0:
		return 1
	if j == -1:
		return n
	if j == 1:
		return 2
	ar = a[:j]
	ds = [ar[i + 1] - ar[i] for i in range(j - 1)]
	if min(ds) >= a[j]:
		return j + 1
	else:
		return j
for _ in range(t):
	print(main())


def strangeSubsequences(n, array):
	positives = 0
	negetives = 0
	zeros = 0
	for x in array:
		if x < 0:
			negetives += 1
		elif x == 0:
			zeros += 1
		else:
			positives += 1
	if negetives == 0:
		if zeros == 0:
			return min(1, positives)
		elif zeros == 1:
			return 1 + min(1, positives)
		elif zeros > 1:
			return zeros
	elif zeros > 1:
		return negetives + zeros
	else:
		if positives == 0:
			return negetives + zeros
		m = []
		pos = []
		min_diff = float('inf')
		for x in array:
			if x <= 0:
				m.append(x)
			else:
				pos.append(x)
		m.sort()
		for x in range(1, len(m)):
			min_diff = min(min_diff, abs(m[x] - m[x - 1]))
		min_pos = min(pos)
		if min_diff >= min_pos:
			return negetives + min(1, zeros) + min(1, positives)
		else:
			return negetives + min(1, zeros)
t = int(input())
final = []
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	final.append(strangeSubsequences(n, l))
for _ in range(t):
	print(final[_])


from sys import stdin, stdout
stdin.readline

def mp():
	return list(map(int, stdin.readline().strip().split()))

def it():
	return int(stdin.readline().strip())
from collections import defaultdict as dd, Counter as C, deque
from math import ceil, gcd, sqrt, factorial, log2, floor
from bisect import bisect_right as br, bisect_left as bl
for _ in range(it()):
	n = it()
	l = sorted(mp())
	if n == 1:
		print(1)
		continue
	mi = 1 << 60
	ind = n - 1
	for i in range(n):
		if l[i] == abs(l[i]) and l[i] != 0:
			ind = i
			break
		if i != 0:
			mi = min(mi, abs(l[i - 1] - l[i]))
	if ind == 0:
		print(1)
		continue
	ans = ind
	if l[ind] <= mi:
		ans += 1
	print(ans)


import sys
for j in range(int(sys.stdin.readline().strip())):
	N = int(sys.stdin.readline().strip())
	arr = list(map(int, sys.stdin.readline().strip().split()))
	arr.sort()
	answer = 1
	minimum = float('inf')
	for i in range(1, N):
		if abs(arr[i - 1] - arr[i]) < minimum:
			minimum = abs(arr[i - 1] - arr[i])
		if arr[i] <= minimum:
			answer += 1
	print(answer)


for i in range(int(input())):
	a = input()
	b = [int(i) for i in input().split()]
	if max(b) <= 0:
		print(len(b))
	else:
		i = len([i for i in b if i <= 0])
		b.sort()
		for j in range(1, i):
			if b[j] - b[j - 1] < b[i]:
				i -= 1
				break
		print(i + 1)


n = int(input())
for i in range(n):
	y = int(input())
	x = list(map(int, input().split()))
	l = []
	flag1 = 0
	flag2 = 0
	x.sort()
	for i in range(y):
		if x[i] > 0:
			l = x[0:i + 1]
			flag1 = 1
			max_pos = x[i]
			break
	if flag1 == 0:
		print(y)
		continue
	j = 0
	k = 1
	y = len(l)
	while k < y:
		m = abs(l[k] - l[j])
		if max_pos > m:
			print(y - 1)
			flag2 = 1
			break
		j = j + 1
		k = k + 1
	if flag2 == 0:
		print(y)


t = int(input())
for _ in range(t):
	n = int(input())
	a = sorted(list(map(int, input().split())))
	m = 100000000000000
	count = 0
	for i in range(n):
		if i != 0:
			m = min(m, abs(a[i] - a[i - 1]))
		if m < a[i]:
			break
		count += 1
	print(count)


def solve(arr):
	arr.sort()
	neg = [el for el in arr if el <= 0]
	pos = [el for el in arr if el > 0]
	ans = len(neg)
	neg.sort()
	if pos:
		ans += 1
		candidate = min(pos)
		for i in range(len(neg) - 1):
			if abs(neg[i] - neg[i + 1]) < candidate:
				ans -= 1
				break
	return ans

def main():
	n = int(input())
	arr = list(map(int, input().split()))
	print(solve(arr))
t = int(input())
for i in range(t):
	main()


def check(cnt, list, n):
	if cnt == 0:
		return 1
	for i in range(1, len(list)):
		if list[i] > 0:
			break
		if list[i] - list[i - 1] < n:
			return 0
	return 1
t = int(input())
while t > 0:
	n = int(input())
	list = [int(item) for item in input().split()]
	list.sort()
	cnt = 0
	flag = 0
	for i in list:
		if i <= 0:
			cnt += 1
		else:
			flag = check(cnt, list, i)
			break
	print(cnt + flag)
	t -= 1


import sys

def get_io():
	if '--local' in sys.argv:
		return (open('input.txt', 'r'), open('output.txt', 'w'))
	else:
		return (sys.stdin, sys.stdout)

def solve(fin, fout):
	n = int(fin.readline())
	a = list(map(int, fin.readline().split()))
	pos = [x for x in a if x > 0]
	non_pos = [x for x in a if x <= 0]
	non_pos.sort()
	dist = min([non_pos[i] - non_pos[i - 1] for i in range(1, len(non_pos))], default=2000000000)
	answer = len(non_pos) + (1 if any(map(lambda x: x <= dist, pos)) else 0)
	print(answer, file=fout)

def main():
	(fin, fout) = get_io()
	tests = int(fin.readline())
	for test in range(tests):
		solve(fin, fout)
main()


import sys
input = sys.stdin.readline
import bisect
for _ in range(int(input())):
	n = int(input())
	w = sorted(map(int, input().split()))
	c = bisect.bisect_right(w, 0)
	if n > c > 1:
		d = min((abs(j - i) for (i, j) in zip(w[:c], w[:c][1:])))
		if d >= w[c]:
			print(c + 1)
		else:
			print(c)
	elif c == n:
		print(c)
	elif c == 0:
		print(1)
	else:
		print(2)


for testis in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	if n == 1:
		ans = 1
	else:
		f = 0
		ans = 1
		mi = 10000000000
		for i in range(1, n):
			mi = min(mi, abs(a[i] - a[i - 1]))
			if a[i] > mi:
				break
			ans = ans + 1
	print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	b = [x for x in a if x > 0]
	len_b = len(b)
	if len_b == 0:
		print(n)
	elif len_b == n:
		print(1)
	elif len_b == n - 1:
		print(2)
	else:
		c = [x for x in a if x <= 0]
		c.sort()
		len_c = len(c)
		cc = [c[i + 1] - c[i] for i in range(len_c - 1)]
		x = min(cc)
		if x == 0:
			print(len_c)
		else:
			print(len_c + int(min(b) <= x))


from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
import bisect

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def digits(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def ceil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def mapin():
	return map(int, input().split())
t = int(input())
for _ in range(t):
	n = int(input())
	l = [int(x) for x in input().split()]
	l.sort()
	fi = [max(l)]
	ans = 0
	l2 = []
	x = 0
	y = 0
	z = 0
	l1 = []
	for i in range(n):
		if l[i] < 0:
			l2.append(-l[i])
			x += 1
		elif l[i] > 0:
			y += 1
			l1.append(l[i])
		else:
			z += 1
			l2.append(0)
	ans = z + x
	ans = max(ans, len(l2))
	if len(l1) > 0:
		tt = min(l1)
		fi = 0
		l2.sort()
		mi = -tt
		for i in l2:
			if i - mi >= tt:
				fi += 1
				mi = i
		ans = max(ans, fi + 1)
	print(ans)


import sys
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	c = 1
	m = sys.maxsize
	for i in range(1, n):
		m = min(m, abs(a[i] - a[i - 1]))
		if m < a[i]:
			break
		c += 1
	print(c)


cases = int(input())
for case in range(0, cases):
	n = int(input())
	a_array = [int(x) for x in input().split(' ')]
	min_number = 10 ** 10
	min_neg_diff = 10 ** 10
	max_neg = -10 ** 10
	pos_count = 0
	zero_count = 0
	neg_array = []
	result = 0
	x = 10
	for a in a_array:
		if a > 0:
			pos_count += 1
			if a < min_number:
				min_number = a
		if a == 0:
			zero_count += 1
		if a < 0:
			neg_array.append(a)
	sorted_neg_array = sorted(neg_array)
	for i in range(0, len(neg_array) - 1):
		if min_neg_diff == 0:
			break
		if abs(sorted_neg_array[i] - sorted_neg_array[i + 1]) < min_neg_diff:
			min_neg_diff = abs(sorted_neg_array[i] - sorted_neg_array[i + 1])
	if pos_count == 0:
		print(n)
		continue
	if n == 2 and zero_count == 1:
		print(2)
		continue
	if pos_count == n:
		print(1)
		continue
	if zero_count > 1:
		print(len(neg_array) + zero_count)
		continue
	if min_neg_diff >= min_number:
		result = len(neg_array) + 1
	else:
		result = len(neg_array)
	if zero_count == 1:
		print(result + 1)
	else:
		print(result)


import math
from fractions import gcd
t = int(input())
for z in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	arr.sort()
	if n == 1:
		print(1)
	else:
		count = 1
		md = 1000000001
		for i in range(1, n):
			d = abs(arr[i] - arr[i - 1])
			md = min(md, d)
			if md >= arr[i]:
				count = count + 1
			else:
				break
		print(count)


for _ in range(int(input())):
	n = int(input())
	arr = [int(x) for x in input().split()]
	arr.sort()
	notp = []
	first = -1
	for i in range(n):
		if arr[i] <= 0:
			notp.append(arr[i])
		else:
			first = arr[i]
			break
	if len(set(notp)) != len(notp):
		print(len(notp))
	else:
		allowed = 100000000000
		ans = len(notp)
		for i in range(1, len(notp)):
			allowed = min(allowed, abs(notp[i] - notp[i - 1]))
		if first > 0:
			if first <= allowed:
				ans += 1
		print(ans)


for x in range(int(input())):
	n = int(input())
	c = 1
	m = 10000000000.0
	arr = sorted([int(i) for i in input().split()])
	for i in range(n - 1):
		m = min(m, arr[i + 1] - arr[i])
		if m >= arr[i + 1]:
			c += 1
	print(c)


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	ans = []
	mindiff = float('inf')
	for i in a:
		if len(ans) >= 1 and abs(ans[-1] - i) < mindiff:
			mindiff = abs(ans[-1] - i)
		if i <= mindiff:
			ans.append(i)
		else:
			break
	print(len(ans))


T = int(input())
for x in range(T):
	n = int(input())
	a = [int(y) for y in input().split()]
	a.sort()
	countn0 = 0
	pos = -1
	if n == 1 or a[0] > 0:
		print(1)
	else:
		a.sort()
		diff = a[1] - a[0]
		for z in range(n):
			if a[z] <= 0:
				countn0 = countn0 + 1
				if z > 0:
					if diff >= a[z] - a[z - 1]:
						diff = a[z] - a[z - 1]
			if a[z] > 0:
				pos = z
				break
		if pos != -1:
			if diff >= a[pos]:
				print(countn0 + 1)
			else:
				print(countn0)
		else:
			print(n)


for _ in range(int(input())):
	n = int(input())
	l1 = list(map(int, input().split()))
	neg = [x for x in l1 if x <= 0]
	pos = [x for x in l1 if x > 0]
	ans = len(neg)
	if len(pos) > 0:
		ans += 1
		p = min(pos)
		neg.sort()
		for i in range(len(neg) - 1):
			if neg[i + 1] - neg[i] < p:
				ans -= 1
				break
	print(ans)


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())

def solve():
	n = ii()
	arr = rr() + [inf]
	arr.sort()
	m = pos = inf
	for i in range(n):
		if i and arr[i] > m:
			break
		pos = i
		x = abs(arr[i] - arr[i + 1])
		m = min(m, x)
	print(pos + 1)
for _ in range(ii()):
	solve()


def solve():
	n = int(input())
	l = list(map(int, input().split()))
	if n == 1:
		print(1)
		return
	l.sort()
	count = 1
	ans = l[1] - l[0]
	key = l[0]
	j = -1
	for i in range(1, n):
		if l[i] > 0:
			key = l[i - 1]
			j = i
			break
		count += 1
		ans = min(ans, l[i] - l[i - 1])
	if j != -1:
		flag = True
		while j < n:
			if flag:
				flag = False
				if l[j] <= ans:
					count += 1
					key = l[j]
			if flag and l[j] <= ans and (l[j] - key <= ans):
				count += 1
				ans = min(ans, l[j] - key)
				key = l[j]
			else:
				break
			j += 1
	print(count)
for _ in range(int(input())):
	solve()


import sys
import os.path
from collections import *
import math
import bisect
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
t = int(input())
while t:
	t -= 1
	n = int(input())
	arr = [int(x) for x in input().split()]
	arr.sort()
	if arr[0] > 0:
		print(1)
		continue
	if arr[-1] <= 0:
		print(n)
		continue
	index = 0
	for i in range(n):
		if arr[i] > 0:
			break
		index += 1
	mindiff = 3 * 10 ** 9
	for i in range(1, index):
		mindiff = min(mindiff, abs(arr[i] - arr[i - 1]))
	if arr[index] <= mindiff:
		print(index + 1)
	else:
		print(index)


answers = []

def solve(n, arr):
	store = []
	posStore = []
	for ele in arr:
		if ele <= 0:
			store.append(ele)
		else:
			posStore.append(ele)
	store.sort()
	minDiff = float('inf')
	length = len(store)
	for i in range(length - 1):
		if store[i + 1] - store[i] < minDiff:
			minDiff = store[i + 1] - store[i]
	if len(posStore) == 0:
		answers.append(len(store))
		return
	else:
		temp = min(posStore)
		if temp <= minDiff:
			answers.append(len(store) + 1)
		else:
			answers.append(len(store))
T = int(input())
while T:
	n = int(input())
	arr = [int(x) for x in input().split()]
	solve(n, arr)
	T -= 1
for ans in answers:
	print(ans)


for s in [*open(0)][2::2]:
	a = sorted(map(int, s.split()))
	m = 1000000000.0
	i = 1
	while i < len(a) and (m := min(m, a[i] - a[i - 1])) >= a[i]:
		i += 1
	print(i)


cases = int(input())
for _ in range(cases):
	num = int(input())
	arr = sorted(map(int, input().split()))
	ans = 1
	mn = float('inf')
	for i in range(1, num):
		mn = min(mn, arr[i] - arr[i - 1])
		if mn >= arr[i]:
			ans += 1
	print(ans)


import sys
input = sys.stdin.readline
from collections import defaultdict
for _ in range(int(input())):
	n = int(input())
	v = list(map(int, input().split()))
	ans = []
	for i in v:
		if i <= 0:
			ans.append(i)
	ans.sort()
	min_diff = 1000000000000
	for i in range(1, len(ans)):
		if abs(ans[i] - ans[i - 1]) < min_diff:
			min_diff = abs(ans[i] - ans[i - 1])
	pr = len(ans)
	if pr > 0:
		for i in v:
			if i > 0 and i <= min_diff:
				pr += 1
				break
		print(pr)
	else:
		print(1)


import sys, os
import math
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
from io import BytesIO, IOBase

def main():
	import bisect
	for _ in range(int(input())):
		n = int(input())
		arr = list(MI())
		arr.sort()
		c = bisect.bisect_right(arr, 0)
		m = 10 ** 12
		for i in range(1, c):
			m = min(m, arr[i] - arr[i - 1])
		z = arr.count(0)
		if c < n and z <= 1:
			for i in range(c, n):
				if arr[i] <= m:
					c += 1
					break
		print(max(c, 1))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def MI():
	return map(int, input().split())

def outP(var):
	sys.stdout.write(str(var) + '\n')
MOD = 10 ** 9 + 7
main()


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	ans = 0
	a.sort()
	ans = sum([x <= 0 for x in a])
	mn = min([x if x > 0 else 10 ** 9 + 7 for x in a])
	flag = mn < 10 ** 9 + 7
	for i in range(1, n):
		if a[i] <= 0:
			flag &= a[i] - a[i - 1] >= mn
	if flag == True:
		print(ans + 1)
	else:
		print(ans)


for i in range(int(input())):
	n = int(input())
	a = sorted(list(map(int, input().split())))
	res = 1
	if n == 1:
		print(res)
	else:
		ma = a[-1] - a[0]
		for j in range(1, n):
			ma = min(ma, a[j] - a[j - 1])
			if ma >= a[j]:
				res += 1
			else:
				break
		print(res)


from sys import stdin

def solve():
	n = int(stdin.readline().strip())
	seq = list(map(int, stdin.readline().split()))
	seq.sort()
	if seq[-1] <= 0:
		return n
	for i in range(n):
		if seq[i] > 0:
			seq = seq[:i + 1]
			break
	target = seq[-1]
	n = len(seq)
	for i in range(1, n):
		d = seq[i] - seq[i - 1]
		if target > d:
			return n - 1
	return n
t = int(stdin.readline().strip())
for _ in range(t):
	print(solve())


import sys
import math
from math import gcd, inf, sqrt, pi, cos, sin, ceil, log2, floor, log
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)
N = 20005

def isPowerOfTwo(x):
	return x and (not x & x - 1)
T = 1
T = int(stdin.readline())
for _ in range(T):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().rstrip().split()))
	mn = -1
	nc = 0
	a.sort()
	for i in range(n):
		if a[i] <= 0:
			nc += 1
		else:
			mn = a[i]
			break
	if mn == -1:
		print(nc)
	else:
		isOk = True
		for i in range(nc):
			if abs(a[i + 1] - a[i]) < mn:
				isOk = False
				break
		if isOk:
			print(nc + 1)
		else:
			print(nc)


out = []

def f(x):
	for el in enumerate(x):
		try:
			q = abs(el[1] - x[el[0] + 1])
			if q == 1 and q < x[-1]:
				return False
			elif q < x[-1]:
				return False
		except:
			pass
	return True
for _ in range(int(input())):
	lst = int(input())
	s = False
	t = input()
	st = sorted(list(map(int, t.split())))
	for i in range(len(st)):
		if st[i] <= 0:
			continue
		else:
			st = st[:i + 1]
			break
	while len(st) != 0:
		if f(st):
			out.append(len(st))
			break
		else:
			st = st[:-1]
for e in out:
	print(e)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = []
	c = []
	for i in range(n):
		if a[i] <= 0:
			b.append(a[i])
		else:
			c.append(a[i])
	b.sort()
	diff = 10000000000000000
	for i in range(1, len(b)):
		if abs(b[i] - b[i - 1]) < diff:
			diff = abs(b[i] - b[i - 1])
	for i in range(len(c)):
		if c[i] <= diff:
			b.append(c[i])
			break
	print(len(b))


from math import *
sInt = lambda : int(input())
mInt = lambda : map(int, input().split())
lInt = lambda : list(map(int, input().split()))
t = sInt()
for _ in range(t):
	n = sInt()
	a = lInt()
	a.sort()
	ans = 1
	last = a[0]
	if n == 1:
		print(1)
		continue
	mind = a[1] - last
	for i in a[1:]:
		if i - last >= i and mind >= i:
			ans += 1
		else:
			break
		if i - last < mind:
			mind = i - last
		last = i
		flag = False
	print(ans)


tot = int(input())
for x in range(tot):
	tt = int(input())
	arr = list(map(int, input().split()))
	if tt == 1:
		print(1)
		continue
	arr.sort()
	if arr[0] <= 0 and arr[-1] <= 0:
		print(tt)
		continue
	pid = -1
	ct = 0
	mind = 9999999999
	for x in range(1, tt):
		if mind > arr[x] - arr[x - 1]:
			mind = abs(arr[x] - arr[x - 1])
		if arr[x] > 0:
			pid = x
			break
	if mind >= arr[pid]:
		pid += 1
	print(pid)


for i in range(int(input())):
	n = int(input())
	k = 0
	t = True
	s = list(sorted(list(map(int, input().split()))))
	for j in range(len(s)):
		if s[j] <= 0:
			k += 1
		else:
			maxx = s[j]
			s = s[:j + 1]
			break
	if k == n:
		print(n)
	else:
		for j in range(1, len(s)):
			if abs(s[j - 1] - s[j]) < maxx:
				print(k)
				t = False
				break
		if t:
			print(k + 1)


from sys import *
from collections import defaultdict as dd
from math import *
from bisect import *

def sinp():
	return input()

def inp():
	return int(sinp())

def minp():
	return map(int, sinp().split())

def linp():
	return list(minp())

def strl():
	return list(sinp())

def pr(x):
	print(x)
mod = int(1000000000.0 + 7)
for _ in range(inp()):
	n = inp()
	a = linp()
	a.sort()
	(pos, neg) = (0, 0)
	for i in range(n):
		if a[i] < 0:
			neg += 1
		elif a[i] > 0:
			pos += 1
	if pos == n:
		pr(1)
		continue
	z = n - pos - neg
	ans = neg + z
	if z == n or pos == 0 or neg == n:
		pr(n)
	elif z >= 2:
		pr(ans)
	elif z <= 1 and neg == 1 and (pos >= 1):
		pr(ans + 1)
	elif neg > 1 and z <= 1 and (pos >= 1):
		min_diff = maxsize
		flag = False
		for i in range(1, n):
			if a[i] < 0:
				min_diff = min(min_diff, abs(a[i] - a[i - 1]))
			elif a[i] > 0:
				if min_diff >= a[i]:
					flag = True
					ans += 1
					break
		pr(ans)


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	A = list(map(int, input().rstrip().split(' ')))
	mx = 0
	m = 0
	s = set()
	for a in A:
		if a <= 0:
			s.add(a)
			mx += 1
		else:
			if m == 0:
				m = a
			m = min(m, a)
	if m > 0:
		cnt = 1
		s = list(s)
		s.sort()
		if s:
			cnt = 2
			prev = s[0]
			for _ in s[1:]:
				if _ - prev >= m:
					cnt += 1
					prev = _
		mx = max(mx, cnt)
	print(mx)


from sys import stdin
from math import inf
t = int(stdin.readline())
for _ in range(t):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	cp = cz = cn = 0
	for ele in a:
		if ele == 0:
			cz += 1
		elif ele > 0:
			cp += 1
		else:
			cn += 1
	ak = 0
	a = list(set(a))
	a.sort()
	p = a[0]
	fp = a[0]
	md = inf
	cc = p <= 0
	for ele in a[1:]:
		if ele > 0:
			fp = ele
			break
		cc += 1
		md = min(md, ele - p)
		p = ele
	if md >= fp and fp > 0:
		ak = cc + 1
	print(max(cz + cn, ak, 1))


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	if len(a) < 2:
		print(len(a))
		continue
	if a[len(a) - 1] <= 0:
		print(len(a))
		continue
	p = 0
	diff = a[1] - a[0]
	for i in range(1, n):
		if a[i] > 0:
			p = i
			break
		d = a[i + 1] - a[i]
		if d < diff:
			diff = d
	if a[p] <= diff:
		print(p + 1)
	else:
		print(p)


for j in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	pos = 0
	var = 0
	neg = []
	for k in range(n):
		if a[k] < 1:
			neg.append(a[k])
		else:
			var = k
			break
	pos = a[k]
	flag = True
	for j in range(len(neg) - 1):
		if abs(a[j + 1] - a[j]) < pos:
			flag = False
			break
	if len(neg) == n:
		print(n)
	elif flag:
		print(len(neg) + 1)
	else:
		print(len(neg))


from collections import defaultdict
from math import inf
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	min_dif = inf
	arr.sort()
	neg = []
	for x in range(n):
		if arr[x] > 0:
			neg = arr[:x]
			arr = arr[x:]
			break
	if len(arr) == n:
		if arr[-1] > 0:
			print(1)
		else:
			print(n)
		continue
	ans = len(neg)
	for x in range(1, len(neg)):
		min_dif = min(min_dif, neg[x] - neg[x - 1])
	if arr and arr[0] <= min_dif:
		ans += 1
	print(ans)


def sol(A):
	neg = []
	pos = []
	for a in A:
		if a <= 0:
			neg.append(a)
		else:
			pos.append(a)
	neg = sorted(neg)
	if not pos:
		return len(neg)
	if len(neg) == 1:
		return 2
	if len(neg) == 0:
		return 1
	minn = min(pos)
	diff = 2 ** 31
	for i in range(len(neg) - 1):
		diff = min(diff, neg[i + 1] - neg[i])
	if diff >= minn:
		return len(neg) + 1
	else:
		return len(neg)
x = int(input())
for _ in range(x):
	y = int(input())
	A = list(map(int, input().split()))
	print(sol(A))


for t in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l.sort()
	c = 1
	m = 10000000000
	while c < n and l[c] <= 0:
		m = min(l[c] - l[c - 1], m)
		c += 1
	if c < n:
		if m >= l[c] and l[c] - l[c - 1] >= l[c]:
			c += 1
	print(c)


import sys
import math
import random

def solve(arr, n):
	i = 0
	while i < n and arr[i] <= 0:
		i += 1
	if i == n:
		print(n)
		return
	if i == 0:
		print(1)
		return
	if i == 1:
		print(2)
		return
	count = i + 1
	while i - 2 >= 0:
		if abs(arr[i - 1] - arr[i - 2]) < arr[count - 1]:
			count -= 1
			break
		i -= 1
	print(count)
t = int(input())
for tt in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	arr.sort()
	solve(arr, n)


from sys import *
ws = lambda : map(int, stdin.readline().strip().split())
li = lambda : list(map(int, stdin.readline().strip().split()))
mod = 1000000007

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def prod(l):
	ans = 1
	for i in range(len(l)):
		ans = ans * l[i]
	return ans

def sortindex(l, a):
	c = []
	if a == -1:
		rev = True
	else:
		rev = False
	for i in range(len(l)):
		c.append([l[i], i])
	x = sorted(c, reverse=rev)
	return x
for _ in range(int(input())):
	n = int(input())
	l = li()
	l.sort()
	maxi = 0
	ans = 1
	if n == 1:
		print(1)
	elif l[0] > 0:
		print(1)
	else:
		maxi = l[1] - l[0]
		for i in range(n - 1):
			t1 = l[i + 1] - l[i]
			if t1 < maxi:
				maxi = t1
			if l[i + 1] <= maxi:
				ans += 1
			else:
				break
		t2 = l.count(0)
		if t2 > ans:
			print(t2)
		else:
			print(ans)


t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	b = sorted(a)
	m = []
	s = 0
	h = 0
	for j in range(n):
		if b[j] > 0:
			s = b[j]
			break
		else:
			m.append(b[j])
	if s != 0:
		for j in range(len(m) - 1):
			q = m[j + 1] - m[j]
			if q < s:
				h = 1
				break
			else:
				continue
	if s != 0 and h == 0:
		print(len(m) + 1)
	else:
		print(len(m))


def solve(n, arr):
	np = 0
	p = 0
	m = 10 ** 9 + 1
	npl = []
	for a in arr:
		if a <= 0:
			np += 1
			npl.append(a)
		else:
			p += 1
			m = min(m, a)
	if p == 0:
		return n
	if np <= 1:
		return np + 1
	npl.sort()
	d = min((npl[i + 1] - npl[i] for i in range(len(npl) - 1)))
	if d >= m:
		return np + 1
	return np
import sys
input = lambda : sys.stdin.readline().rstrip()
t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	print(solve(n, arr))


import sys
for _ in range(int(input())):
	n = int(input())
	a = sorted(map(int, sys.stdin.readline().split()))
	key = min(filter(lambda x: x > 0, a), default=0)
	if key:
		res = a.index(key)
		end = 0
		for i in range(a.index(key), n):
			max = a[i]
			for j in range(i):
				if a[j + 1] - a[j] < max:
					end = 1
					continue
			if end:
				break
			res += 1
		print(res)
	else:
		print(len(a))


import sys
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
from collections import defaultdict as df
rn = lambda : int(input().strip())
infinite = float('inf')
t = rn()
for i in range(t):
	n = rn()
	l = RI()
	neg = []
	pos = []
	zero = 0
	ans = 0
	for j in range(len(l)):
		if l[j] <= 0:
			neg.append(l[j])
			zero += 1 if l[j] == 0 else 0
		else:
			pos.append(l[j])
	if len(pos) == 0:
		ans = n
	elif len(pos) == n:
		ans = 1
	else:
		mini = min(pos)
		neg.sort()
		mindiff = infinite
		for j in range(0, len(neg) - 1, 1):
			mindiff = min(mindiff, neg[j + 1] - neg[j])
		if mindiff >= mini:
			ans = len(neg) + 1
		else:
			ans = len(neg)
	print(ans)


import sys, math, bisect
inf = float('inf')
mod = 998244353

def lcm(a, b):
	return int(a / math.gcd(a, b) * b)

def gcd(a, b):
	return int(math.gcd(a, b))

def tobinary(n):
	return bin(n)[2:]

def binarySearch(a, x):
	i = bisect.bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return i
	else:
		return -1

def lowerBound(a, x):
	i = bisect.bisect_left(a, x)
	if i:
		return i - 1
	else:
		return -1

def upperBound(a, x):
	i = bisect.bisect_right(a, x)
	if i != len(a) + 1 and a[i - 1] == x:
		return i - 1
	else:
		return -1

def primesInRange(n):
	ans = []
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for p in range(2, n + 1):
		if prime[p]:
			ans.append(p)
	return ans

def primeFactors(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			factors.append(i)
			n = n // i
	if n > 2:
		factors.append(n)
	return factors
from collections import deque, defaultdict, Counter
import heapq
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	arr.sort()
	cnt = 1
	maxi = 1e+19
	for i in range(1, n):
		maxi = min(maxi, abs(arr[i] - arr[i - 1]))
		if maxi < arr[i]:
			break
		cnt += 1
	print(cnt)


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	if n == 1:
		print(1)
	else:
		l.sort()
		m = abs(l[0] - l[1])
		f = n
		if l[0] <= 0:
			for i in range(1, n):
				if l[i] <= 0:
					k = abs(l[i - 1] - l[i])
					m = min(m, k)
				else:
					f = i
					break
			if f < n and m >= l[f]:
				print(f + 1)
			else:
				print(f)
		else:
			print(1)


import bisect

def solve(arr, n, ans):
	arr.sort()
	max_len = 0
	start = 0
	min_diff = float('inf')
	end = 0
	for end in range(1, n):
		min_diff = min(min_diff, arr[end] - arr[end - 1])
		if min_diff >= arr[end]:
			continue
		min_diff = float('inf')
		max_len = max(max_len, end - start)
		start = end
	max_len = max(max_len, end - start + 1)
	ans.append(str(max_len))

def main():
	t = int(input())
	ans = []
	for i in range(t):
		n = int(input())
		arr = list(map(int, input().split()))
		solve(arr, n, ans)
	print('\n'.join(ans))
main()


def solve(values):
	values.sort()
	x = 1
	while x < len(values) and values[x] <= 0:
		x += 1
	if x == len(values):
		return x
	else:
		for y in range(1, x + 1):
			if abs(values[y] - values[y - 1]) < values[x]:
				return x
		return x + 1
for _ in range(int(input())):
	input()
	print(solve(list(map(int, input().split()))))