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

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

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

print(len(set(S_list)))

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

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

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

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

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

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

Solution (Python):
n = int(input())
d = {}
for i in range(n):
    s = input()
    d.setdefault(s,1)
    
print(len(d))

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

print(len(set(S)))

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

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

print(len(ss))

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

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

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

Solution (Python):


import math

N = int(input())
S = ["" for i in range(N)]
for i in range(N):
    S[i] = input()
    
S.sort()

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

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

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

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

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

print(len(item))

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

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

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

print(len(s))

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

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

s = set()

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

Solution (Python):
import numpy as np

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

    print(np.unique(S).shape[0])


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    n = int(input())
    ans_dist = {}
    for _ in range(n):
        ans_dist[input()] = 0
    print(len(ans_dist.keys()))


if __name__ == '__main__':
    main()

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

mydic = {}
for n in range(N):
    mys = input()
    if mys not in mydic:
        mydic[mys] = 1
    else:
        mydic[mys] += 1
print(len(mydic))

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    N = int(input())
    S = [input() for _ in [0] * N]

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


main()

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

ans = set(S)

print(len(ans))

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

s = set()

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

print(len(s))

Solution (Python):

n=int(input())
d=dict()
for i in range(n):
    si=input()
    if si in d:
        d[si]=d[si]+1
    else:
        d[si]=1
        
print(len(d))

Solution (Python):

import sys


def solve(N: int, S: "List[str]"):
    s = set()

    for thing in S:
        s.add(thing)

    print(len(s))
    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):
def main():
    n = int(input())
    s = {input() for _ in range(n)}
    print(len(s))
if __name__ == "__main__":
    main()

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

print(len(list(set(info))))

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

Solution (Python):
import collections

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

c = collections.Counter(s)

print(len(c))

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())
S=set()
for i in range(n):
   s=input()
   if s not in S:
      S.add(s)
print(len(S))

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

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

Solution (Python):
from collections import Counter

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

c = Counter(s)

print(len(c))

Solution (Python):
n = int(input().strip())
L=set()
[L.add(input().strip()) for _ in range(n)]
print(len(L))

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

print(len(set(s)))

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

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

print(len(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())
s = {input()}
for i in range(n-1):
    s.add(input())

print(str(len(s)))

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

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

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

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

Solution (Python):
N = int(input())
S = [str(input()) for i in range (N)]
S.sort()
k = 0
for i in range (N - 1):
    if S[i] == S[i + 1]:
        k += 1
print(N - k)

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

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

ss = []

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

ss.sort()

ans = 1

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

print(ans)

Solution (Python):


from pprint import pprint
from collections import deque, defaultdict
import sys

sys.setrecursionlimit(10 ** 6)
inf = float("inf")

n = int(input())
s = defaultdict(str)
for _ in range(n):
    key = input()
    s[key] = 1

print(len(dict(s)))

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

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

Solution (Python):
import collections

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

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

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

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

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

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

print(len(set(s)))

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

Solution (Python):
set2=set()
N=int(input())
ans=0
for i in range(N):
  s=input()
  if not s in set2:
    ans+=1
    set2.add(s)
print(ans)

Solution (Python):
n = int(input())
S = set()
for i in range(n):
  S.add(input())
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 i in range(n):
    s.add(str(input()))

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

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

newli = list(set(li))
print(len(newli))

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

print(len(shugo))

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

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

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

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

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

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


def log(*args):
    print(*args, file=sys.stderr)


all = set()

N = int(input())
for _ in range(0, N):
    all.add(input())
print(len(all))

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

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

ans = len(set(S))
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):
    s.add(input())

print(len(s))

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

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

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

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

ans = 0
input_list = []
for i in range(n): input_list.append(input())
for i in set(input_list):
    ans += 1
print(ans)

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

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

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

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

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

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
from collections import Counter

N = int(input())
print(len(Counter([input() for _ in range(N)])))

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

print(len(s))

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


def MI(): return map(int, input().split())


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def debug(table, *args):
    ret = []
    for name, val in table.items():
        if val in args:
            ret.append('{}: {}'.format(name, val))
    print(' | '.join(ret), file=sys.stderr)


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    N = I()
    m = defaultdict(int)

    for i in range(N):
        m[S()] += 1

    print(len(m.keys()))


if __name__ == '__main__':
    main()

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

    S_set = set(S_list)
    print(len(S_set))

if __name__ == "__main__":
    resolve()

Solution (Python):

import sys
input = sys.stdin.readline

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

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

Solution (Python):
x=set()
c=0
n=int(input())
for i in range(0,n):
  s=input()
  if s in x:
    pass
  else:
    x.add(s)
    c+=1
print(c)

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

Solution (Python):


N = int(input())
S = set()

for _ in range(N):
    test = input()
    if test not in S:
        S.add(test)

print(len(S))

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

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

Solution (Python):
from collections import Counter

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

print(len(Counter(s)))

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

print(len(set(s)))

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

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

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

Solution (Python):
N = int(input())
data = set()
count = 0
for _ in range(N):
    line = input()
    if not line in data:
        data.add(line)
        count += 1

print(count)

Solution (Python):
import sys
from pprint import pprint

N = int(sys.stdin.readline().strip())
items = set()
for _ in range(N):
    items.add(sys.stdin.readline().strip())

print(len(items))

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
N = int(input())
S = [input() for _ in range(N)]

print(len(set(S)))

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

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

Solution (Python):

from collections import Counter

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

c = Counter(s)

print(len(c))

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


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

ans = len(kinds)
print(ans)

Solution (Python):
N = int(input())
ans = 0
dict = {}
for i in range(N):
    a = input()
    if a not in dict:
        dict[a] = 1
        ans += 1
    else:
        pass
print(ans)

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())
List = [input() for _ in range(N)]
Con = Counter(List)
print(len(Con))

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

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

Solution (Python):
import sys
from random import choice,randint
inp=sys.stdin.readline
out=sys.stdout.write
flsh=sys.stdout.flush
 
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
 
def MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()]
def LF(): return [float(x) for x in inp().strip().split()]
def LS(): return inp().strip().split()
def I(): return int(inp().strip())
def F(): return float(inp().strip())
def S(): return inp().strip()
def pf(s): return out(s+'\n')
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)

def main():
    from collections import Counter
    n=I()
    l = []
    for i in range(n):
        s = S()
        l.append(s)
    z = Counter(l)
    print(len(z))

if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
def main():
    n, *s = open(0).read().split()
    t = set(s)
    ans = len(t)
    print(ans)


if __name__ == '__main__':
    main()

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

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

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

print(len(set(kuzi)))

Solution (Python):


n = int(input())

a = {}
for x in range(n):
    s = input()
    a[s] = 1

print(len(a.keys()))

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

print(len(set(s)))

Solution (Python):
N = int(input())
lst = [input() for _ in range(N)]
s = set()
for prize in lst:
    if prize not in s:
        s.add(prize)
print(len(s))

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

print(len(set(s)))

Solution (Python):
import sys
n = int(sys.stdin.readline())
li = []
for _ in range(n):
  li.append(sys.stdin.readline().strip())
li2 = list(set(li))
print(len(li2))

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

d = defaultdict(int)
for i in range(N):
    key = input()
    d[key] += 1
ans = 0
for key, value in d.items():
    ans += 1
print(ans)

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

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

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

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

print(len(set(lst)))

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

Solution (Python):
from collections import defaultdict

n = int(input())
cnt = defaultdict(int)
for i in range(n):
    s = input()
    cnt[s] += 1

print(len(cnt))

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

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

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

c = Counter(array)
print(len(c))

Solution (Python):
def Main(N, S):
    d = {}
    for s in S:
        if s not in d:
            d[s] = 0
        else:
            d[s] += 1
    return len(d)
    
def main():
    N = int(input())
    S = []
    for i in range(N):
        S.append(str(input()))
    print(Main(N, S))

if __name__ == '__main__':
    main()

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

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

while True:
    try:
        s.append(input())
    except:
        break
print(len(set(s)))

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

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

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

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


from collections import defaultdict
d = defaultdict(int)

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

print( len(d) )

Solution (Python):
import sys
input = sys.stdin.readline
def main():
    N = int(input())
    S = [input() for i in range(N)]
    SET = set(S)
    print(len(SET))
    

if __name__ == '__main__':
    main()

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

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

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

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

keihin = set([])

for s in range(N):
    keihin.add(input())
    
print(len(keihin))

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

print(len(set(S)))

Solution (Python):
def input_one_number():
    return int(input())

def input_multiple_number():
    return map(int, input().split())

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


N = input_one_number()

listS = []
import hashlib
for i in range(N):
	listS.append(input())

print(len(set(listS)))

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

dic = {}

for i in range(n):
    a = str(input())
    if dic.get(a) is None:
        dic[a] = 1
    else:
        dic[a] +=1
    
    
keys = list(dic.keys())
ans = int(len(keys))

print(ans)

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

if __name__ == "__main__":
    main()

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

prise = set()

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

print(len(prise))

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

Solution (Python):
from collections import Counter

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

s = Counter(s)
print(len(s))

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

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

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

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

print(len(set(S)))

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

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

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

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

print(len(t))

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

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

print(count)

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

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

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

Solution (Python):

import sys

N = int(input())

dic = {}
for i in range(N):
    S = input()
    if S not in dic:
        dic[S] = 1

print(len(dic.keys()))

Solution (Python):
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))


N = INT()
prize = set()

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

print(len(prize))

Solution (Python):




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


if __name__ == '__main__':
    main()

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

Solution (Python):

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

Solution (Python):
import sys,math,copy,queue,itertools,bisect,collections
sys.setrecursionlimit(10**7)
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
INF = 10**18
MOD = 10**9 + 7
DD = ((1,0),(0,1),(-1,0),(0,-1))
n = NI()
s = [sys.stdin.readline().rstrip() for _ in range(n)]
s = set(s)
print (len(s))

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

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

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

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

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

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

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

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

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

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

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

print(len(jisyo))

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

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())
output = [0]*N

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

print(len(set(A)))

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

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

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

Solution (Python):
import sys
import math
from collections import Counter
import itertools



def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")



N=II()
S={SR() for _ in range(N)}

print(len(S))

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

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

Solution (Python):
n=input()
a=[]
for i in range(n):
	a+=[raw_input()]

print len(set(a))

Solution (Python):
import sys
import itertools
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
a=int(input())

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

slist=set(list)

print(len(slist))

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

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

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

Solution (Python):
from collections import defaultdict

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

count = 0
d = defaultdict(int)

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

print(len(d))

Solution (Python):
from collections import Counter

def main():
    n = int(input())
    t = []
    for _ in range(n):
        t.append(input())
    c = Counter(t)
    print(len(c))

if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
import math
from collections import deque
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def S(): return sys.stdin.readline()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h,w): return [[i for j in range(w)] for k in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)

MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)


N = I()
l = [input() for i in range(N)]
d = {}
ans = 0
for item in l:
    if item in d:
        continue
    else:
        ans += 1
        d[item] = 1
        continue
print(ans)

Solution (Python):


int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]


def solve():
    n = II()

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


if __name__ == '__main__':
    solve()

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

print(len(st))

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

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

cnt = len(set(s))

print(cnt)

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

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

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

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

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

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


print(len(s))

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


def main():
    N = int(input())
    S = []
    for _ in range(N):
        s = input()[:-1]
        S.append(s)
    
    print(len(set(S)))


if __name__ == '__main__':
    main()

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