description: Stephen Queen wants to write a story. He is a very unusual writer, he uses only letters 'a', 'b', 'c', 'd' and 'e'!
  
  To compose a story, Stephen wrote out n words consisting of the first 5 lowercase letters of the Latin alphabet. He wants to select the maximum number of words to make an interesting story.
  
  Let a story be a sequence of words that are not necessarily different. A story is called interesting if there exists a letter which occurs among all words of the story more times than all other letters together.
  
  For example, the story consisting of three words "bac", "aaada", "e" is interesting (the letter 'a' occurs 5 times, all other letters occur 4 times in total). But the story consisting of two words "aba", "abcde" is not (no such letter that it occurs more than all other letters in total).
  
  You are given a sequence of n words consisting of letters 'a', 'b', 'c', 'd' and 'e'. Your task is to choose the maximum number of them to make an interesting story. If there's no way to make a non-empty story, output 0.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases. Then t test cases follow.
  
  The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of the words in the sequence. Then n lines follow, each of them contains a word — a non-empty string consisting of lowercase letters of the Latin alphabet. The words in the sequence may be non-distinct (i. e. duplicates are allowed). Only the letters 'a', 'b', 'c', 'd' and 'e' may occur in the words.
  
  It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5; the sum of the lengths of all words over all test cases doesn't exceed 4 ⋅ 10^5.
  
  Output
  
  For each test case, output the maximum number of words that compose an interesting story. Print 0 if there's no way to make a non-empty interesting story.
  
  Example
  
  Input
  
  
  6
  3
  bac
  aaada
  e
  3
  aba
  abcde
  aba
  2
  baba
  baba
  4
  ab
  ab
  c
  bc
  5
  cbdca
  d
  a
  d
  e
  3
  b
  c
  ca
  
  
  Output
  
  
  3
  2
  0
  2
  3
  2
  
  Note
  
  In the first test case of the example, all 3 words can be used to make an interesting story. The interesting story is "bac aaada e".
  
  In the second test case of the example, the 1-st and the 3-rd words can be used to make an interesting story. The interesting story is "aba aba". Stephen can't use all three words at the same time.
  
  In the third test case of the example, Stephen can't make a non-empty interesting story. So the answer is 0.
  
  In the fourth test case of the example, Stephen can use the 3-rd and the 4-th words to make an interesting story. The interesting story is "c bc".
solution: import sys
  read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()
  import bisect,string,math,time,functools,random,fractions
  st=time.time()
  from bisect import*
  from heapq import heappush,heappop,heapify
  from collections import deque,defaultdict,Counter
  from itertools import permutations,combinations,groupby
  rep=range;R=range
  def I():return int(input())
  def LI():return [int(i) for i in input().split()]
  def LI_():return [int(i)-1 for i in input().split()]
  def S_():return input()
  def IS():return input().split()
  def LS():return [i for i in input().split()]
  def NI(n):return [int(input()) for i in range(n)]
  def NI_(n):return [int(input())-1 for i in range(n)]
  def NLI(n):return [[int(i) for i in input().split()] for i in range(n)]
  def NLI_(n):return [[int(i)-1 for i in input().split()] for i in range(n)]
  def StoLI():return [ord(i)-97 for i in input()]
  def ItoS(n):return chr(n+97)
  def LtoS(ls):return ''.join([chr(i+97) for i in ls])
  def RLI(n=8,a=1,b=10):return [random.randint(a,b)for i in range(n)]
  def RI(a=1,b=10):return random.randint(a,b)
  def INP():
      N=8
      n=random.randint(2,N)
      n=6
      a=[(random.randint(1,9),random.randint(1,9)) for i in range(n)]
      #A=[random.randint(1,n) for i in range(m)]
      return a
  def Rtest(T):
      case,err=0,0
      for i in range(T):
          inp=INP()
          a1=naive(inp)
          a2=solve(inp)
          if a1!=a2:
              print(inp)
              
              print('naive',a1)
              print('solve',a2)
              err+=1
          case+=1
      print('Tested',case,'case with',err,'errors')
  def GI(V,E,ls=None,Directed=False,index=1):
      org_inp=[];g=[[] for i in range(V)]
      FromStdin=True if ls==None else False
      for i in range(E):
          if FromStdin:
              inp=LI()
              org_inp.append(inp)
          else:
              inp=ls[i]
          if len(inp)==2:a,b=inp;c=1
          else:a,b,c=inp
          if index==1:a-=1;b-=1
          aa=(a,c);bb=(b,c);g[a].append(bb)
          if not Directed:g[b].append(aa)
      return g,org_inp
  def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
      #h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
      mp=[boundary]*(w+2);found={}
      for i in R(h):
          s=input()
          for char in search:
              if char in s:
                  found[char]=((i+1)*(w+2)+s.index(char)+1)
                  mp_def[char]=mp_def[replacement_of_found]
          mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
      mp+=[boundary]*(w+2)
      return h+2,w+2,mp,found
  def TI(n):return GI(n,n-1)
  def accum(ls):
      rt=[0]
      for i in ls:rt+=[rt[-1]+i]
      return rt
  def bit_combination(n,base=2):
      rt=[]
      for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
      return rt
  def gcd(x,y):
      if y==0:return x
      if x%y==0:return y
      while x%y!=0:x,y=y,x%y
      return y
  def YN(x):print(['NO','YES'][x])
  def Yn(x):print(['No','Yes'][x])
  def show(*inp,end='\n'):
      if show_flg:print(*inp,end=end)
  
  mo=10**9+7
  #mo=998244353
  inf=float('inf')
  FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
  alp=[chr(ord('a')+i)for i in range(26)]
  #sys.setrecursionlimit(10**7)
  
  ########################################################################################################################################################################
  # Verified by
  # https://yukicoder.me/problems/no/979
  # https://atcoder.jp/contests/abc152/tasks/abc152_e
  
  ## return prime factors of N as dictionary {prime p:power of p}
  ## within 2 sec for N = 2*10**20+7
  def primeFactor(N):
      i,n=2,N
      ret={}
      d,sq=2,99
      while i<=sq:
          k=0
          while n%i==0:
              n,k,ret[i]=n//i,k+1,k+1
          if k>0 or i==97:
              sq=int(n**(1/2)+0.5)
          if i<4:
              i=i*2-1
          else:
              i,d=i+d,d^6
      if n>1:
          ret[n]=1
      return ret
  
  ## return divisors of n as list
  def divisors(n):
      div=[1]
      for i,j in primeFactor(n).items():
          div=[(i**k)*d for d in div for k in range(j+1)]
      return div
  
  ## return the array s such that s[q] = the minimum prime factor of q
  def sieve(x):
      s=[i for i in range(x+1)]
      p=2
      while p*p<=x:
          if s[p]==p:
              for q in range(2*p,x+1,p):
                  if s[q]==q:
                      s[q]=p
          p+=1
      return s
  
  ## return the list of prime numbers in [2,N], using eratosthenes sieve
  ## around 800 ms for N = 10**6  by PyPy3 (7.3.0) @ AtCoder
  def PrimeNumSet(N):
      M=int(N**0.5)
      seachList=[i for i in range(2,N+1)]
      primes=[]
      while seachList:
          if seachList[0]>M:
              break
          primes.append(seachList[0])
          tmp=seachList[0]
          seachList=[i for i in seachList if i%tmp!=0]
      return primes+seachList
  
  
  ## retrun LCM of numbers in list b
  ## within 2sec for no of B = 10*5  and  Bi < 10**6
  def LCM(b,mo=10**9+7):
      prs=PrimeNumSet(max(b))
      M=dict(zip(prs,[0]*len(prs)))
      for i in b:
          dc=primeFactor(i)
          for j,k in dc.items():
              M[j]=max(M[j],k)
      
      r=1
      for j,k in M.items():
          if k!=0:
              r*=pow(j,k,mo)
              r%=mo
      return r
  
  ## return (a,b,gcd(x,y)) s.t. a*x+b*y=gcd(x,y)
  def extgcd(x,y):
      if y==0:
          return 1,0
      r0,r1,s0,s1 = x,y,1,0
      while r1!= 0:
          r0,r1,s0,s1=r1,r0%r1,s1,s0-r0//r1*s1
      return s0,(r0-s0*x)//y,x*s0+y*(r0-s0*x)//y
  
  
  ## return x,LCM(mods) s.t. x = rem_i (mod_i), x = -1 if such x doesn't exist
  ## verified by ABC193E
  ## https://atcoder.jp/contests/abc193/tasks/abc193_e
  def crt(rems,mods):
      n=len(rems)
      if n!=len(mods):
          return NotImplemented
      x,d=0,1
      
      for r,m in zip(rems,mods):
          a,b,g=extgcd(d,m)
          x,d=(m*b*x+d*a*r)//g,d*(m//g)
          x%=d
  
      for r,m in zip(rems,mods):
          if r!=x%m:
              return -1,d
  
      return x,d
  
  ## returns the maximum integer rt s.t. rt*rt<=x
  ## verified by ABC191D
  ## https://atcoder.jp/contests/abc191/tasks/abc191_d
  def intsqrt(x):
      if x<0:
          return NotImplemented
      rt=int(x**0.5)-1
      while (rt+1)**2<=x:
          rt+=1
      return rt
  
  show_flg=False
  show_flg=True
  
  d=dict(zip('abcde',range(5)))
  for i in range(I()):
      ans=0
      n=I()
      t=[]
      for i in range(n):
          s=input()
          x=[0]*5
          for j in s:
              x[d[j]]+=1
          t+=x+[sum(x)],
      
      ans=0
      for i in range(5):
          t.sort(key=lambda x:-x[i]+(x[5]-x[i]))
          tmp=a=0
          for j in range(n):
              a+=t[j][i]-(t[j][5]-t[j][i])
              if a<1:
                  break
              tmp=j+1
          #show(i,tmp,t)
          ans=max(ans,tmp)
  
      print(ans)
      #show(t)
  
  
  