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):
from collections import Counter

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

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

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

l = list(set(S))

print(len(l))

Solution (Python):
import collections
N=int(input())
count=0
a=[]
while N>0:
  a.append(input())
  N=N-1
c=collections.Counter(a)
print(len(c))

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

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

Solution (Python):
N =int(input())
keihin ={}
ans = 0
for _ in range(N):
    S = input()   
    keihin[S] = 1


print(sum(keihin.values()))

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

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

Solution (Python):
N = int(input())
dic = {}
for i in range(0, N):
  keyName = input()
  if keyName not in dic:
    dic[keyName] = 0
print(len(dic.keys()))

Solution (Python):
N = int(input())
L = set()
for _ in range(N):
    s = input()
    if s in L:
        pass
    else:
        L.add(s)

print(len(L))

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

Solution (Python):
import sys
a = []
for l in sys.stdin:
    a.append(l.rstrip('\n'))
a.pop(0)
b = list(set(a))
print(len(b))

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

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

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

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

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

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

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

Solution (Python):

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

print(len(list(set(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())
List=[input() for i in range(N)]
A=set(List)
print(len(A))

Solution (Python):



                            
                            
                            
                            



import sys
import math as mt


def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))

def printwsp(*args): return print(*args, end="")
def printsp(*args): return print(*args, end=" ")
def printchk(*args): return print(*args, end="tst, ")

MOD = int(1e9+7); BABYMOD = 998244353;


d = dict()
for _testcases_ in range(int(input())):
    s = input()
    d[s] = 1
ans  = 0
for k, v in d.items():
    ans += 1
print(ans)



'''
THE LOGIC AND APPROACH WAS DEVELOPED BY ME @luctivud.
SOME PARTS OF THE CODE HAS BEEN TAKEN FROM WEBSITES LIKE::
(I Own the code if no link is provided here or I may have missed mentioning it)
PLEASE DO NOT PLAGIARISE.
'''

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

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())
items=[]
for i in range(N):
  items.append(input())
print(len(set(items)))

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

count = []

for _ in range(N):
    temp = input()
    count.append(temp)
    
count = set(count)

print(len(count))

Solution (Python):
import collections

n = int(input())

s = []
for _ in range(n):
    s_ = input('')
    s.append(s_)

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

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

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

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

Solution (Python):
n = int(input())
a = []
for i in range(n) :
  x = input()
  a.append(x)
a.sort()
p = a[0]
ans = 1
for i in range(1,n) :
  if p != a[i] :
    ans += 1
    p = a[i]
print(ans)

Solution (Python):

def howManyPresent(N):
    seen = []
    for i in range(N):
        p = str(input())
        seen.append(p)
    return len(set(seen))


N = int(input())

print(howManyPresent(N))

Solution (Python):

from collections import deque
from operator import itemgetter
from bisect import bisect_left, bisect
import itertools
import sys
import math
import numpy as np
sys.setrecursionlimit(10**6)
input = sys.stdin.readline


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


if __name__ == '__main__':
    main()

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

dic={}
for i in range(N):
    A=input()
    dic[A]=1
    
print(len(dic))

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

print(len(set(l)))

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

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

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

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

print(len(l))

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

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

print(len(s))

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

Solution (Python):
import collections

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

Solution (Python):

import sys
input = sys.stdin.readline


N = int(input())
S = [input().strip() for i in range(N)]

from collections import Counter
c = Counter(S)
print(len(c))

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

print(len(set(s)))

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

Solution (Python):

def Sol(arr):
    
    print(len(set(arr)))
    return

    



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



Sol(arr)

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

Solution (Python):
import collections

n=int(input())

c=0
s=list()

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


c = collections.Counter(s)

print(len(c))

Solution (Python):
n = int(input())
ans = {}
cnt = n
for i in range(n):
    s = input()
    if s in ans:
        cnt -= 1
    else:
        ans[s] = '1'
print(cnt)

Solution (Python):
n=int(input())
a=set()
while(n):
    s=input()
    a.add(s)
    n-=1
print(len(a))

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

print(len(A))

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

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

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

set_a = set(a)

print(len(set_a))

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

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

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

Solution (Python):
import random

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




print(len(set(m)))

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

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

print(len(set_list))

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

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

print(len(S))

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

print(len(set(list)))

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

S.sort()
ans = 1

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

print(ans)

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

print(len(ss))

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

pre = list(range(N))

for i in range (N):

    pre[i] = input()


ans = set(pre)

print(len(ans))

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

arr = []

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

print(len(set(arr)))

Solution (Python):

def main():
    N = int(input())
    keihin_l = []
    
    for _ in range(N):
        s = input()
        keihin_l.append(s)

    delete_duplicate_list = set(keihin_l)
    out = len(list(delete_duplicate_list))
    print(out)
main()

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

print(len(set(S)))

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

d = dict()

for _ in range(n):
    d[input()] = 1

print(len(d))

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

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

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

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

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

print(len(set(s)))

Solution (Python):
N = int(input())
lottery = []
while len(lottery) < N:
    lottery.append(input())
print(len(set(lottery)))

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

print(len(set(p_list)))

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())
list=[input() for i in range(n)]
c = collections.Counter(list)
print(len(c))

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

print(len(s_uni))

Solution (Python):
tmp = input().split()
N = int(tmp[0])

ListG = []

for i in range(N):
    ListG.append(input().split())

ListG.sort()
p = 1
for i in range(N-1):
    if ListG[i] == ListG[i+1]:
        continue
    else:
        p = p +1

print(p)

Solution (Python):
import sys
import math
from collections import deque
input = lambda: sys.stdin.readline().rstrip()
Yes = lambda boolean: print('Yes') if boolean else print('No')
YES = lambda boolean: print('YES') if boolean else print('NO')
aint = lambda: int(input())
ints = lambda: list(map(int, input().split()))
is_even = lambda x: True if x%2==0 else False

n = aint()
get = []
for i in range(n):
    s = input()
    get.append(s)
ss = set(get)
print(len(ss))

Solution (Python):
def resolve():
    import sys
    input = lambda: sys.stdin.readline().rstrip()
    r = [0] * int(input())
    print(len({input() for _ in r}))

if __name__ == "__main__":
	resolve()

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

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

print(len(set(list)))

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

print(len(S))

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

print(len(set(string_list)))

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

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

Solution (Python):
from collections import Counter
n=int(input())
s=[input() for i in range(n)]
k=0
kinds=Counter(s)
for i in kinds.values():
    k+=1
print(k)

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

Solution (Python):
from collections import Counter

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

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


if __name__ == "__main__":
  resolve()

Solution (Python):
num = int(input())
product_list = []

for _ in range(num):
  product_list.append(input())

print(len(set(product_list)))

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

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

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

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

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

Solution (Python):


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

while N > 0:
    S = input()
    p_list.append(S)
    N -= 1

p_set = (set(p_list))
print(len(p_set))

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

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

sets = set(list)
print(len(sets))

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

def histogram_sorted(data):
    table = []
    prev = data[0]
    c = 1 
    for i in range(1,len(data)):
        if prev == data[i]:
            c=c+1
        else:
            table.append([prev,c])
            prev = data[i]
            c = 1
    table.append([prev,c]) 
    return table

T = []
for i in range(N):
    T.append(S[i])
    
    
print(len(histogram_sorted(sorted(T))))

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

print(len(set(a)))

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

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

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

Solution (Python):
import collections

n = int(input())
s = [input() for i 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(set(S)))

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

Solution (Python):
import collections

num = int(input())
keihin = [input() for i in range(num)]
shurui = collections.Counter(keihin)

print(len(shurui.values()))

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

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

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

print(len(check_dict.keys()))

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


dic={}

for i in range(N):
  x=input()
  if x in dic:
    dic[x]+=1
  else:
    dic[x]=1
    
print(len(dic))

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

Solution (Python):

import sys

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

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

Solution (Python):
nums = int(input())
keihin = []

for i in range(0,nums):
  word = input()
  keihin.append(word)

print(len(list(set(keihin))))

Solution (Python):
issues = set()

N = int(input())

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

print(len(issues))

Solution (Python):
N = int(input())
L = []
for n in range(N):
    L.append(str(input()))
L = sorted(L)

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

Solution (Python):
N=int(input())
hash = {}
count=0
for _ in range(N):
    s=input()
    if s in hash:
      continue
    else:
      hash[s]=1
      count+=1
print(count)

Solution (Python):
import collections

ts = int(input())
a = []
for i in range(ts):
    a.append(str(input()))
print(len(collections.Counter(a)))

Solution (Python):
import sys

if __name__ == "__main__":
    N = int(input())
    data = set()
    for _ in range(N):
        data.add(sys.stdin.readline().rstrip())
    print(len(data))

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

bbb = list(set(aaa))

ans = len(bbb)

print(ans)

Solution (Python):
N=int(input())
x=0
a=list()
while x<N:
    a.append(input())
    x=x+1
print(len(set(a)))

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

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

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

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

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

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

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

print(ans)

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

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

Solution (Python):
n = int(input())
s = []
p = set()
ans = 0
for i in range(n):
    s.append(input())
    if s[i] in p:
        pass
    else:
        p.add(s[i])
        ans += 1
print(ans)

Solution (Python):
import collections
N = int(input())
S = list()
for i in range(N):
    S.append(str(input()))
c = collections.Counter(S)
values,counts = zip(*c.most_common())
print(len(values))

Solution (Python):
import collections

N = int(input())

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

T = collections.Counter(S)
print(len(T.keys()))

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

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

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

Solution (Python):


def main():
    s = set()
    n = int(input())
    for _ in range(n):
        s.add(str(input()))
    print(len(s))
    
    
if __name__ == '__main__':
    main()

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

k = []

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

print(len(set(k)))

Solution (Python):


n = int(input())
S = set(input() for _ in range(n))

print(len(S))

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

for i in range(n):
    word = input()
    if word not in dic:
        dic[word]=1
        s += 1
print(s)

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

sc = list(set(s))

print(len(sc))

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

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

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

itemCount = 0
itemList = {}

for i in range(N):
  item = input()
  if item in itemList:
    continue
  else:
    itemCount += 1
    itemList[item] = item

print(itemCount)

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

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

kind={}
for each in s:
    if each in kind.keys():
        kind[each]+=1
    else:
        kind[each]=1

print(len(kind.keys()))

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

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

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

for _ in range(N):
    prize = input()
    prize_num = 0
    for i,p in enumerate(prize[::-1]):
        prize_num += 26**i * ord(p)
    P.append(prize_num)

P.sort()
now=-1
count = 0
for p in P:
    if not p==now:
        now=p
        count+=1

print(count)

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

Solution (Python):
l = input()

s = []

for _ in range(int(l)):
    s.append(input())



print(len(set(s)))

Solution (Python):



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

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

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

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

Solution (Python):
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
N = int(input())
S = []
for i in range(N):
    S.append(input())

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

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

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):
gachaNum=int(input())
items=set()
for i in range(gachaNum):
    items.add(input())

print(len(items))

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

print(len(s))

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

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



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


print(len(S))

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

print(len(set(lotteries)))

Solution (Python):
import collections
N = int(input())
s = [input() for i in range(N)]
c = collections.Counter(s)
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())
s = [input() for i in range(n)]

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

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

gift = dict()



for i in range(i):
  value = input()
  
  
  if gift.get(value) == None:
    gift[value] = 1
  else:
    gift[value] += 1



print(len(gift))

Solution (Python):
n=int(input())
dic=dict()
while n:
  temp=input()
  if temp not in dic:
    dic[temp]=1
  n-=1
print(len(dic))

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

Solution (Python):

import math


def main():

    
    first_input = list(map(lambda x:int(x), input().split(" ")))
    

    
    
    

    
    

    N = first_input[0]

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

    print(len(set(keihin)))

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

kind = []

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

print(len(set(kind)))

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

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

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

count = len(list(set(a)))
print(count)

Solution (Python):
N = int(input())
S = ["" for _ in range(N)]
num = 1
for i in range(N):
  S[i] = input()
List = sorted(S)
for j in range(N-1):
  if List[j] != List[j+1]:
    num += 1
print(num)

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

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

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

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





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

Solution (Python):
import collections

def main():
    N = int(input())
    s = [input() for i in range(N)]
    c = collections.Counter(s)
    print(len(c))
if __name__ == '__main__':
    main()

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

Solution (Python):



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

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


print(len(set(list)))

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

Solution (Python):
from collections import defaultdict

N = int(input())

goods = defaultdict(lambda: 0)

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

print(len(goods))

Solution (Python):
n = int(input())
s_lst = []

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



print(len(set(s_lst)))

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

LST=[]


for i in range(a):
  LST.append(input())

Kekka=list(set(LST))  
print(len(Kekka))

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

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

Solution (Python):
raw_input = input().split()
n = int(raw_input[0])
items = [input().strip() for _ in range(n)]
items = set(items)
print(len(items))

Solution (Python):
from collections import Counter
N = int(input())
S = [0]*N
for i in range(N):
    S[i]=input()
C = Counter(S)
print(len(C))

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

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

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

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

print(len(set(S)))

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

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

Solution (Python):
def main():
    import collections
    n = int(input())  
    lis = [input() for _ in range(n)]
    print(len(collections.Counter(lis)))



if __name__ == '__main__':
    main()

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

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

keihin_dict = {}
for i in range(N):
  keihin = input()
  keihin_dict[keihin] = 1
  
print(len(keihin_dict))

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

S = []

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

S.sort()

result=1

for i in range(1, len(S)):
    if S[i-1] != S[i]:
        result += 1

print(result)

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

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

Solution (Python):


n = int(input())

mylist = [input() for i in range(n)]
output = list(set(mylist))

print(len(output))

Solution (Python):


itemsList={}
num=int(input())
for i in range(num):
    temp=input()
    if not temp in itemsList:
        itemsList[temp]=1
print(len(itemsList))

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

B=set(A)

print(len(B))

Solution (Python):
n = int(input())
a = []

for i in range(n):
    a.append(input())
    
print(len(set(a)))

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

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

Solution (Python):
N = int(input())
keihin =[]
cnt = 0
for i in range(N):
    keihin.append(str(input()))

print(len(set(keihin)))

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

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

Solution (Python):
n = int(input())
si=[]
for i in range(0,n):
    si0 = input()
    si.append(si0)
    
kekka=list(set(si))
print (len(kekka))

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

Solution (Python):





n=int(input())
ans=0
q=[]
for i in range(n):
    x=input()
    
        
    q.append(x)
w=set(q)
ans=len(w)
print(ans)

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

s=[]

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

S=set(s)

print(len(S))

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

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

print(len(set(l)))

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

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

print(len(set(str_list)))

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

Solution (Python):
import collections
N = int(input())
hoge = [0 for i in range(0,N)]
for i in range(0,N):
    hoge[i] = (input())
c = collections.Counter(hoge)
print(len(c.keys()))

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

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

n = int(input())

Li = [input() for _ in range(n)]
Li.sort()
s= Li[0]
c =1
for l in Li[1:]:
    if l == s:
        pass
    else:
        c+=1
        s = l
print(c)

Solution (Python):
import sys
input()
print(len(set(sys.stdin.readlines())))

Solution (Python):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
MOD = 10**9 + 7

n = INT()
res = []
for i in range(n):
    s = input()
    res.append(s)
res = list(set(res))

print(len(res))

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

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

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

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

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