Problem:
 Score : 300 points    Problem Statement You drew lottery N times. In the i -th draw, you got an item of the kind represented by a string S_i .  How many kinds of items did you get?      Constraints  1 \leq N \leq 2\times 10^5  S_i consists of lowercase English letters and has a length between 1 and 10 (inclusive).         Input Input is given from Standard Input in the following format:  N  S_1  :  S_N       Output Print the number of kinds of items you got.        Sample Input 1 3
apple
orange
apple      Sample Output 1 2  You got two kinds of items: apple and orange .       Sample Input 2 5
grape
grape
grape
grape
grape      Sample Output 2 1       Sample Input 3 4
aaaa
a
aaa
aa      Sample Output 3 4

Solution (Python):
n=int(input())
string_list=[input() for i in range(n)]

a = set(string_list)
print(len(a))

Solution (Python):


N,= map(int, input().split())
S=[]
su=0
for i in range(N):
    a = input()
    S+=[a]    
print(len(set(S)))

Solution (Python):
n = int(input())
ls = []
for i in range(n):
    s = input()
    ls.append(s)
ln = set(ls)
print(len(ln))

Solution (Python):
import sys,bisect,string,math,time,functools,random
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 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 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 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()
            a,b,c=(inp+[1])[:3]
            org_inp.append(inp)
        else:
            index=0
            a,b,c=(list(ls[i])+[1])[:3]
        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={'

    mp=[1]*(w+2);found={}
    for i in range(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+=[1]+[mp_def[j] for j in s]+[1]
    mp+=[1]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)

YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase

input=lambda: sys.stdin.readline().rstrip()

class Comb:
    def __init__(self,n,mo=10**9+7):
        self.fac=[0]*(n+1)
        self.inv=[1]*(n+1)
        self.fac[0]=1
        self.fact(n)
        for i in range(1,n+1):
            self.fac[i]=i*self.fac[i-1]%mo
            self.inv[n]*=i
            self.inv[n]%=mo
        self.inv[n]=pow(self.inv[n],mo-2,mo)
        for i in range(1,n):
            self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
        return
    
    def fact(self,n):
        return self.fac[n]
        
    def invf(self,n):
        return self.inv[n]

    def comb(self,x,y):
        if y<0 or y>x:
            return 0
        return self.fac[x]*self.inv[x-y]*self.inv[y]%mo

show_flg=False
show_flg=True








class SegTree:

    def __init__(self,n,init_ls=None,init_val=0,function=lambda a,b:a+b,ide=0):
        self.n=n
        self.ide_ele=ide_ele=ide
        self.num=num=2**(n-1).bit_length()
        self.seg=seg=[self.ide_ele]*2*self.num
        self.lazy=lazy=[self.ide_ele]*2*self.num
        self.segfun=segfun=function
        
        if init_ls==None:
            for i in range(n):
                self.seg[i+self.num-1]=init_val
        else:
            for i in range(n):
                self.seg[i+self.num-1]=init_ls[i]
        
        for i in range(self.num-2,-1,-1):
            self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
    
    def update(self,k,x):
        k += self.num-1
        self.seg[k] = x
        while k:
            k = (k-1)//2
            self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
        
    def evaluate(k,l,r): 
        if lazy[k]!=0:
            node[k]+=lazy[k]
            if(r-l>1):
                lazy[2*k+1]+=lazy[k]//2
                lazy[2*k+2]+=lazy[k]//2

        lazy[k]=0
        
    def query(self,p,q):
        if q<=p:
            return self.ide_ele
        p += self.num-1
        q += self.num-2
        res=self.ide_ele
        while q-p>1:
            if p&1 == 0:
                res = self.segfun(res,self.seg[p])
            if q&1 == 1:
                res = self.segfun(res,self.seg[q])
                q -= 1
            p = p//2
            q = (q-1)//2
        if p == q:
            res = self.segfun(res,self.seg[p])
        else:
            res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
        return res
    
    def find_min_index(self,p,q,m):
        if q<=p:
            return self.ide_ele
        p += self.num-1
        q += self.num-2
        res=self.ide_ele
        while q-p>1:
            if p&1 == 0:
                res = self.segfun(res,self.seg[p])
            if q&1 == 1:
                res = self.segfun(res,self.seg[q])
                q -= 1
            p >>= 1
            q = (q-1)//2
        if p == q:
            res = self.segfun(res,self.seg[p])
        else:
            res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
        return res


    def __str__(self):
        
        rt=self.seg[self.num-1:self.num-1+self.n]
        return str(rt)

class Tree:
    def __init__(self,inp_size=None,init=True):
        if init:
            self.stdin(inp_size)
        return

    def stdin(self,inp_size=None):
        if inp_size==None:
            self.size=int(input())
        else:
            self.size=inp_size
        self.edges,_=GI(self.size,self.size-1)
        return
    
    def listin(self,ls):
        self.size=len(ls)+1
        self.edges,_=GI(self.size,self.size-1,ls)
        return

    def __str__(self):
        return  str(self.edges)

    def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append(x)
        v=[-1]*self.size
        v[x]=root_v
        while q:
            c=q.pop()
            for nb,d in self.edges[c]:
                if v[nb]==-1:
                    q.append(nb)
                    v[nb]=func(v[c],nb,d)
        return v

    def EulerTour(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append((-1,x))
        v=[None]*self.size
        v[x]=root_v
        et=[]
        while q:
            cb,ce=q.pop()
            et.append(ce)
            for nb,d in self.edges[ce]:
                if v[nb]==None:
                    q.append((nb,ce))
                    q.append((ce,nb))
                    v[nb]=func(v[ce],nb,d)
        vid=[[-1,-1]for i in range(self.size)]
        for i,j in enumerate(et):
            if vid[j][0]==-1:
                vid[j][0]=i
            else:
                vid[j][1]=i
        return v,et,vid
    
    def LCA_init(self,depth,et):
        self.st=SegTree(self.size*2-1,func=min,ide=inf)
        for i,j in enumerate(et):
            self.st.update(i,j)
        self.LCA_init_stat==True
        return
    
    def LCA(self,root,x,y):
        if self.LCA_init_stat==False:
            depth,et,vid=self.EulerTour(root)
            self.LCA_init(depth,et)
        return self.st.query(x,y+1)

def dijkstra(edge,st):
    
    
    n=len(edge)
    d=[(0 if st==i else inf) for i in range(n)]
    prev=[0]*n
    q=[(j,i) for i,j in enumerate(d)]
    heapify(q)
    
    
    while q:
        dist,cur=heappop(q)
        for dst,dist in edge[cur]:
            alt=d[cur]+dist
            if alt<d[dst]:
                d[dst]=alt
                prev[dst]=cur
                heappush(q,(alt,dst))
    return d,prev


ans=0
n=I()
d=defaultdict(int)

for i in range(n):
    s=input()
    d[s]+=1

print(len(d))

Solution (Python):
N = int(input())
S = [input()for i in range(N)]
print(len(set(S)))

Solution (Python):
import sys 
try:
	sys.stdin = open('input.txt', 'r') 
	sys.stdout = open('output.txt', 'w')
except:
	pass

for tt in range(1):
	n = int(input())
	s = set()
	for i in range(n):
		s.add(input())
	print(len(s))

Solution (Python):
n = int(input())
l = []
while(n):
  s = input()
  l.append(s)
  n = n-1
ans = set(l)
print(len(ans))

Solution (Python):
import collections
S=[]
N=int(input())
for i in range(N):
    S.append(input())
print(len(collections.Counter(S)))

Solution (Python):
N = int(input())
st = set()
for _ in range(N):
    s = input()
    st.add(s)
print(len(st))

Solution (Python):
n = int(input())
S = [input() for i in range(n)]
print(len(set(S)))

Solution (Python):
def main():
    import sys
    N=int(sys.stdin.readline())
    st=set()
    for i in range(N):
        st.add(input().strip())
    print(len(st))
main()

Solution (Python):
n = int(input())
ss = []
for i in range(n):
    s = str(input())
    ss.append(s)
print(len(set(ss)))

Solution (Python):
def main(N, S):
    print(len(set(S)))


if __name__ == '__main__':
    S = []
    N = int(input())
    for i in range(N):
        S.append(input())
    main(N, S)

Solution (Python):
import collections
n = int(input())
s = [input() for i in range(n)]
print(len(set(s)))

Solution (Python):
def main():
    N = int(input())
    S_set = set()

    for i in range(N):
        S_set.add(input())

    print(len(S_set))

if __name__ == '__main__':
    main()

Solution (Python):

N = int(input())

L = []
for i in range(N):
    L.append(input())

LL = sorted(L)

ans = 1
for i in range(N-1):
    if LL[i+1] != LL[i]: ans += 1

print(ans)

Solution (Python):
n=int(input())
s=list()
for i in range(n):
 s.append(input())
print(len(set(s)))

Solution (Python):
N = int(input())
S = {1}

for _ in range(N):
    a = input()
    S.add(a)

print(len(S)-1)

Solution (Python):
n = int(input())
st = set()
for i in range(n):
    a = input()
    if not a in st:
        st.add(a)

print(len(st))

Solution (Python):
N=int(input())
a=[]
for i in range(N):
    a.append(input())
b=set(a)
print(len(b))

Solution (Python):
n=int(input())
s={input() for i in range(n)}
print(len(s))

Solution (Python):
N = int(input())
S = []
for _ in range(N):
    s = str(input())
    S.append(s)
S1 = sorted(S)
counter=1
for i in range(N-1):
    if S1[i]!=S1[i+1]:
        counter+=1
print(counter)

Solution (Python):
N = int(input())
S = [0 for i in range(N)]
for i in range(N):
    S[i]=input()
print(len(set(S)))

Solution (Python):
import collections

N=int(input())
lis=[]
for i in range(N):
    s=input()
    lis.append(s)
c = collections.Counter(lis)
print(len(c))

Solution (Python):
n = int(input())
l = []
for i in range(n):
  s = input()
  l.append(s)
print(len(set(l)))

Solution (Python):

n = int(input())
l = []
for i in range(n):
    l.append(input())
print(len(set(l)))

Solution (Python):
n = int(input())
m = [0]*n
s =[]

for i in range(n):
    m[i] += 1
    s.append(input())
    
d = dict(zip(s, m))
result = 0
for value in d.values():
    result += value
print(result)

Solution (Python):
n=int(input())
li=[input() for i in range(n)]
a=list(set(li))
ans=len(a)
print(ans)

Solution (Python):
import collections
N = int(input())
S = []
for n in range(N):
    S.append(input())

c = collections.Counter(S)
print(len(c))

Solution (Python):
a = int(input())
S = [input() for i in range(a)]
res = 1

S.sort()

for i in range(a - 1):
    if S[i] != S[i + 1]:
        res = res + 1

print(res)

Solution (Python):
x=int(input())
s=[input() for i in range(x)]

sp=set(s)

print(len(sp))

Solution (Python):
n = int(input())
li = [input() for i in range(n)]
l = list(set(li))

print(len(l))

Solution (Python):
N = int(input())

t = set()

for _ in range(N):
    t.add(input())

print(len(t))

Solution (Python):
n = int(input())
s =[input() for i in range(n)]

se = set(s)

print(len(se))

Solution (Python):
N = int(input())
S = [str(input()) for _ in range(N)]

from collections import Counter

print(len(Counter(S)))

Solution (Python):
N = int(input())
S = []

for i in range(N):
    S.append(input())

print(len(set(S)))

Solution (Python):
import sys
stdin = sys.stdin
     
pi=3.1415
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

N=int(input())
S=[]
for i in range(N):
    S.append(ns())

S.sort()
c=0
tmp=''
for i in range(N):
    val=S.pop()
    if(val!=tmp):
        c+=1
    tmp=val

print(c)

Solution (Python):
k = int(input())
l = [input() for i in range(k)]
import collections
c = collections.Counter(l)
print(len(c))

Solution (Python):
n=int(input())
s= set()
for _ in range(n):
    t = input()
    s.add(t)
print(len(s))

Solution (Python):
N = int(input())
S = {input() for _ in range(N)}
print(len(S))

Solution (Python):
N=int(input())
s=[input() for i in range(N)]
r=set(s)
print(len(r))

Solution (Python):
N = int(input())
S = []
for _ in range(N):
    S.append(input())

print(len(set(S)))

Solution (Python):
n = int(input())
l = list()
for i in range(n):
    l.append(input())

l = list(set(l))
print(l.__len__())

Solution (Python):
N = int(input())
present = []

for i in range(N):
    present.append(input())

ans_list = set(present)
print(len(ans_list))

Solution (Python):
n = int(input())
c = 1
s = []
for i in range(n):
  ss = input()
  s.append(ss)
s.sort()  
for j in range(1,n):
  
  if s[j] !=s[j-1]:
    c+=1 
print(c)

Solution (Python):
N = int(input())
S =[input() for i in range(N)]
import collections
c = collections.Counter(S)

print(len(c))

Solution (Python):

"""
Created on Sun Apr 19 21:27:49 2020

@author: arute
"""


from sys import stdin

import time
import numpy as np





temp = stdin.readline().split()
N = int(temp[0])

data = []
write = stdin.readline().split()
data = set()
for i in range(N):
    
    data.add(write[0])
    write = stdin.readline().split()
    
print(len(data))

Solution (Python):
a=int(input())
list1=[]
for i in range(a):
  list1.append(input())
  
print(len(list(set(list1))))

Solution (Python):
N = int(input())
S_n = [ ]
for i in range(N):
    S_n.append(input())

if N ==1:
    print(1)
else:
    count=1
    S_n.sort()
    prize= S_n.pop()
    for i in range(N-1):
        neprize = S_n.pop()
        if prize != neprize:
            count +=1
            prize = neprize
    print(count)

Solution (Python):
n = int(input())
sets = set()

for i in range(n):
    sets.add(input())

print(len(sets))

Solution (Python):
n = int(input())
s = set()
for i in range(n):
    prize = str(input())
    s.add(prize)
print(len(s))

Solution (Python):
n=int(input())
a=[]
for i in range(n):
  a.append(str(input()))

ans=1
a=sorted(a)
tmp=a[0]
for i in range(n-1):
  if a[i+1] != tmp:
    ans += 1
    tmp=a[i+1]

print(ans)

Solution (Python):
n = int(input())
print(len(list(set([input() for s in range(n)]))))

Solution (Python):
N = int(input())

S = []

for i in range(N):
    S.append(input())

print(len(set(S)))

Solution (Python):
N = int(input())
L = [input() for _ in range(N)]
S = set(L)
print(len(S))

Solution (Python):
N = int(input())
a = []
for i in range(N):
    a.append(input())
tmp = set(a)
print(len(tmp))

Solution (Python):
n=int(input())
a = [input() for i in range(n)]
print(len(set(a)))

Solution (Python):
n=int(input())
s=[str(input()) for i in range (n)]
l=sorted(s)
t=1
for i in range (n-1):
    if l[i+1]!=l[i]:
        t+=1
print(t)

Solution (Python):
N = int(input())

lis = []

for n in range(N):
  lis.append(input())

s = set(lis)
print(len(s))

Solution (Python):
import collections
n = int(input())
List = [input() for i in range(n)]
c = collections.Counter(List)
print(len(c))

Solution (Python):
n=int(input())
li=[]
for i in range(n):
    s=input()
    li.append(s)
li=list(set(li))
print(len(li))

Solution (Python):
N=int(input())
i=0
S=[]
for i in range(0,N):
    S.append(input())
if 1<=N<=2*10**5:
    S=list(set(S))
    print(len(S))

Solution (Python):
import collections
n = int(input())
s = []

for i in range(n):
    s.append(input())

c = collections.Counter(s)

print(len(c))

Solution (Python):
iterate = int(input())
unique_item = set()
for i in range(iterate):
  unique_item.add(input())

print(len(unique_item))

Solution (Python):
N = int(input())
s = [input() for i in range(N)]
print(len(set(s)))

Solution (Python):
n = int(input())
items = []
for i in range(n):
  items.append(input())
print(len(set(items)))

Solution (Python):
n = int(input())
ary = {}
for _ in range(n):
    s = input()
    if s in ary:
        ary[s] = ary[s] + 1
    else:
        ary[s] = 1

print(len(ary.keys()))

Solution (Python):
from collections import defaultdict
N = int(input())
dictionary = defaultdict(bool)
ans = 0
for _ in range(N):
  S = input()
  if (S not in dictionary.keys()):
    ans += 1
    dictionary[S] = True
print(ans)

Solution (Python):
N = int(input())
l = [input() for x in range(N)]

l = list(set(l))
print(len(l))

Solution (Python):
N = int(input())
S = [input() for i in range(N)]
print(len(set(S)))

Solution (Python):
N=int(input())
 
S=[input() for _ in range(N)]



print(len(set(S)))

Solution (Python):
n = int(input())
l = []
 
for i in range(n):
    l.append(input())
 
print(len(set(l)))

Solution (Python):
N = int(input())
items = {}
ans = 0
for _ in range(N):
    items[input()] = None
print(len(items))

Solution (Python):
N=int(input())
s_li=[input() for i in range(N)]
print(len(set(s_li)))

Solution (Python):
n = int(input())
base = []
for i in range(n):
  base.append(str(input()))
ans_set = set(base)
print(len(ans_set))

Solution (Python):
n = int(input())
strList = [ input() for i in range(n)]
strSet = set(strList)
print(len(strSet))

Solution (Python):
from collections import Counter

N = int(input())

S = [input() for _ in range(N)]
counter = Counter(S)

print(len(counter.keys()))

Solution (Python):
keihin = {}
n = int(input())
for i in range(n):
    k = input()
    keihin[k] = 1

print(len(keihin))

Solution (Python):
N = int(input())
l = []
for i in range(N):
    l.append(input().rstrip())
print(len(list(set(l))))

Solution (Python):
lst=[]
for i in range(int(input())):
    lst.extend([input()])

lst=list(set(lst))
print(len(lst))

Solution (Python):
N = int(input())
SSet = set()
noCount = 0
for i in range(N):
    itemInput = input()
    if itemInput in SSet:
        continue
    else:
        SSet.add(itemInput)
        noCount += 1
print(noCount)

Solution (Python):
N = int(input())
ans = set()

for _ in range(N):
    ans.add(input())

print(len(ans))

Solution (Python):

from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


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


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    n = I()
    s = [input() for i in range(n)]
    cs = Counter(s)
    print(len(cs))

    return



if __name__ == "__main__":
    solve()

Solution (Python):
n = int(input())
l = set()
for i in range(n):
    s = input()
    if s not in l:
        l.add(s)
print(len(l))

Solution (Python):
N = int(input())
S = [input() for i in range(N)]

print(len(list(set(S))))

Solution (Python):
N = int(input())
slist=list(input() for i in range(N))





print(len(list(set(slist))))

Solution (Python):
N = input()
slist = []
N = int(N)
for i in range(0,N):
    slist.append(input())


print(len(list(set(slist))))

Solution (Python):

N = int(input())

res = set()
for i in range(N):
    res.add(input())
print(len(res))

Solution (Python):
N = int(input())
S = [input().split() for _ in range(N)]

S_ = [s[0] for s in S]

set_S = set(S_)

print(len(set_S))

Solution (Python):


n = int(input())
l = []
count = 0

for i in range(n):
    s = str(input())
    l.append(s)

l = set(l)
count = len(l)
print("{}".format(count))

Solution (Python):
import bisect

n = int(input())
s = [input() for i in range(n)]
s = sorted(s)
a = []

for i in range(n):
    if bisect.bisect_left(a, s[i]) == bisect.bisect_right(a, s[i]):
        a.append(s[i])
print(len(a))

Solution (Python):
import collections
N=int(input())
s =list(map(str,[input() for m in range(N)]))       
c=collections.Counter(s)
print(len(c))

Solution (Python):
n=int(input())
lottery_items=set()
for i in range(n):
    lottery_items.add(input())
print(len(lottery_items))

Solution (Python):
N = int(input())
S = [input() for i in range(N)]
a = set(S)
print(len(a))

Solution (Python):
import numpy as np
N = input()
Si = [input() for _ in range(int(N))]

uni = np.unique(Si)

print(len(uni))

Solution (Python):
N = int(input())
str_list = set()

for i in range(N):
    n = input()
    if n in str_list:
        continue
    else:
        str_list.add(n)
print(len(str_list))

Solution (Python):
n = int(input())
a = []
for i in range(n):
    a.append(input())
print(len(set(a)))

Solution (Python):
myset = set()
N = int(input())
for i in range(N):
    s = input()
    myset.add(s)
print(len(myset))

Solution (Python):
from collections import Counter
n = int(input())
s_list = []
for i in range(n):
    s_list.append(input())
s_counter = Counter(s_list)
most_s = s_counter.most_common()
print(len(most_s))

Solution (Python):

N = int(input())
ss = []
for i in range(N):
  ss.append(input())
  
print(len(set(ss)))

Solution (Python):
n=int(input())
l={}

for i in range(n):
  l[input()]=1

print(len(l))

Solution (Python):


item = set()
for _ in range(int(input())):
    item.add(input())

print(len(item))

Solution (Python):
n = int(input())
k = set()

for i in range(n):
  s = input()
  k.add(s)

print(len(k))

Solution (Python):
n = int(input())
li=[]
for _ in range(n):
  li.append(input())

print(len(set(li)))

Solution (Python):
n = int(input())
s_list = {}
count = 0
for i in range(n):
    s = input()
    if not s in s_list:
        s_list[s]=0
        count+=1
print(count)

Solution (Python):
n = int(input())
s = {}
for _ in range(n):
    s[input()] = 1

print(len(s))

Solution (Python):
N = int(input())
s = [input() for i in range(N)]

s = set(s)
print(len(s))

Solution (Python):
N=int(input())
S=[str(input()) for i in range(N)]

S_set=set(S)
print(len(S_set))

Solution (Python):
N = int(input())

ans = {}
for _ in range(N):
    S = input()
    ans[S] = 1

print(len(ans))

Solution (Python):
if __name__ == '__main__':
    n = int(input())
    elements = set()

    for _ in range(n):
        w = input()
        elements.add(w)

    print(len(elements))

Solution (Python):
n = int(input())
l = [input() for _ in range(n)]
a = set(l)
print(len(a))

Solution (Python):

N = int(input())







S = [input() for _ in range(N)]
print(len(set(S)))

Solution (Python):
inputLine = input()

numInput = int(inputLine)
outputSet = set()

for index in range(numInput) :

	inputLine = input()

	if inputLine not in outputSet :
		outputSet.add(inputLine)

print(len(outputSet))

Solution (Python):
n = int(input())
set = set()
for i in range(n):
    set.add(input())
print(len(set))

Solution (Python):
n=int(input())
s = [input() for _ in range(n)]
print(len(set(s)))

Solution (Python):
keihin = int(input())

keihin_list = []
for i in range(keihin):
    keihin_list.append(input())

print(len(set(keihin_list)))

Solution (Python):

N = int(input())

S_list = []
for i in range(N):
  
  S = input()
  S_list.append(S)
  
S_list = set(S_list)
S_list = list(S_list)


print(len(S_list))

Solution (Python):
N = int(input())
S = [input() for _ in range(N)]
print(len(set(S)))

Solution (Python):
def main():
    n = int(input())
    s = [input() for i in range(n)]
    import numpy as np
    s = np.unique(s)
    print(len(s))

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())

S = []
counter = 0
for i in range(N):
    S.append(input())

S = sorted(S)
for i in range(N-1):
    if S[i] == S[i+1]:
        counter += 1
print(N - counter)

Solution (Python):
import sys
N = int(sys.stdin.readline())
data = sys.stdin.readlines()
L = [x.strip("\n") for x in data]
print(len(list(set(L))))

Solution (Python):
n = int(input())

s = []
for i in range(n):
	s.append(input())

print(len(set(s)))

Solution (Python):
N = int(input())
S = {input() for i in range(N)}
print(len(S))

Solution (Python):

import sys
input = sys.stdin.readline

N = int(input())
s = set()

for i in range(N):
   strA = str(input())
   s.add(strA)

print(len(s))

Solution (Python):
n = int(input())
res = [input() for i in range(n)]
res_ = list(set(res))

print(len(res_))

Solution (Python):
n = int(input())
ml = list(input() for _ in range(n))
print(len(set(ml)))

Solution (Python):
n = int(input())

s = set()
for _ in range(n):
    s.add(input())
print(len(s))

Solution (Python):
N_input = int(input())



str = set()
for i in range(N_input):
    str.add(input())
print(len(str))

Solution (Python):
n = int(input())
import collections
s = []
for i in range(n):
    s.append(input())
c = collections.Counter(s)
print(len(c))

Solution (Python):
N = int(input())

freebies_list = [input() for i in range(N)]
freebies_set = set(freebies_list)

print(len(freebies_set))

Solution (Python):
n = int(input())
li = []
count = 0
for i in range(n):
    li.append(input())
li.sort()
for i in range(n-1):
    if li[i] == li[i+1]:
        count += 1
print(n-count)

Solution (Python):
from collections import Counter
n=int(input())
l=[input() for i in range(n)]
c=Counter(l)
print(len(c))

Solution (Python):
N = int(input())
S = []
for _ in range(N):
    S.append(input())
new_S = list(set(S))
print(len(new_S))

Solution (Python):
import numpy as np
import collections


n = int(input())
s = [input() for _ in range(n)]

c = collections.Counter(s)
print(len(c))

Solution (Python):
N = int(input())
tList = []
for i in range(N):
    A = input()
    tList.append(A)
print(len(set(tList)))

Solution (Python):
N=int(input())
Acquisition=[]

for i in range(N):
    S=input()
    Acquisition.append(S)

Acquisition_unique=list(set(Acquisition))
print(len(Acquisition_unique))

Solution (Python):
N = int(input())
S = []
count = 0
for i in range(0, N):
    s = input()
    S.append(s)

S.sort()

for i in range(0, N - 1):
    if S[i] == S[i+1]:
        count += 1

ans = len(S) - count
print(str(ans))

Solution (Python):
N = int(input())
s = [input() for i in range(N)]

b = len(set(s))
print(b)

Solution (Python):




def main():
    N = int(input())
    S = [input() for _ in range(N)]
    print(len(set(S)))


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    N = int(input())
    S = [input() for _ in range(N)]

    print(len(set(S)))

main()

Solution (Python):
N=int(input())
goods=[]

for i in range(N):
    item=input()
    goods.append(item)

print(len(list(set(goods))))

Solution (Python):
n = int(input())
ls = []
count = 0
for x in range(n):
    ls.append(input())
ls = set(ls)
print(len(ls))

Solution (Python):
n=int(input())
d=dict()

for i in range(n):
  s="".join(input())
  
  if s in d:
    d[s]+=1
  else:
    d[s]=1
ans=0
for x in d.values():
  ans+=1
print(ans)

Solution (Python):

N = int(input())

m = {}
for i in range(N):
    l = input()
    m[l] = ""

print(len(m))

Solution (Python):
n=int(input())
st=set()
for i in range(n):
  s=input()
  st.add(s)
print(len(st))

Solution (Python):
N = int(input())
S =[0] * N
for i in range(N):
    S[i] =input()
SS = set(S)
print(len(SS))

Solution (Python):
N=int(input())
List=[input() for i in range(N)]
print(len(list(set(List))))

Solution (Python):
N=int(input())
freebies={}
count=0

for i in range(N):
    S=input()
    if not S in freebies:
        freebies[S]=True
        count+=1

print(count)

Solution (Python):
N = int(input())
S = {input() for i in range(N)}
print(len(S))

Solution (Python):
n = int(input())
s = [input() for _ in range(n)]

cnt = len(set(s))
if cnt <= n:
    print(cnt)
else:
    print(n)

Solution (Python):
N = int(input())

presents = []

for i in range(N):
    present = input()
    presents.append(present)
print(len(set(presents)))

Solution (Python):
import collections

N = int(input())
S_list = []

for i in range(N):
  S_list.append(input())
  
c = collections.Counter(S_list)
print(len(c))

Solution (Python):
N = int(input())
S = []
for _ in range(N):
    S.append(input())

cnt = 1
S = sorted(S)
s_1 = S[0]
for s in S[1:]:
    if s_1 != s:
        cnt += 1
        s_1 = s

print(cnt)

Solution (Python):
n=int(input())
s=[input() for i in range(n)]
s=set(s)
print(len(s))

Solution (Python):
N=int(input())
Set = set()
for i in range(N):
    S=input()
    Set.add(S)

print(len(Set))

Solution (Python):
n = int(input())
s= set()
for i in range(n):
  s.add(input())
print(len(s))

Solution (Python):
n=int(input())
mdic={}
for i in range(0,n):
  st=input()
  mdic[st]=i+1
print(len(mdic))

Solution (Python):
N=int(input())
S=[]
for i in range(N):
    S.append(input())
print(len(set(S)))

Solution (Python):
N = int(input())
S = [input() for i in range(N)]

set_s = set(S)
print(len(set_s))

Solution (Python):
import collections

n = int(input())
s_list = []
for i in range(n):
    s_list.append(input())

c = collections.Counter(s_list)
print(len(c))

Solution (Python):
import collections
print(len(collections.Counter([input() for i in range(int(input()))])))

Solution (Python):
a=int(input())
l=[]
for i in range(a):
    b=input()
    l.append(b)
l=set(l)
print(len(l))

Solution (Python):
import collections
N = int(input())
S = [str(input()) for _ in range(N)]
c=collections.Counter(S)
print(len(c))

Solution (Python):
n = int(input())
s = []
for i in range(n):
    s.append(input())
print(len(list(set(s))))

Solution (Python):
num=int(input())
s = [input() for i in range(num)]
print(len(set(s)))

Solution (Python):
def main():
    N=int(input())
    S=[input() for i in range(N)]
    print(len(set(S)))

main()

Solution (Python):
n = int(input())
s = [input() for _ in range(n)]
d = {}
total=0
for i in s:
    d[i]= 1
    
for key in d.keys():
    total+=1
print(total)

Solution (Python):
N = int(input())
S = set()
for i in range(N):
    S.add(input())
print(len(S))

Solution (Python):
N = int(input().strip())
S = [input().strip() for _ in range(N)] 
print(len(set(S)))

Solution (Python):
import collections

N = int(input())

List = [input() for i in range(N)]

c = collections.Counter(List)

print(len(c))

Solution (Python):
n = int(input())
s = set([input() for i in range(n)])
print(len(s))

Solution (Python):
import collections
n = int(input())
s = [input() for i in range(n)]
print(len(collections.Counter(s)))

Solution (Python):
n = int(input())
string_list = [input() for i in range(n)]
string_set = set(string_list)
print (str(len(string_set)))

Solution (Python):
n = int(input())
cnt = 0
dict = {}

while cnt < n:
    s = input()
    dict[s] = True
    cnt += 1

res = 0
for i in dict:
    res += 1

print(res)

Solution (Python):
n=int(input())
s=set()
for i in range(n):s.add(input())
print(len(s))