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

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

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

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

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

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

Solution (Python):
print(len({*open(0)}) - 1)

Solution (Python):
print(len(set(open(0))) - 1)

Solution (Python):
print(len(set(open(0).read().split())) - 1)

Solution (Python):
def readinput():
    n=int(input())
    sList=[]
    for _ in range(n):
        sList.append(input())
    return n,sList

def main(n,sList):
    keihin={}
    for s in sList:
        if s in keihin:
            keihin[s]+=1
        else:
            keihin[s]=1
    return len(keihin)

if __name__=='__main__':
    n,sList=readinput()
    ans=main(n,sList)
    print(ans)

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

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

Solution (Python):

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

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

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

print(len(set(A)))

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

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

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

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

s = {}

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

print(len(s.keys()))

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

Solution (Python):
N = int(input())
M_Dict = {}
for i in range(N):
    Current_M = str(input())
    if Current_M in M_Dict:
        M_Dict[Current_M] += 1
    else:
        M_Dict[Current_M] = 1
        

print(len(M_Dict))

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

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

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


if __name__ == '__main__':
    main()

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())
k = set()

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

print(len(k))

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


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

if __name__ == "__main__":
    main()

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

print(len(S))

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

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

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

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

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

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

lst = set()
for _ in range(n):
  j = input()
  if j not in lst:
    lst.add(j)
print(len(lst))

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

ans = set([])
for _ in range(n):
    ans.add(input())

print(len(ans))

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

print(len(s))

Solution (Python):
Row = int(input())
List = []
for i in range (Row):
  List.append(input())
s_l = set(List)
print(len(s_l))

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

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

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

ans = set()

for i in range(N):
    S = input()
    if S in ans:
        continue
    else:
        ans.add(S)

print(len(ans))

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

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

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



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


if __name__ == "__main__":
    main()

Solution (Python):
if __name__ == "__main__":
    N = int(input())
    hash = {}
    for i in range(N):
        hash[input()] = ""
    print(len(hash.keys()))

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

n = inp()
s = [input() for _ in range(n)]
s.sort()

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

print(ans)

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

print(len(set(s)))

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

T = [input() for i in range(N)]
T.sort()
c = 1
pre = T[0]
for i in range(1,N):
    if T[i] == pre:
        pass
    else:
        c += 1
    pre = T[i]
print(c)

Solution (Python):
import sys, itertools
print(len(set(itertools.islice(sys.stdin.buffer, 1, None))))

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

ans = len(set(S))

print(ans)

Solution (Python):
import sys
import itertools


def resolve(in_):
    return len(set(s.strip() for s in itertools.islice(in_, 1, None)))
    

def main():
    answer = resolve(sys.stdin.buffer)
    print(answer)


if __name__ == '__main__':
    main()

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

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

l = sorted(a)

count = 1
for i in range(n - 1):
    if l[i] != l[i + 1]:
        count += 1
    
print(count)

Solution (Python):
def gacha():
    
    N = int(input())
    S = [input() for _ in range(N)]
    
    freebie_tuple = set(S)
    
    return len(freebie_tuple)

result = gacha()
print(result)

Solution (Python):


def main():

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

    setS = set()

    for i in S:
        setS.add(i)

    ans = len(setS)

    print(ans)


if __name__ == "__main__":
    main()

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

Solution (Python):
from collections import defaultdict
from collections import deque
from collections import OrderedDict
import itertools
from sys import stdin
input = stdin.readline


def main():
  N = int(input())
  set_ = set()
  for i in range(N):
    set_.add(input()[:-1])

  print(len(set_))

if(__name__ == '__main__'):
  main()

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

Solution (Python):


























































global FLAG_LOG
FLAG_LOG = False


def log(value):
    
    
    if FLAG_LOG:
        print(str(value))


def calculation(lines):
    
    N = int(lines[0])
    
    
    
    values = list()
    for i in range(N):
        values.append(lines[i+1])
    
    
    

    tmps = list()
    for value in values:
        tmps.append(value)

    log(list(set(tmps)))
    result = len(list(set(tmps)))

    return [result]



def get_input_lines():
    line = input()
    N = int(line)
    lines = list()
    lines.append(line)
    for _ in range(N):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['3', 'apple', 'orange', 'apple']
        lines_export = [2]
    if pattern == 2:
        lines_input = ['5', 'grape', 'grape', 'grape', 'grape', 'grape']
        lines_export = [1]
    if pattern == 3:
        lines_input = ['4', 'aaaa', 'a', 'aaa', 'aa']
        lines_export = [4]
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    global FLAG_LOG
    if len(args) == 1:
        mode = 0
        FLAG_LOG = False
    else:
        mode = int(args[1])
        FLAG_LOG = True
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines()
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

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

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

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

s = set()

for i in range(n):
    s.add(stdin.readline().rstrip())

print(len(s))

Solution (Python):
N = int(input())
S = list(input() for _ in range(N))
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 = [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):
import collections
N = int(input())
ls = []
for i in range(N):
    ls.append(input())
counter = collections.Counter(ls)
print(len(counter.keys()))

Solution (Python):
N, *S = open(0);print(len(set(S)))

Solution (Python):
N, *S = open(0)
print(len(set(S)))

Solution (Python):
import sys
N = int(input())
S = [str(s) for s in sys.stdin.read().split()]
print(len(set(S)))

Solution (Python):
import sys
from collections import Counter
N = int(input())
S = [str(s) for s in sys.stdin.read().split()]
items = list(dict.fromkeys(S))
print(len(items))

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):
    si = input()
    s.add(si)

print(len(s))

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

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

print(len(S))

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

print(len({input() for _ in range(N)}))

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

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

for x in range(n):
  d[input()]+=1
  
print(len(d))

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

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

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

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

print(len(set(ans)))

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

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

dict = {}

for i in range(n):
    s = input();
    if not s in dict:
        dict[s] = 1

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

print(sum)

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

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

print(len(s_set))

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

newLs = list(set(ls))
print(len(newLs))

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
input = sys.stdin.readline

n = int(input())

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

print(len(se))

Solution (Python):
def main():
    N = int(input())
    s={""}
    for _ in range(N):
        s.add(input())
    
    return len(s)-1

if __name__ == '__main__':
    print(main())

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

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

s=set()

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

print(len(s))

Solution (Python):






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

main()

Solution (Python):
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
a = [None]*n
for i in range(n):
    a[i] = input()
s = set(a)
print(len(s))

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

aaa = {}
for i in range(N):
  aaa[input()] = 1  

print(len(aaa))

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

Solution (Python):


N = int(input())

goods = set()
cnt = 0
for i in range(N):
  S = input()
  if S not in goods:
    goods.add(S)
    cnt += 1
print(cnt)

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

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

print(len(set(s)))

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

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

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

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

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

print(ans)

Solution (Python):
N = int(input())
S = [input() for _ in range(N)]
S.sort()
check = [True]*N
item = ""
item_ = ""
dict_item = {}
cnt = 0

for i in range(N):
  item_ = S[i]
  if item_ != item:
    item = item_
    cnt += 1
print(cnt)

Solution (Python):
import collections

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

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

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

Solution (Python):
import collections

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

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

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

Solution (Python):
import collections

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

c = collections.Counter(S)

ans = 0
for key in c:
    ans += 1

print(ans)

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

Solution (Python):

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

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

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

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

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

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

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

res = set()
for _ in range(N):
    res.add(input())

print(len(res))

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

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

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

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

print(len(S))

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

import collections

x = collections.Counter(list)
y = x.keys()
print(len(y))

Solution (Python):
from math import *

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

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

Solution (Python):
def l_in(type_): return list(map(type_, input().split()))
def i_in(): return int(input())
def m_in(type_): return map(type_, input().split())
def r_in(n, type_): return [type_(input()) for _ in range(n)]
ans = None

n = i_in()
d = {}
for _ in range(n):
    k = input()
    d[k] = 1
ans = len(d)

print(ans)

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

Solution (Python):
import collections

N=int(input())
S=[""]*N
for i in range(N):
  S[i]=input()
print(len(collections.Counter(S)))

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

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

print(len(s))

Solution (Python):
from collections import Counter

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

counter = Counter(S)
print(len(counter.keys()))

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

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


if __name__ == '__main__':
    main()

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

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

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

for i in s:
    myset.add(i)

print(len(myset))

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

Solution (Python):
def main():
    _, *S = open(0)
    print(len(set(S)))
 
 
if __name__ == "__main__":
    main()

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

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

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

print(len(set(S_list)))

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

Solution (Python):
stock = {}
for _ in range(int(input())):
  s = input()
  try:
    stock[s] += 1
  except KeyError:
    stock[s] = 1
print(len(stock))

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

l = []

for _ in range(N):
    l.append(str(input()))
    
c = Counter(l)

print(len(c))

Solution (Python):

from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


def solve():
    N = int(input())
    ans = set()
    for i in range(N):
        s = input()
        ans.add(s)
    print(len(ans))


def main():
    solve()


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import collections

n = int(input())
s = [input() for i in range(n)]
t = collections.Counter(s)

print(len(t))

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

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

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

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

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

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

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

Solution (Python):
n = int(input())
dict = {}
for i in range(0, n) :
    s = input()
    dict[s] = 1

print(len(dict))

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

Solution (Python):
import sys

input = sys.stdin.readline

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

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

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

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

n, s = int(input()), set([])
for i in range(n): s.add(input()[:-1])
print(len(s))

Solution (Python):
n=int(input())
li=[]
res = 1
for i in range(n):
    li += [input()]
la=sorted(li)
for i in range(1,n):
    if la[i-1]!=la[i]:res += 1
print(res)

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




C = dict([s,1] for s in S)
L = len(C)
print(L)

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

cnt = {}
ans =0
for s in ss:
    if s not in cnt:
        cnt[s]=0
        ans += 1
print(ans)

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

Solution (Python):


import io
import sys
import math

def solve():
    
    pass

def main():
    
    n = int(input())
    s_list = []
    for s in range(n):
      s_list.append(input())
    
    
    s_set = set(s_list)
    ans = str( len( s_set) )
    
    
    print(ans)
    return ans
        

_DEB = 0   

_INPUT = """\
5
grape
grape
grape
grape
grape
"""
_EXPECTED = """\
1
"""

def logd(str):
    """usage:
    if _DEB: logd(f"{str}")
    """
    if _DEB: print(f"[deb] {str}")


if __name__ == "__main__":
    if _DEB:
        sys.stdin = io.StringIO(_INPUT)
        print("!! Debug Mode !!")

    ans = main()

    if _DEB:
        print()
        if _EXPECTED.strip() == ans.strip(): print("!! Success !!")
        else: print(f"!! Failed... !!\nANSWER:   {ans}\nExpected: {_EXPECTED}")

Solution (Python):


import io
import sys
import math

def solve():
    
    pass

def main():
    
    n, *a = open(0).read().split()
    
    
    s_list = list(a)
    s_set = set()
    for s in s_list:
      s_set.add(s)
    
    ans = str( len( s_set) )
    
    
    print(ans)
    return ans
        

_DEB = 0   

_INPUT = """\
5
grape
grape
grape
grape
grape
"""
_EXPECTED = """\
1
"""

def logd(str):
    """usage:
    if _DEB: logd(f"{str}")
    """
    if _DEB: print(f"[deb] {str}")


if __name__ == "__main__":
    if _DEB:
        sys.stdin = io.StringIO(_INPUT)
        print("!! Debug Mode !!")

    ans = main()

    if _DEB:
        print()
        if _EXPECTED.strip() == ans.strip(): print("!! Success !!")
        else: print(f"!! Failed... !!\nANSWER:   {ans}\nExpected: {_EXPECTED}")

Solution (Python):


import io
import sys
import math

def solve():
    
    pass

def main():
    
    n, *a = open(0).read().split()
    
    
    s_list = list(a)
    ans = str( len( set(s_list)) )
    
    
    print(ans)
    return ans
        

_DEB = 0   

_INPUT = """\
5
grape
grape
grape
grape
grape
"""
_EXPECTED = """\
1
"""

def logd(str):
    """usage:
    if _DEB: logd(f"{str}")
    """
    if _DEB: print(f"[deb] {str}")


if __name__ == "__main__":
    if _DEB:
        sys.stdin = io.StringIO(_INPUT)
        print("!! Debug Mode !!")

    ans = main()

    if _DEB:
        print()
        if _EXPECTED.strip() == ans.strip(): print("!! Success !!")
        else: print(f"!! Failed... !!\nANSWER:   {ans}\nExpected: {_EXPECTED}")

Solution (Python):


import io
import sys
import math

def solve():
    
    pass

def main():
    
    n = int(input())
    s_set = set()
    for _ in range(n):
        s_set.add(input())
    
    
    ans = str( len(s_set) )
    
    
    print(ans)
    return ans
        

_DEB = 0   

_INPUT = """\
5
grape
grape
grape
grape
grape
"""
_EXPECTED = """\
1
"""

def logd(str):
    """usage:
    if _DEB: logd(f"{str}")
    """
    if _DEB: print(f"[deb] {str}")


if __name__ == "__main__":
    if _DEB:
        sys.stdin = io.StringIO(_INPUT)
        print("!! Debug Mode !!")

    ans = main()

    if _DEB:
        print()
        if _EXPECTED.strip() == ans.strip(): print("!! Success !!")
        else: print(f"!! Failed... !!\nANSWER:   {ans}\nExpected: {_EXPECTED}")

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

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

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

s=[None]*n
for i in range(n):
    s[i]=input()
    
t=set(s)

print(len(t))

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

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

print(len(S))

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

Solution (Python):
n=int(input())
lst=set([])
counter=0
for _ in range(n):
    s=input()
    if s in lst : continue
    lst.add(s)
    counter+=1

print(counter)

Solution (Python):
n, *a = open(0).read().split()
print(len(set(a)))

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

Solution (Python):
import math
import collections
import fractions
import itertools
 
def solve():
    n = int(input())
    s = [input() for i in range(n)]
    print(len(set(s)))
    return 0
 
if __name__ == '__main__':
    solve()

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

Solution (Python):
N = int(input())
C = {}
for _ in range(N):
    s = input().strip()
    if s not in C:
        C[s] = 0
    C[s] += 1
print(len(C))

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

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

Solution (Python):
import math
import collections
import fractions
import itertools

def solve():
    n = int(input())
    s = [input() for i in range(n)]
    print(len(set(s)))
    return 0

if __name__ == '__main__':
    solve()

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

Solution (Python):
from sys import stdin
data = stdin.readlines()

n = int(data[0].split()[0])

l = []
for i in range(n):
    l.append(data[i+1].split()[0])
print(len(set(l)))

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)

def int1(x): return 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 LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')







def solve():
    N = II()
    S = set()
    for i in range(N):
        s = input()
        S.add(s)
    print(len(S))
    

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

Solution (Python):

print(len({*open(0).read().split()}) - 1)

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

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

Solution (Python):



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

Solution (Python):
from collections import deque
n = int(input())
l = deque()
for i in range(n):
    s = input()
    l.append(s)
print(len(set(l)))

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

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