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

Solution (Python):


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

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

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

Solution (Python):
def resolve():
    from collections import defaultdict
    n = int(input())
    d = defaultdict(int)
    c = ()
    for i in range(n):
        d[input()] += 1
    print(len(d))


if __name__ == '__main__':
    resolve()

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

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

print(len(set(s)))

Solution (Python):
















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

sets = set(rows)

print(len(sets))

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

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

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

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

get.sort()
ans = 0
for i in range(N):
    if get[i] != get[i+1]:
        ans += 1
print(ans)

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

ans = set(s)

print(len(ans))

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


print(len(set(L)))

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque

from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush


def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]



n=I()
strs=[]
for i in range(n):
    strs.append(input().rstrip())
u=Counter(strs)

ans=n
for i in u.values():
    ans-=i-1
print(ans)

Solution (Python):
N = int(input())
S = [''] * N

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

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

s = set()

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

print(len(s))

Solution (Python):
N = [int(i) for i in input().split()][0]
Sn = [input() for _ in range(N)]
print(len(set(Sn)))

Solution (Python):
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())


ans = len(set(S))


print(ans)

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

Solution (Python):
import math

n = int(input())

d = set()

for _ in range(n):
    d.add(input())

print(len(d))

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

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

word_list = []
for i in range(n):
    word_list.append(str(input()))

print(len(set(word_list)))

Solution (Python):
from collections import defaultdict

n = int(input())
d = defaultdict(bool)
for i in range(n):
    d[input()] = True

print(len(d))

Solution (Python):
def main():
    from builtins import int, map, list, print, len
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = sys.stdin.readline
    input_list = (lambda: input().rstrip().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

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

if __name__ == '__main__':
    main()

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

s={}
cnt=0

for i in range(n):
  a=str(input())
  if a in s:
    continue

  else:
    s[a]=1
    cnt+=1

print(cnt)

Solution (Python):
import collections

if __name__ == '__main__':
	 N = int(input())
	 ls = []
	 for _ in range(N):
	 	ls.append(input())
	 c = collections.Counter(ls)

	 print(len(c))

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

print len(set(a))

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

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

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

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

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

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


if __name__ == "__main__":
    main()

Solution (Python):
from collections import defaultdict

N = int(input())
S_dic = defaultdict(int)

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

print(len(S_dic))

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

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

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

print(len(prizes))

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

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

print(len(S))

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

Solution (Python):
print(len({input().strip() for _ in range(int(input().strip()))}))

Solution (Python):
def q3():
    n = int(input())
    d = {}
    for i in range(n):
        name = input()
        d[name] = 0
    print(len(d.keys()))

q3()

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)


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


main()

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

Solution (Python):
k = []

n = int(input())
for _ in range(n):
    k.append(input())

print(len(set(k)))

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

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

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

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

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

if __name__ == '__main__':
    main()

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

d = {}

for i in range(N):
  word = input()
  d[word] = 1

print(len(d))

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

S=sorted(S)
count=1

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

print(count)

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

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

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

Solution (Python):




import sys
input = sys.stdin.readline



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

    Sset = set(S)

    res = len(Sset)

    print(res)



main()

Solution (Python):
inputs = open(0).readlines()
n = int(inputs[0])
S = [s.strip() for s in inputs[1:]]
print(len(set(S)))

Solution (Python):
import collections


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

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

    group = collections.Counter(S)

    ans = 0
    for key in list(group):
        ans += 1

    print(ans)


resolve()

Solution (Python):
s = list(map(int, input().split()))
n=s[0]
di={}
for i in range(n):
    s = input().split()
    di[s[0]]=0
print(len(di))

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

Solution (Python):


from sys import stdin
import sys

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


print(len(set(S)))

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

    print(len(s))

if __name__ == '__main__':
    solve()

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

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

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

from collections import Counter
dic = Counter(s)

print(len(dic))

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

print(len(set(s)))

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

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

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

fruit = []
for i in range (A):
    S = str(input())
    fruit.append(S)
    
print(len(set(fruit)))

Solution (Python):
import collections
import sys
sys.setrecursionlimit(2000000)




n = int(input())


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

s_count = collections.Counter(s)

print(len(s_count))

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 = []
for _ in range(n):
    S.append(input())

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

Solution (Python):
from collections import Counter

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

cnt = len(list(Counter(S).values()))

print(cnt)

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

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

count = 0
tmp = ''
for i in range(N):
    if tmp != NList[i]:
        count += 1
    tmp = NList[i]
       
print(count)

Solution (Python):


import sys
import math
import time

import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq
import itertools








n = int(input())
S = [str(input()) for x in range(n)]
S_set = set(S)
ans = 0

print(len(S_set))

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

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10**6)
readline = sys.stdin.readline

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


if __name__ == "__main__":
    main()

Solution (Python):
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


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

if __name__ == '__main__':
    main()

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

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

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

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

print(len(st))

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

gift = list()
for i in range(N):
    gift.append(input())
gift_set = set(tuple(gift))
print(len(gift_set))

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

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

print(len(set(s)))

Solution (Python):
from collections import Counter

n = int(input())
c = Counter(input() for _ in range(n))
print(len(c))

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

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

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

ab = list(set(ab))
print(len(ab))

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

print(len(s))

Solution (Python):

n = int(input())
dic = {}
for i in range(n):
    s = input()
    dic.setdefault(s, 1)
k = 0
for x in dic.values():
    k += x
print(k)

Solution (Python):

import sys



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



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

if __name__ == '__main__':
    main()

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

print(len(S))

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

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

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

item=dict()
count=0
for i in range(n):
  s=input()
  if item.get(s)==None:
    count+=1
    item[s]=1
  else:
    item[s]+=1

print(count)

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

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

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

C = Counter(ans)

print(len(set(ans)))

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

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

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

Solution (Python):
N = int(input())
dic = {}
for _ in range(N):
    dic.setdefault(input(), "hoge")

print(len(dic))

Solution (Python):

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

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

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

print(len(set(S)))

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

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

S = []

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


print(len(set(S)))

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

S_dict = dict()
for i in range(N):
    S = input()
    if S in S_dict:
        S_dict[S] += 1
    else:
        S_dict[S] = 1
        
print(len(S_dict))

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

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

print(len(set(Sli)))

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

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

Solution (Python):

from decimal import *
from itertools import permutations, combinations,combinations_with_replacement,product
import math


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


l = sorted(l)

last = ''
counter = 0
for i in range(N):
    if(l[i] != last):
        counter += 1
    last = l[i]

print(counter)

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

Solution (Python):
def solve():
    ims = {}
    for itm in s:
        if not itm in ims:
            ims[itm]=1
    print(len(ims))
    return


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

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

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

main()

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

Solution (Python):

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

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

print(count)

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

abc164_c()

Solution (Python):
from sys import stdin

def main():
    n = int(input())
    lst = list(set([stdin.readline()[:-1] for _ in range(n)]))
    print(len(lst))

if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin

N = int(stdin.readline().rstrip())
Ss = []
for i in range(N):
    s = stdin.readline().rstrip()
    Ss.append(s)

print(len(set(Ss)))

Solution (Python):
from collections import defaultdict

if __name__ == "__main__":
    n = int(input())
    s = list()
    for i in range(n):
        s.append(input())

    prise = defaultdict(int)

    for ss in s:
        prise[ss] += 1

    print(len(prise))

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

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

print(len(kind))

Solution (Python):
import sys
import math
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
from scipy.sparse import csr_matrix
import itertools
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

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

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

Solution (Python):
import sys
import math

from collections import Counter


input = sys.stdin.readline

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

c=Counter(Keihin)
print(len(list(c.keys())))

Solution (Python):
"""
    Template written to be used by Python Programmers.
    Use at your own risk!!!!
    Owned by enraged(rating - 5 star at CodeChef and Specialist at Codeforces).
"""
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest, _heapify_max, _heapreplace_max
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction



mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(var): sys.stdout.write(str(var))
def outln(var): sys.stdout.write(str(var)+"\n")
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]


dp = dd(int)
for i in range(int(data())):
    dp[data()] += 1
outln(len(dp))

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

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

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

Solution (Python):
def solve(s):
    return len(set(s))


if __name__ == "__main__":
    print(solve([input() for x in range(int(input()))]))

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

Solution (Python):
from collections import Counter
n = int(input())
items = Counter([input() for _ in range(n)])

print(len(items))

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

a = {}

for _ in range(n):
  s = input()
  a[s] = a.get(s, 0) + 1
  
print(len(a.keys()))

Solution (Python):
import math
import queue

def readInt():
	return int(input())

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

def readChars():
	return input().split()

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

print(len(set(s)))

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

Solution (Python):
import math
import collections


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


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


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


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

Solution (Python):
import sys
input=sys.stdin.readline
n=int(input())
L=list(input() for i in range(n))
print(len(set(L)))

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

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

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

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

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

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

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

Solution (Python):
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

n = inn()
s = set([])
for i in range(n):
    s.add(ins())
print(len(s))

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

unique = set()

for s in S:
    unique.add(s)

print(len(unique))

Solution (Python):

import sys


def solve(N: int, S: "List[str]"):
    print(len(list(set(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):
N = int(input())
S = []
for i in range(N):
  k = input()
  S.append(k)
Sset = set(S)
print(len(Sset))

Solution (Python):


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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)


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


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

    print(len(set(Ss)))


if __name__ == '__main__':
    main()

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

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

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

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

S = {}

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

ans = 0
for i in S:
    ans += 1

print(ans)

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

S = set(S)

print(len(S))

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

print(len(re))

Solution (Python):
if __name__ == '__main__':
    from sys import stdin
    input = stdin.readline

    n = int(input())
    a = set()
    for _ in range(n):
        a.add(input()[:-1])
    print(len(a))

Solution (Python):

import sys


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

    for i in S:
        s.add(i)
    
    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):
N = int(input())
S = [str(input()) for _ in range(N)]

Set = set()

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

print(len(Set))

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

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

Solution (Python):
def main():
    from collections import Counter
    n=int(input())
    s=[input() for _ in range(n)]
    print(len(Counter(s)))
if __name__=="__main__":
    main()

Solution (Python):
import itertools

def solve():
  n = int(input())
  s = []
  for i in range(n):
    s.append(input())
  print(len(set(s)))
  return 0
 
if __name__ == "__main__":
  solve()

Solution (Python):
n = int(input())
ls = [[]]*n

import sys 

input = sys.stdin.readline
for i in range(n):
  ls[i] = input()
  
print(len(set(ls)))

Solution (Python):
N = int(input())
P = {}
for _ in range(N):
  P[input()] = 1
print(sum(P.values()))

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

print(len(set(S)))

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

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

Solution (Python):
from collections import Counter
c = Counter()
n = int(input())
for _ in range(n):
    c[input()] += 1
print(len(c.keys()))

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n=INT()
    s=[]
    for i in range(n):
        s.append(STR())
    s=set(s)
    print(len(s))
if __name__ == '__main__':
    do()

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

s=[]

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


a=set(s)

print(len(a))

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

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

Solution (Python):
if __name__ == '__main__':
    a = int(input())
    list = []

    for i in range(a):
        s = input()
        list.append(s)
    setList = set(list)
    print(len(setList))

Solution (Python):
import sys
import os
import math
import string

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: x * y / math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = ii()
    S = isn(N)
    print(len(set(S)))


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

def resolve():
    N = int(input())
    gacha = {input() for _ in range(N)}
    print(len(gacha))

if __name__ == "__main__":
    resolve()

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

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

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

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

print(len(s))

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

ans=list(set(l))
print(len(ans))

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

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