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())
S = set([])
for n in range(N):
  S.add(input())
print(len(S))

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

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

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

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

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

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

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

Solution (Python):
n = int(input())
d = {}
for i in range(n):
    s = input()
    d[s] = d.get(s, 0) + 1
print(len(d))

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

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

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

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

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

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

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

Solution (Python):
from collections import Counter

n = int(input())

string = [input() for i in range(n)]

string.sort()

i = Counter(string)

print(len(i))

Solution (Python):
import sys

N = int(input())
reward = set()
for i in range(N):
    S = input()
    reward.add(S)

print(len(reward))

Solution (Python):

from collections import Counter

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

counter = Counter(S)

print(len(counter.keys()))

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

ans = []

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

print(len(set(ans)))

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

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

Solution (Python):
from collections import Counter

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

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

S = Counter(S)
print(len(S))

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

Solution (Python):
n = int(input())
dic = {}
ans = 0

for _ in range(n):
  x = input()
  if x not in dic:
    ans += 1
    dic[x] = 1


print(ans)

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

print(len(set(S)))

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

s = set([])
for i in range(N):
    str_ = input()
    s.add(str_)

print(len(s))

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

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

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

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

mono = []

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

print(len(set(mono)))

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

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


d = set()
for v in s:
    d.add(v)

print(len(d))

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

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

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

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

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

Solution (Python):
n = int(input())
a = {}
for i in range(n):
    s = input()
    if s not in a:
        a[s] = 1
    else:
        a[s] += 1
print(len(a))

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

Solution (Python):
n = int(input())
d = {}
for _ in range(n):
    s = input()
    if not s in d.keys():
        d[s] = 1
print(len(d))

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

strs = set()

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

print(len(strs))

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

Solution (Python):
n = int(input())
a = set()
for i in range(0, n):
    lst = input()
    a.add(lst)

print(len(a))

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

Solution (Python):
from collections import Counter
N=int(input())
S=[input() for _ in [0]*N]
print(len(Counter(S).items()))

Solution (Python):
import numpy as np

N = int(input())
data_list = []
for i in range(N):
    si = input()
    data_list.append(si)

data_list = np.array(data_list)
print(len(np.unique(data_list)))

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

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

Solution (Python):
N = int(input())
S = [str(input()) for i in range(N)]
gocha = {}
for s in S:
  gocha[s] = 1
print(len(gocha))

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

Solution (Python):
n=int(input())
S=[]
for i in range(n):
    S.append(input())
print(len(list(set(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 = []
for i in range(N):
  s = str(input())
  S.append(s)
T = set(S)
print(len(T))

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

print(len(S))

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

T = set(S)
print(len(T))

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

print(len(s))

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

prise = []
for _ in range(N):
    prise.append(input())

prise = list(set(prise))
print(len(prise))

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

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

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

print(len(list(set(s))))

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

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

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

Solution (Python):
N = int(input())
b=[]
c=[]
for j in range(N):
    a = input()
    b.append(a)



c = set(b)

print(len(c))

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

D =[]

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



print(len(set(D)))

Solution (Python):

import sys
from itertools import chain


def solve(N: int, S: "List[str]"):
    return len(set(S))


def main():
    tokens = chain(*(line.split() for line in sys.stdin))
    N = int(next(tokens))  
    S = [next(tokens) for _ in range(N)]  
    answer = solve(N, S)
    print(answer)


if __name__ == "__main__":
    main()

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

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

Solution (Python):
n = int(input())
from collections import defaultdict
dic = defaultdict(int)
for _ in range(n):
    tmp = input()
    dic[tmp] += 1
print(len(dic))

Solution (Python):

def main():
    n = int(input())
    a = set()
    for i in range(n):
        s = input()
        a.add(s)
    print(len(a))
        

if __name__ == "__main__":
    main()

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

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

S = set(S)
S = list(S)


print(len(S))

Solution (Python):
import sys

N = int(input())
S = set()
for i in range(N):
    S.add(str(input()))


print(len(S))

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

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

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

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

print(len(set(s)))

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

from collections import Counter

c = Counter(str_list)
print(len(c))

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

Solution (Python):


n = int(input())
s = []
c = 1

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

s.sort()

for j in range(1,n):
    if s[j-1] != s[j]:
        c += 1


print(c)

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

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

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



print(len(set(a)))

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


main()

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

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

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

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

print(len(set([input() for i in range(n)])))

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

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

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

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

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

s.sort()

ans = n
for i in range(n-1):
    if s[i] == s[i+1]:
        ans -= 1

print(ans)

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

m = {}
for i in range(n):
  s = input()
  m[s] = True
  
print(len(m))

Solution (Python):
import collections

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

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

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

s = []

for x in range(n):
  mozi = input()
  s.append(mozi)
  
new_s = set(s)

print(len(new_s))

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

print(len(S))

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

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

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


if __name__ == '__main__':
    main()

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

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

S = set(S)
ans = len(S)
print(ans)

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

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

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

Solution (Python):
from collections import Counter

l = []

N = int(input())

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

c = Counter(l)
print(len(c))

Solution (Python):
n = int(input())
dic = {}
for _ in range(n):
  dic[input()] = 0
print(len(dic))

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

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

Solution (Python):
a=int(input())
b=[input() for i in range(a)]
b.sort()
c=0
for i in range(a-1):
  if b[i]==b[i+1]:
    c=c+1
print(a-c)

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

print(len(set(S)))

Solution (Python):
N = int(input())
d = dict()
for i in range(N):
  prize = input()
  if not prize in d:
    d[prize] = 1
print(len(d))

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

s=set(s)

print(len(s))

Solution (Python):
from collections import Counter
N=int(input())
b=0
S=[]

for i in range(0,N):
    S.append(input())
b=Counter(S)
print(len(b))

Solution (Python):

import sys
def input():
    return sys.stdin.readline()[:-1]

def main():
    N = int(input())
    S = {'0'}
    for i in range(N):
        S.add(input())
    print(len(S) - 1)

if __name__ == '__main__':
    main()

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

s = set()


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

print(len(s))

Solution (Python):
N = int(input())
li = list()
for i in range(N):
    li.append(input())

print(len(list(set(li))))

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

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

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

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

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

Solution (Python):
N = int(input())
S = [input() for i in range(N)]
S.sort()
cnt = 1
for i in range(1, N):
    if S[i]!=S[i-1]:
        cnt += 1
print(cnt)

Solution (Python):

N=int(input())
S=list(input() for i in range(N))

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

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

    s_dict = dict()
    for _ in range(n):
        s = input()
        if s in s_dict:
            continue
        else:
            s_dict[s] = 1

    print(sum(s_dict.values()))


if __name__ == "__main__":
    main()

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

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

    print(len(s))


if __name__ == "__main__":
    main()

Solution (Python):
import math
import sys
import os
from operator import mul

sys.setrecursionlimit(10**7)

def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))

if os.getenv("LOCAL"):
    inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
    sys.stdin = open(inputFile, "r")
INF = float("inf")


N = I()
S = [_S() for _ in range(N)]
ans = 0

s = set()

for i in range(N):
    s.add(S[i])

ans = len(s)

print(ans)

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

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

for i in range(x):
  s[i-1] = input()

l = set (s)
length = len(l)

print(length)

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

if '__main__' == __name__:
    resolve()

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

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

print(len(set(S)))

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

Solution (Python):
N = int(input())
s = {}
for i in range(N):
    item = input()
    if item not in s:
        s[item] = 1
print(len(s))

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

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

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input().rstrip())
lis = {}
for _ in range(N):
  a = input().rstrip()
  if a in lis:
    lis[a] += 1
  else:
    lis[a] = 1
print(len(lis))

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

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

print(len(s))

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

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

Solution (Python):
N = int(input())
S = {}
for i in range(N):
    S.update([(input(), 1)])
s = S.keys()
print(len(s))

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

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

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

Solution (Python):
N = int(input())
s = set()
for _ in range(N):
    S = input()
    if S in s:
        continue
    else:
        s.add(S)
print(len(s))

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

ans = len(set(A))

print(ans)

Solution (Python):
print(len(set(open(0).read().split("\n")))-2)

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

Solution (Python):

import sys
sys.setrecursionlimit(10**9)


INF=10**20
class Counter:
    def __init__(self):
        self.dict = {}

    def add(self,x):
        if x in self.dict: self.dict[x] += 1
        else: self.dict[x] = 1

    def decrement(self,x):
        self.dict[x] -= 1
        if self.dict[x] <= 0:
            del self.dict[x]

    def get_dict(self):
        return self.dict



def solve(N: int, S: "List[str]"):
    counter = Counter()
    for s in S:
        counter.add(s)
    
    print(len(counter.get_dict().keys()))
        
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    S = [next(tokens) for _ in range(N)]  
    solve(N, S)



if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
n=int(input())
dic={}
for i in range(n):
  s=input()
  dic[s]=1
print(len(list(dic.keys())))

Solution (Python):
import sys
N = int(input())
x = set()
for _ in range(N):
    s = sys.stdin.readline()
    x.add(s)
print(len(x))

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

Solution (Python):


ans = set()

n = int(input())
for i in range(n):
    ans.add(str(input()))

print(len(ans))

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

sets = set(list)
ans = len(sets)

print(ans)

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

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

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

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

Solution (Python):
print(len(set([input() for x in range(int(input()))])))

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

A_list = list()

for i in range(N):
    A = input()
    A_list.append(A)

ans = len(set(A_list))
print(ans)

Solution (Python):
N = int(input())
d = {}
for n in range(N):
    s = input()
    d[s] = True
print(len(d))

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

Solution (Python):


def main():
    n = int(input())
    keihin_set = set()
    for i in range(n):
        s = input()
        if not s in keihin_set:
            keihin_set.add(s)
    print(len(keihin_set))
if __name__ == "__main__":
    main()

Solution (Python):


def main():
    n = int(input())
    keihin_list = []
    for i in range(n):
        s = input()
        keihin_list.append(s)
    print(len(set(keihin_list)))

if __name__ == "__main__":
    main()

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

Solution (Python):
def main():
    N = int(input())
    S = [input() for _ in range(N)]
    dict = {}
    ans = 0
    for i in range(N):
        if S[i] in dict:
            continue
        else:
            dict[S[i]] = 1
            ans += 1

    return ans

print(main())

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

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

print(len(S))

Solution (Python):
from collections import Counter

N = int(input())

S_list = []

for i in range(N):
    str = input()
    S_list.append(str)

print(len(list(Counter(S_list))))

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

Solution (Python):
N = int(input())
dict = {}

for i in range(N):
    dict[input()] = 0

print(len(dict.keys()))

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

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

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

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

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

Solution (Python):
N = int(input())
GACHA={}
for n in range(N):
  g=input()
  GACHA[g]=GACHA.get(g,0)
print(len(GACHA))

Solution (Python):
def Cfun():
    lines = int(input())
    inputLst = []
    for i in range(lines):
        inputLst.append(input())
    itemSets = set(inputLst)
    print(len(itemSets))


Cfun()

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

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=[str(input()) for _ in range(n)]

print(len(set(s)))

Solution (Python):
N=int(input())
S=[]
for i in range(0,N):
    t=str(input())
    S.append(t)
u=set(S)
w=list(u)
print(len(w))

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()

print(len(set(s)))

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

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

li.sort()
last=li[0]

for i in range(1,n):
    if last==li[i]:
        li[i]=0
    
    else:
        last=li[i]

print(n-li.count(0))

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

freebies = []

for _ in range(num_freebies):
    freebies.append(input())

print(len(set(freebies)))

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

l = [input() for _ in range(n)]
print(len(set(l)))

Solution (Python):








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

print(len(set(s)))

Solution (Python):
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))

seen = set()
t = ini()
for _ in range(t):
    s = ins()
    seen.add(s)
print(len(seen))

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

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

s_set = set(s_array)
print(len(s_set))

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


for i in range(N):
	S.add(input())
print(len(S)-1)

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

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

Solution (Python):


def main():
    n = int(input())
    goods = []
    for i in range(n):
        s = input()
        goods.append(s)
    print(len(set(goods)))
    
main()

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

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

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

Solution (Python):
n = int(input())
d = {}
ans = 0
for i in range(n):
  s = input()
  if d.get(s, 0)==0:
    d[s]=1
    ans+=1
print(ans)

Solution (Python):



N = int(input())

S_set = set()

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

ans = len(S_set)

print(ans)

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

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

if __name__ == "__main__":
    solve()

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

ans = set()
for i in range(n):
    ans.add(input())

print(len(ans))

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

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

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

Solution (Python):
N ,*S = open(0).read().split()

s = list(set(S))
print(len(s))

Solution (Python):
import collections
n=int(input())
box=[]
for i in range(n):
    tmp=str(input())
    box.append(tmp)
l=len(collections.Counter(box))
print(l)

Solution (Python):
import numpy as np

if __name__ == "__main__":
    N=input()
    N=int(N)
    l=[]
    for i in range(N):
        buf=input()
        l+=[buf]
    l=np.array(l)
    print(len(np.unique(l)))

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

Solution (Python):
nn = int(input())
ss = [str(input()) for l in range(nn)]
ss.sort()

keihin = 1
for i in range(nn-1):
    if ss[i] != ss[i+1]:
        keihin += 1

print(keihin)

Solution (Python):
from collections import Counter

n = int(input())
s = [input() for _ in range(n)]
data = Counter(s)
print(len(data.keys()))

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

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

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

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

Solution (Python):
import sys


def input():
    return sys.stdin.readline().rstrip()


def main():
    n = int(input())
    items = {input() for _ in range(n)}
    print(len(items))


if __name__ == "__main__":
    main()

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()


def main():
    n = int(input())
    items = {input() for _ in range(n)}
    print(len(items))


if __name__ == "__main__":
    main()

Solution (Python):
import sys
input = sys.stdin.readline


def main():
    n = int(input())
    items = {input().rstrip() for _ in range(n)}
    print(len(items))


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    N = int(input())
    l = []
    for i in range(N):
        l.append(str(input()))
    s_l = set(l)
    print(len(s_l))
main()

Solution (Python):


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

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

print(len(set(S)))

Solution (Python):
c={}
N=int(input())
for i in range(N):
  s=input()
  if s not in c:
    c[s]=0
print(len(c))

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

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

keihin = dict()

for i in range(n):
    s = input()
    if s in keihin:
        keihin[s] += 1
    else:
        keihin[s] = 1
print(len(keihin))

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

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

Solution (Python):

def main():
    N = int(input())

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


if __name__ == '__main__':
    main()

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

print(len(set(S)))

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

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

s = set()

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

print(len(s))

Solution (Python):
import collections

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

c = collections.Counter(S)

print(len(c.keys()))

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

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

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

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

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

Solution (Python):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines

def main():
    n = int(input())
    s = [input() for _ in range(n)]
    s = set(s)
    r = len(s)
    print(r)


if __name__ == '__main__':
    main()

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

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

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

print(len(set(S)))

Solution (Python):
N=int(input())
d={}
for _ in range(N):
  d[input()]=1
print(len(d))

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

for i in s:
    ans.add(i)

print(len(ans))

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

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

Solution (Python):
from collections import defaultdict
N = int(input())
d = defaultdict(int)
for i in range(N):
    d[input()] += 1
print(len(d.keys()))

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

a = [input()for i in range(N)]
c = collections.Counter(a)
print(len(c.keys()))

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

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

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

print(len(S))

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

S=[]
for i in range(n):
    S.append(input())
    
S.sort()
c=1
for i in range(n-1):
    if S[i]!=S[i+1] :
        c+=1
print( c )

Solution (Python):
scnum = int(input())
word = [0]*scnum
for i in range(scnum):
    word[i] = input()
word.sort()
answer = 1

for j in range(scnum-1):
    if word[j] != word[j+1]:
        answer += 1
print(answer)