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

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *




























def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

inf = float('inf')
mod = 1000000007




def main():
	N = inputInt()
	S = {}

	ans = 0
	for i in range(N):
		tmp = input()
		tmp = tmp[:-1]
		tmptmp = tmp[0]

		if tmp in S:
			continue
		else:
			S[tmp] = 1
			ans += 1

	print(ans)






def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

if __name__ == "__main__":
	main()

Solution (Python):


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


result = len(set(S))


print(result)

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

item = list(set(item))
print(len(item))

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

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

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

print(len(set(name_list)))

Solution (Python):
def gacha(sl):
    print(len(set(sl)))

n = int(input())
sl = []
for _ in range(n):
    sl.append(input())


gacha(sl)

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

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

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

print(len(set(l)))

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

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

print(len(set(S)))

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

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

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

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

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

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

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

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

s_set = set(s)

print(len(s_set))

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

print(len(gacha_list))

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

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

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

from collections import Counter

cnt = Counter(S)

print(len(cnt))

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

kind = 1
S.sort()
s_old = S[0]
for i in range(1,N):
    if S[i] != s_old:
        kind += 1
    s_old = S[i]

print(kind)

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

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

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

S = set(S)

print(len(S))

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

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

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

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

prizes = [input() for _ in range(N)]

prizes_set = set(prizes)
print(len(prizes_set))

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

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

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

print(len(set(s_list)))

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

print(len(set(array)))

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

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

a_unique = list(set(a))

print(len(a_unique))

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

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

print(len(set(s)))

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

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

print(ans)

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

print(len(d))

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

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

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

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

Solution (Python):
n=int(input())
d=dict()
for _ in range(n):
    s=input()
    if s not in d:
        d[s]=0

print(len(d))

Solution (Python):


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

Goods=dict()
res=0
for s in S:
	if s not in Goods:
		Goods[s]=1
		res+=1
print(res)

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

import collections
print(len(collections.Counter(S)))

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

    A.sort()
    count = 1
    if N != 1:
        for i in range(1, N):
            if A[i - 1] != A[i]:
                count += 1
    print(count)


if __name__ == '__main__':
    solve()

Solution (Python):
from sys import stdin
import math
import fractions

n = int(stdin.readline().rstrip())

s = [0] * n

for i in range(n):
    s[i] = stdin.readline().rstrip()

result = {}
for ss in s:
    result[ss] = 1

print(len(result))

Solution (Python):
N = int(input())
ret = {}
for i in range(N):
    ret[input()] = 0
print(len(ret.keys()))

Solution (Python):

"""
@author: H_Hoshigi
"""
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())
strs=set()
for i in range(0,n):
    temp=input()
    strs.add(temp)
print(len(strs))

Solution (Python):
n = int(input())
look_up = {}
for i in range(n):
    item = input()
    if item in look_up:
        look_up[item] += 1
    else:
        look_up[item] = 0

print(len(look_up))

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

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

Solution (Python):
import collections

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

c= collections.Counter(list)

m=0
for i in c.values():
    m+=1

print(m)

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

print(len(set(s)))

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

print(ans)

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

from collections import Counter


n = int(input())
S = [input().strip() for _ in range(n)]

COUNTS = Counter(S)

print(len(COUNTS))

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

S = set()

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

print(len(S))

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

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

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

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

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

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

goods=[]

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

print(len(set(goods)))

Solution (Python):
n = int(input())
s = set(input() for _ in range(n))
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())

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

print(len(set(string_list)))

Solution (Python):
import collections
N = int(input())
S = [str(input()) for _ in range(N)]
k = collections.Counter(S)
ans = 0
for k in k.keys():
    ans += 1
print(ans)

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

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

Solution (Python):


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

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

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

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

dic = {}

for gift in gift_lis:
    if gift in dic:
        dic[gift] += 1
    else:
        dic[gift] = 1

n = 0

for num in dic:
    n += 1

print(n)

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

S = list(set(S))

print(len(S))

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

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

if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
S = [input() for i 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())
reword =list()
for i in range(N):
    reword.append(input())

print(len(set(reword)))

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

Solution (Python):
n = int(input())
lst = []
ans = 1

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

lst.sort()

pre = lst[0]
for s in lst[1:]:
  
  if pre != s:
    ans += 1
  pre = s
  
print(ans)

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

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

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

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

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

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

print(len(set(keihin)))

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

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

print(len(list(set(s_list))))

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

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

print(len(keihin))

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

import collections

c = collections.Counter(S)

print(len(c))

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

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

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

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

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

Solution (Python):
from math import *
from copy import *
from string import *				
from random import *
from sys import stdin
from sys import maxsize
from operator import *				
from itertools import *
from collections import Counter		
import math

def bin1(l,r,k,t,b,val,ans):
	if(l>r):
		return ans
	else:
		mid=(l+r)//2
		v=k**mid
		if(v==val):
			return v
		elif(v>val):
			ans=mid
			return bin1(mid+1,r,k,t,b,val,ans)
		else:
			return bin1(l,mid-1,k,t,b,val,ans)
		
def bin2(l,r,k,t,b,val,ans):
	if(l>r):
		return ans
	else:
		mid=(l+r)//2
		v=t*(k**mid)+b*(mid)
		if(v==val):
			return v
		elif(v>val):
			ans=mid
			return bin2(l,mid-1,k,t,b,val,ans)
		else:
			return bin2(mid+1,r,k,t,b,val,ans)

def SieveOfEratosthenes(n): 
      
    
    
    
    prime = [True for i in range(n+1)] 
    p = 2
    while (p * p <= n): 
          
        
        if (prime[p] == True): 
              
            
            for i in range(p * p, n+1, p): 
                prime[i] = False
        p += 1
    l=[]
    for i in range(2,n+1):
    	if(prime[i]):
    		l.append(i)
    return l
def bin(l,r,ll,val):
	if(l>r):
		return -1
	else:
		mid=(l+r)//2
		if(val>=ll[mid][0] and val<=ll[mid][1]):
			return mid
		elif(val<ll[mid][0]):
			return bin(l,mid-1,ll,val)
		else:
			return bin(mid+1,r,ll,val)
def deci(n):
	s=""
	while(n!=0):
		if(n%2==0):
			n=n//2
			s="0"+s
		else:
			n=n//2
			s="1"+s
	return s
def diff(s1,s2):
	if(len(s1)<len(s2)):
		v=len(s1)
		while(v!=len(s2)):
			s1="0"+s1
			v=v+1
	else:
		v=len(s2)
		while(v!=len(s1)):
			s2="0"+s2
			v=v+1
	c=0
	for i in range(len(s1)):
		if(s1[i:i+1]!=s2[i:i+1]):
			c=c+1
	return c
from sys import stdin, stdout 
def fac(a,b):
	v=a
	while(a!=b):
		v*=a-1
		a=a-1
	return v
def bino(l,r,n):
	if(l>r):
		return -1
	else:
		mid=(l+r)//2
		val1=math.log((n/mid)+1,2)
		val2=int(val1)
		if(val1==val2):
			return val1
		elif(val1<1.0):
			return bino(l,mid-1,n)
		else:
			return bino(mid+1,r,n)

def binary(l,r,ll,val,ans):
	if(l>r):
		return ans
	else:
		mid=(l+r)//2
		if(val%ll[mid]==0):
			ans=ll[mid]
			return binary(l,mid-1,ll,val,ans)
		else:
			return binary(l,mid-1,ll,val,ans)
def odd(n,ans,s):
	if(n%2!=0 or n in s):
		return ans
	else:
		s.add(n)
		return odd(n//2,ans+1,s)

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

Solution (Python):
from collections import Counter

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

s = Counter(S)
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):
N = int(input())
items = []

for i in range(N):
    item = input()
    items.append(item)    
items.sort()
cnt = 0
before = ""
for index,item in enumerate(items):
    if index == 0:
        cnt += 1    
    elif before != item:
        cnt += 1
    before = item
print(cnt)

Solution (Python):


def main():
    n = int(input())
    set_ = set()
    for i in range(n):
        set_.add(input())

    print(len(set_))


if __name__ == '__main__':
    main()

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())
    hoge = {}
    for _ in range(n):
        s = input()
        hoge[s] = 1
    print(len(hoge.keys()))

if __name__ == '__main__':
    main()

Solution (Python):






"""Module docstring
"""

import functools
import heapq
import itertools
import logging
import math
import random
import string
import sys
from argparse import ArgumentParser
from collections import defaultdict, deque
from copy import deepcopy
from typing import Dict, List, Optional, Set, Tuple


def solve(values: List[int], nb: int) -> int:
    for _v in values:
        pass
    return nb


def do_job():
    "Do the work"
    LOG.debug("Start working")
    
    N = int(input())
    values = set()
    for _ in range(N):
        values.add(input().strip())
    print(len(values))


def print_output(testcase: int, result) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case 
    
    


def configure_log() -> None:
    "Configure the log output"
    log_formatter = logging.Formatter("%(lineno)d - " "%(message)s")
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(log_formatter)
    LOG.addHandler(handler)


LOG = None

if not LOG:
    LOG = logging.getLogger("template")
    configure_log()


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    parser = ArgumentParser()
    parser.add_argument(
        "-v",
        "--verbose",
        dest="verbose",
        action="store_true",
        default=False,
        help="run as verbose mode",
    )
    args = parser.parse_args(argv)
    if args.verbose:
        LOG.setLevel(logging.DEBUG)
    do_job()
    return 0


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    sys.exit(main())


class memoized:
    """Decorator that caches a function's return value each time it is called.
    If called later with the same arguments, the cached value is returned, and
    not re-evaluated.
    """

    def __init__(self, func):
        self.func = func
        self.cache = {}

    def __call__(self, *args):
        try:
            return self.cache[args]
        except KeyError:
            value = self.func(*args)
            self.cache[args] = value
            return value
        except TypeError:
            
            
            return self.func(*args)

    def __repr__(self):
        """Return the function's docstring."""
        return self.func.__doc__

    def __get__(self, obj, objtype):
        """Support instance methods."""
        return functools.partial(self.__call__, obj)

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

if __name__ == '__main__':
    main()

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

ans = len(set(lst))

print(ans)

Solution (Python):
import math
N = int(input())
di = {}
count = 0
for i in range(N):
    word = input()
    if word not in di:
        di[word] = 1
        count += 1
    else:
        di[word] += 1
print(count)

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

S_list = []
for i in range(0,n) :
  S_list.append(input())
  
x = len(set(S_list))
print(x)

Solution (Python):






import sys,bisect
sys.setrecursionlimit(15000)

n = int(sys.stdin.readline())
a = [sys.stdin.readline() for _ in range(n)]

import collections
c = collections.Counter(a)
print(len(c))

Solution (Python):
import collections

N=int(input())

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

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

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

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

Solution (Python):
n = input()

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

ans = set(all)
print(len(ans))

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

a = []
for _ in range(n):
  a.append(input())

print(len(set(a)))

Solution (Python):
if __name__ == "__main__":
    count = 0
    num = int(input())
    lotteryList = []
    for i in range(0,num):
        lotteryList.append(str(input()))

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

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

print(len(s))

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

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

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

print(len(set(s)))

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

resolve()

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

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

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

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

print(len(P))

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

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

print(len(Ss))

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

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

Solution (Python):
if __name__ == "__main__":
    
    
    
    
    
    
    N = int(input())
    d = [str(input()) for _ in range(N)]
    print(len(set(d)))

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

Solution (Python):
import sys

n = int(input())

s = [None]*n

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

syugou = list(set(s))

ans = len(syugou)

print(ans)

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

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

print(len(shurui))

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

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

print(len(set(S)))

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

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

Solution (Python):
n = int(input())
dict = {}
for i in range(n):
    x = input()
    dict[x]=1
print(len(dict))

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

print(len(sSet))

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

from collections import Counter

c = Counter(S)

print(len(c))

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

for _ 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 = set(s)
print(len(s_set))

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

print(len(set(S)))

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

S = set(S)

print(len(S))

Solution (Python):
N = int(input())
o = {}
for _ in range(N):
    o.setdefault(input(), "")
print(len(set(o)))

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

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

l2 = collections.Counter(l)

print(len(l2))

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
from collections import Counter
N=int(sys.stdin.readline().strip())
S=[ sys.stdin.readline().strip() for _ in range(N) ]
C=Counter(S)
print len(C)

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

print(len(set(list)))

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

for _ in range(N):
    s = input()
    ans.add(s)
print(len(ans))

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

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

print(len(S))

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

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

print(len(set(k)))

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

d = Counter(s_l)
print(len(d))

Solution (Python):
from collections import Counter

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

print(len(Counter(l)))

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

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

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

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

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

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

s = set()

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

print(len(list(s)))

Solution (Python):
import collections

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


c = collections.Counter(S)

print(len(c))

Solution (Python):
if __name__ == '__main__':
    s = {"",""}
    s.clear()
    n = int(input())
    for i in range(0,n):
        s.add(input())
    print(len(s))

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

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

counter = set([])

for i in range(N):
    si = input()
    if si not in counter:
        counter.add(si)

print(len(counter))

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

prize = set()

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

print(len(prize))

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

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

print(len(set(r)))

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

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

print(len(set(s)))

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

S_Set=set(S)

print(len(S_Set))

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

print(len(set(s)))

Solution (Python):
import collections

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

Solution (Python):
import sys

N=int(input())

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

print(len(S))

Solution (Python):
import sys
input = sys.stdin.readline
def print_ans(N, ar):
    """Test Case
    >>> print_ans(3, ["apple", "orange", "apple"])
    2
    >>> print_ans(5,["grape" ,"grape" ,"grape" ,"grape" ,"grape"])
    1
    """
    print(len(set(ar)))
    

if __name__ == '__main__':
    N = int(input().rstrip())
    ar = [input().rstrip() for _ in range(N) ]
    print_ans(N, ar)

Solution (Python):
n = int(input())
dic = {}
for _ in range(n):
    f = input()
    if f in dic.keys():
        dic[f] += 1
    else:
        dic[f] = 1
print(len(dic))

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.append(input())
print(len(set(s)))

Solution (Python):
n = int(input())
s = [list(input().split()) for i in range(n)]
import numpy as np
s2 = np.ravel(s)
print(len(set(s2)))

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

print(len(set(arr)))

Solution (Python):

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

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())
a=[input() for i in range(n)]
print(len(set(a)))

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

Solution (Python):


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

    sortS = sorted(S)


    count = 0
    for i in range(len(sortS)):
        if i == 0:
            count += 1
            continue
        else:
            if sortS[i-1] == sortS[i]:
                continue
            else:
                count += 1

    print(count)








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 = []*N
k = 1
for i in range(N):
  j = input()
  S.append(j)
S.sort()
for i in range(N-1):
  if S[i] != S[i+1]:
    k += 1
print(k)

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

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

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

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