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 = set()
for k in range (N):
    i = input()
    s.add(i)
print(len(s))

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

gifts_count = {}
for gift in s_gifts:
    if not gift in gifts_count:
        gifts_count[gift] = 0
    gifts_count[gift] += 1

print(len(gifts_count.keys()))

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

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

print(len(set(S)))

Solution (Python):
from collections import Counter
 
N = int(input())
S = {}
for i in range(N):
  S[i] = input()
print(len(Counter(S.values()).keys()))

Solution (Python):
from collections import Counter
 
N = int(input())
S = {}
for i in range(N):
  S[i] = input()
print(len(Counter(S.values()).keys()))

Solution (Python):

def main():
    _, *S = open(0)
    print(len(set(S)))


if __name__ == "__main__":
    main()

Solution (Python):
from collections import Counter
 
N = int(input())
S = {}
for i in range(N):
  S[i] = input()
print(len(Counter(S.values()).keys()))

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

Solution (Python):
n=int(input())
dict={}
sum=0
for i in range(n):
    s=input()
    if s not in dict.keys():
        dict[s]=1
        sum+=1
print(sum)

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

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

print(len(s))

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

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

Solution (Python):
import sys
input=sys.stdin.readline
n=int(input())
S=[input().strip() for _ in range(n)]
print(len(set(S)))

Solution (Python):
from collections import Counter
 
N = int(input())
S = [input() for _ in range(N)]
print(len(Counter(S).keys()))

Solution (Python):

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

from decimal import *




























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

inf = float('inf')
mod = 1000000007




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

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

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

	print(ans)






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


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

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



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

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

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

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

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

if __name__ == "__main__":
	main()

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

Solution (Python):

def main():
    _, *S = open(0).read().split()
    print(len(set(S)))


if __name__ == "__main__":
    main()

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


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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")


def solve():
    n = II()
    s = SR(n)
    print(len(set(s)))
    return



if __name__ == '__main__':
    solve()

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 _ in range(n)]
print(len(set(s)))

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

Solution (Python):
n = int(input())
s = set(input() for _ 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())
counter = 0
s = "TEMP"
list = []
temp = ''

while n > 0:
  s = input()
  list.append(s)
  n = n - 1

list.sort()
for item in list:
  if item == temp:
    counter = counter - 1
  counter = counter + 1
  temp = item

print(counter)

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

print(len(set(s)))

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
aint = lambda: int(input())
n = aint(); get = []
for _ in range(n):
  inp = input()
  get.append(inp)
s = set(get)
print(len(s))

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

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

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

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

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

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

Solution (Python):
import sys
from collections import Counter


def main():
  scan = sys.stdin.readline
  
  n = int(scan().rstrip())
  s = [scan().rstrip() for _ in range(n)]
  
  print(len(Counter(s)))


if __name__ == "__main__":
  main()

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

print(len(set(S)))

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

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

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

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

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

Solution (Python):
def main():

    N = int(input())

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

    now_name = S[0]
    ans = 1
    for i in range(N):
        if now_name != S[i]:
            ans += 1
            now_name = S[i]
    
    print('{}'.format(ans))



if __name__ == '__main__':
    main()

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

n = int(readline())
s = [readline().rstrip().decode() for _ in range(n)]
print(len(set(s)))

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

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

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

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

print(c_gacha())

Solution (Python):
n = int(input())
s = []
'''
t = s
for i in range(n):
    s.append(str(input()))
ans = n
for i in range(n-1):
    for j in range(i+1, n):
        if s[j] == s[i]:
            ans -= 1
            del t[j]
print(ans)
print(len(t))
'''
for i in range(n):
    s.append(str(input()))
sa = set(s)
print(len(sa))

Solution (Python):
def c_gacha():
    N = int(input())
    Prizes = [input() for _ in range(N)]
    return len(set(Prizes))

print(c_gacha())

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

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

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

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

Solution (Python):
import sys
import collections

n = int(sys.stdin.readline().strip())
data = []

for x in range(n):
    data.append(input())

print(len(collections.Counter(data)))

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

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

print(len(set(input() for _ in range(N))))

Solution (Python):
def main():
    N = int(input())
    S = [str(input()) for i in range(N)]
    print(len(set(S)))
if __name__ == '__main__':
    main()

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

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

ans = n

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

print(ans)

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

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

print(len(kind_set))

Solution (Python):

a = int(input())
l = [input() for i in range(a)]
print(len(set(l)))

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

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

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

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):
  string = input()
  S.append(string)
S = sorted(S)
count = N
for i in range(N-1):
  if S[i] == S[i+1]:
    count -= 1
print(count)

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

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

Solution (Python):
myset = set()

N = int(input())

for i in range(N):
  x = input()
  myset.add(x)
    
print(len(myset))

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

d = {}
for _ in range(N):
    S = input()
    d.setdefault(S, 0)
    d[S] += 1
print(len(d.keys()))

Solution (Python):
n = int(input())
obj= []
for i in range (n):
	obj.append(input())
dictOfElems = dict()
for elem in obj:
  if elem in dictOfElems:
    dictOfElems[elem] += 1
  else:
    dictOfElems[elem] = 1
print(len(dictOfElems))

Solution (Python):


import sys
sys.setrecursionlimit(300000)


def solve(N: int, S: "List[str]"):
    s = set(S)
    ret = len(s)
    print(ret)
    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(1, N+1):
        S_i = input()
        S.append(S_i)
A = set(S)
print(len(A))

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

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
from collections import defaultdict
n = int(readline())
lst1 = []
dic1 = defaultdict(int)
for i in range(n):
    dic1[readline().rstrip().decode('utf-8')] += 1
print(len(list(dic1.values())))

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 _ in range(n):
    s.append(input())

s2 = list(set(s))


print(len(s2))

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

Solution (Python):
n = int(input())
obj= []
for i in range (n):
	obj.append(input())
dictOfElems = dict()
for elem in obj:
  if elem in dictOfElems:
    dictOfElems[elem] += 1
  else:
    dictOfElems[elem] = 1
print(len(dictOfElems))

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

Solution (Python):
N = int(input())
a = list()
p = list()
for x in range(N):
    a.append(input())
p=set(a)
print(len(p))

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

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

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

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

for i in range(N):
  input_line = input()
  if input_line not in gacha_list:
    gacha_list.add(input_line)
    
print(len(gacha_list))

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

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

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

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


import collections

c = collections.Counter(List)

print(len(c))

Solution (Python):
import collections

n = int(input())
a = [input() for i in range(n)]
b = collections.Counter(a)
print(len(b))

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

for _ in range(N):
    L.append(input())
def counter(array):
    from collections import Counter
    return list(Counter(array).most_common())

c = counter(L)
print(len(c))

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

Solution (Python):
import math

def main():
    n = input()
    s = {}
    while int(n)>0:
        m = input()
        if m in s:
            s[m]+=1
        else:
            s[m]=1
        n = int(n) - 1
    print(len(s))
    return 0

main()

Solution (Python):
n = int(input())
s = []
for i in range(n):
    s += map(str, input().split())
print(len(set(s)))

Solution (Python):
from collections import Counter
n=int(input())
lst=[]
k=n
while(n>0):
    t=input("")
    lst.append(t)
    n-=1
distinct_list= (Counter(lst).keys())
print(len(distinct_list))

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

sc = Counter(s)
sc = list(sc.items())

print(len(sc))

Solution (Python):

N = int(input())


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


print(len(set(gift_list)))

Solution (Python):

N=int(input())


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


print(len(set(gift)))

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

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

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

Solution (Python):
a=int(input())
l=[]
for _ in range(a):
  b=input()
  l.append(b)
l=list(dict.fromkeys(l))
print(len(l))

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

i = 0
item_list = []

while i < N:
  item = input()
  item_list.append(item)
  i += 1


print(len(set(item_list)))

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

Solution (Python):
n=input()
n=int(n)
i=0
d=dict()
while i<n:
	s=input()
	d[s]=d.get(s,0)+1
	i+=1
print(len(d.keys()))

Solution (Python):



class Main:
    N = int(input());
    s = set([input() for i in range(N)]);
    print(len(s))

Solution (Python):
n = int(input())
A=set()
B=set()

for i in range(n):
	s = input()
	if len(s)>=5:
		A.add(s)
	else:
		B.add(s)
		
print(len(A)+len(B))

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

Solution (Python):
num=int(input())
something=[]
while(num):
    temp=input()
    something.append(temp)
    num-=1
something_set=set(something)
print(len(something_set))

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

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

Solution (Python):
N = int(input())
dic = {}
s = []
for i in range(0,N):
    s = input()
    if not s in dic:
        dic[s] = 1

print(len(dic))

Solution (Python):
t = int(input())
d = {}
cnt = 0
while(t):
  s = input()
  if(s not in d.keys()):
    d[s] = 1
    cnt+=1
  t-=1
print(cnt)

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

Solution (Python):
N=()
S=()
L=[]
N=int(input(""))

for i in range(0,N):
      S=str(input(""))
      L.append(S)

seta=(set(L))
print(len(seta))

Solution (Python):


def cal():
    number = int(input())
    strList = []
    for i in range(number):
        temp = input()
        strList.append(temp)

    count = {}

    for item in strList:
        count[item] = count.get(item, 0) + 1
    print(len(count))


cal()

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

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

s_n = set(s)
m = len(s_n)

print(m)

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

Solution (Python):
newlst = []
lst =[]
m = int(input())
while m > 0:
    a = str(input())
    lst.append(a)
    m = m -1
newlst = list(dict.fromkeys(lst))
print(len(newlst))

Solution (Python):

from collections import Counter
n= int(input())
l=[input()for i in range(n)] 
c=Counter(l)

print(len(c))

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

t_dict = dict()
for i in range(n):
    type_ = input()
    t_dict[type_] =  t_dict.get(type_,1)

    
print(len(t_dict))

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

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

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

print(len(set(S)))

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

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

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

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

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

Solution (Python):

import os,sys,time                   


n = int(input(''))
arr = []

for idx in range(0,n):
    arr.append(input())

arr = list(set(arr))
print(len(arr))

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

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

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

List=[input() for i in range(n)]
List = set(List)

print(len(List))

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

Solution (Python):

loveyou = int(input())
reject= [0] * loveyou
for n in range(0,loveyou):
    reject[n] = input()
sherejected = list(dict.fromkeys(reject))
print(len(sherejected))

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

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

print(len(set(k)))

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

import collections
ans=collections.Counter(s)
print(len(ans))

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

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

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

print(len(set(S_list)))

Solution (Python):
import collections

N = int(input())

l = list()

for i in range(1, N+1):
    l.append(input())

c = collections.Counter(l)

print(len(c))

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

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

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

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

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

word_list = [input() for i in range(n)]
l = len(set(word_list))
        
print(l)

Solution (Python):
from sys import stdin, setrecursionlimit, stdout

from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin
def ii(): return int(stdin.readline())
def fi(): return float(stdin.readline())
def mi(): return map(int, stdin.readline().split())
def fmi(): return map(float, stdin.readline().split())
def li(): return list(mi())
def lsi():
    x=list(stdin.readline())
    x.pop()
    return x
def si(): return stdin.readline().rstrip()

res=['Yes', 'No']

a=set()
for _ in range(ii()):
    a.add(si())
print(len(a))

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

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

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

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

print(len(list(set(p))))

Solution (Python):
n = int(input())
t = []
for i in range(677):
    t.append([])
x = n
for i in range(n):
    a = input()
    if(len(a) < 4):
        if(a in t[0]):
            x -= 1
        else:
            t[0].append(a)
    else:
        p = ord(a[0])*26+ord(a[1])-2618
        if(a[2:] in t[p]):
            x -= 1
        else:
            t[p].append(a[2:])
print(x)

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

def main():
    N = int(input())
    S = [s.rstrip() for s in sys.stdin.readlines()]
    count = 0

    memo = sorted(S)

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

if __name__ == '__main__':
    main()

Solution (Python):
s = [input() for i in range(1)] 
li = list(map(int, s[0].split()))
n = li[0]
t = [input() for j in range(n)]
t_unique = list(set(t))
print(len(t_unique))

Solution (Python):
import collections
n = int(input())
P = [input() for i in range(n)]
Q = set(P)
print(len(Q))

Solution (Python):
import sys


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

    S = set(S)

    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())
a = []
ans = 0
for i in range(n):
    b = input()
    a+=[b]
c = sorted(a)
b = 0
for i in range(n-1):
    if c[i] == c[i+1]:
        b += 1

print(n-b)

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

Solution (Python):
n = int(input())
my_set = set([])

for i in range(0, n):
  my_set.add(str(input()))
  
print(len(my_set))

Solution (Python):
def main():
  n = int(input())
  
  
  
  s = [input() for i in range(n)]
  
  
  
  ans = 0
  count = 0
  lis = []
  
  for i in set(s):
    count += 1
  print(count)
  
if __name__ == '__main__':
  main()

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

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

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

Solution (Python):
list1=[]
num=int(input())
for i in range (0,num):
    list1.append(input())
print(len(set(i for i in list1 if i.isalpha())))

Solution (Python):
import collections
a = int(input())
list = []

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

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

Solution (Python):
import collections

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

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

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

Solution (Python):
import collections

l = list()

N= input()
for i in range(int(N)):
  a_i = input()
  l.append(a_i)
  
c = collections.Counter(l)
print(len(c))

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

mylist_1=[];
mylist_2=[];
mylist_3=[];
mylist_4=[];
mylist_5=[];
mylist_6=[];
mylist_7=[];
mylist_8=[];
mylist_9=[];
mylist_10=[];

for i in range(num):
  s = input();
  if len(s) == 1:
    mylist_1.append(s);
  elif len(s) == 2:
    mylist_2.append(s);
  elif len(s) == 3:
    mylist_3.append(s);
  elif len(s) == 4:
    mylist_4.append(s);
  elif len(s) == 5:
    mylist_5.append(s);
  elif len(s) == 6:
    mylist_6.append(s);
  elif len(s) == 7:
    mylist_7.append(s);
  elif len(s) == 8:
    mylist_8.append(s);
  elif len(s) == 9:
    mylist_9.append(s);
  elif len(s) == 10:
    mylist_10.append(s);
    

m1 = len(list(set(mylist_1)));
m2 = len(list(set(mylist_2)));
m3 = len(list(set(mylist_3)));
m4 = len(list(set(mylist_4)));  
m5 = len(list(set(mylist_5)));
m6 = len(list(set(mylist_6)));
m7 = len(list(set(mylist_7)));
m8 = len(list(set(mylist_8)));
m9 = len(list(set(mylist_9)));
m10 = len(list(set(mylist_10)));

m = m1 + m2 + m3 + m4 + m5 + m6 + m7 + m8 + m9 + m10;
print(m);

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

N = int(readline())
S = set()
for i in range(N):
    S.add(readline().strip())
print(len(S))

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

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

print(len(S))

Solution (Python):
a = int(input())
l = [input() for i in range (a)]
d = {}
for i in l:
    if i in d:
        d[i] += 1
    else:
        d[i] = 1
answer_list = list(d.keys())
answer = len(answer_list)
print(answer)

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

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

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

c = collections.Counter(List)

print(len(c))

Solution (Python):
num=int(input())
lst=[]
if 1<=num<=2*10**5:
    lst=[input() for i in range(num)]
    print(len(set(lst)))

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

print(len(Counter(list)))

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

print(len(list(set(items))))

Solution (Python):
d = {}
ans = 0;
N = int(input())
for i in range(N):
    key = input()
    if key not in d:
        ans+=1
        d[key] = 0
        
        
print(ans)

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

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

print(len(set(l)))

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

s_l = set(l)
print(len(s_l))

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 i in range(N)] 
b = list(set(s))
print(len(b))

Solution (Python):
import sys

def main():

	N = int(input())
	
	d = {}
	for i in range(N):
		A = input()
		d[A] = 0
	print(len(d))
	
if __name__ == "__main__":
    main()

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

Solution (Python):
a = int(input())
b = []
for i in range(a):
    b.append(input())
b = sorted(b)
for i in range(a - 1):
    if b[int(i)] == b[int(i) + 1]:
        a = a - 1
print(a)

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

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

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

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

print(len(result))

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

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



print(len(set(S)))

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

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

if __name__ == '__main__':
  main()