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):
def abc(N, S):
    
    ans = 0
    
    
    str_set = set(S)
    
    
    return(len(str_set))



if __name__ == "__main__":
    
    
    N = int(input())
    
    
    S = []
    for i in range(0, N):
        s = input()
        S.append(s)
    
    
    f = abc(N, S)
    
    
    print(f)

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

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


s.sort()

cnt = 1
if n == 1:
    print(1)
else:
    for i in range(n-1):
        if not (s[i] == s[i + 1]):
            cnt += 1
    print(cnt)

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

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

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

print(len(S))

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

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


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

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

print(len(S))

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

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

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

c = collections.Counter(l)

print(len(c))

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

Solution (Python):
import sys

stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() 

def alpha2num(alpha):
    num=0
    for index, item in enumerate(list(alpha)):
        num += pow(26,len(alpha)-index-1)*(ord(item)-ord('A')+1)
    return num
    
def main():
    n = ni()
    s = set([alpha2num(ns()) for i in range(n)])
    print(len(s))
    return

if __name__ == '__main__':
  main()

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

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

print(len(set(li)))

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

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

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

s_set = set(s)

print(len(s_set))

Solution (Python):
numOfStr= int(input())
strlist = []
total = 1
for i in range(0,numOfStr):
    strlist.append(input())
strlist.sort()
for i in range(1,numOfStr):
    if strlist[i] != strlist[i-1]:
        total += 1
print(total)

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

print(len(s))

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

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

print(len(set(L)))

Solution (Python):


N=int(input())

S=[]
ans=0

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

ans = len(list(set(S)))

print(ans)

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

presents_list = {}

for i in range(n):
    present = input()
    if present in presents_list:
        presents_list[present] += 1
    else:
        presents_list[present] = 1

print(len(presents_list))

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

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

cnt = 0
prize_list = []
for i in range(n):
    prize_list.append(input())
    

print(len(set(prize_list)))

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

dic = {}
for i in range(n):
  value =str(input())
  dic[value] = True
  
print(len(dic))

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

Solution (Python):

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

Solution (Python):


def main():
    N = int(input())
    S = [str(input()) for i in range(N)]
    d = {}
    for i in S:
        if not(i in d):
            d[i] = 0
            
    print(len(d))
if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
import collections

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

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

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

s = [input() for i in range(a)]

s=set(s)

print(len(s))

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

Solution (Python):
import collections
n = int(input())
l = []
for i in range(n):
  l.append(input())
c = collections.Counter(l)
num = 0
for i in c.keys():
  num += 1
print(num)

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

Solution (Python):
numOfStr= int(input())
strlist = []
total = 1
for i in range(0,numOfStr):
    strlist.append(input())
strlist.sort()
for i in range(1,numOfStr):
    if strlist[i] != strlist[i-1]:
        total += 1
print(total)

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

Solution (Python):

import sys
N = int(input())

mylist = []
for i in range(0, N):
  val = input()
  mylist.append(val)
  
print(len(set(mylist)))

Solution (Python):
from sys import stdin


def get_result(data):
    N = data[0][0]
    A = data[1:]
    tmp = set()
    for i in range(int(N)):
        tmp.add(A[i][0])
    return len(tmp)


if __name__ == '__main__':
    raw_data = [val.rstrip() for val in stdin.readlines()]
    data = [list(map(str, val.split(' '))) for val in raw_data]
    result = get_result(data)
    print(result)

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

Solution (Python):
from sys import stdin

def main():
    times = int(stdin.readline())
    results = []
    for x in range(times):
        results.append(stdin.readline())
    
    print(len(set(results)))


main()

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

for i in range(0, N):
  S.append(input())

S = set(S)

print(len(S))

Solution (Python):
import collections

n=int(input())
s=list()

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


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

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

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

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

ans = set(ss)
print(len(ans))

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

print(len(d))

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

L = set(S)

print(len(L))

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

C()

Solution (Python):
import collections

N = int(input())

S = ""
Slist = []
strlist = []
for count in range(N):
    S = str(input())
    Slist.append(S)

strlist = collections.Counter(Slist)

print(len(strlist))

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

Solution (Python):
d={}
ct=0
for _ in range(int(input())):
  s=input()
  if s not in d:
    d[s]=1
    ct+=1
print(ct)

Solution (Python):
import sys
import collections

n = int(input())
s = sys.stdin.readlines()
ans = collections.Counter(s)
print(len(ans))

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

item = {}

import collections

l = [input() for i in range(n)]
c = collections.Counter(l)

print(len(c.keys()))

Solution (Python):
from collections import Counter

if __name__ == '__main__':
    n = int(input())
    cnt = Counter([input() for i in range(n)])
    print(len(cnt.keys()))

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

S = set()

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

print(len(S))

Solution (Python):
def gacha():
    N=int(input())
    string=[]
    for i in range(0,N):
        s=input()
        string.append(s)
    result=list(set(string))
    print(len(result))

if __name__=="__main__":
    gacha()

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

Solution (Python):
num=eval(input(""))
li=[]
while(num!=0):
  li.append(input())
  num-=1
a=set(li)
print(len(a))

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

dct = {}
for i in range(N):
  s = input()
  if s in dct.keys():
  	dct[s] += 1
  else:
    dct[s] = 1
    
print(len(dct))

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


if __name__ == '__main__':
  main()

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

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

def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))


def main():
    N = II()
    S = [input() for i in range(N)]
    Sn = set(S)

    print(len(Sn))


if __name__ == "__main__":
	main()

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

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

di = {}
cnt = 0

for nl in s:
    if str(nl) not in di:
        di[str(nl)] = 1
        cnt += 1
print(cnt)

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

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())
val = {}
ans = 0

for i in range(n):
    key = input()
    try:
        val[key]
    except Exception:
        val.update({key: 0})
        ans += 1

print(ans)

Solution (Python):
INT_MAX=10**11+7
MOD=10**9+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]

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

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

Solution (Python):
import collections

num = int(input())
item = [input() for i in range(num)]

item_count = collections.Counter(item)

print(len(item_count.keys()))

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

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

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

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

    set(s)
    
    return len(set(s))
    
print(solve())

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

Solution (Python):
n = int(input())
lst = [input() for x in range(n)]

print(len(set(lst)))

Solution (Python):
import collections

N = int(input())
count = collections.Counter()
for _ in range(N):
    count[input()] += 1

print(len(count.items()))

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

print(len(set(ls)))

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

Solution (Python):
N = int(input())
S =[]
for i in range(N):
    val = input()
    if val:
        S.append(val)
import collections
c = collections.Counter(S)
n = 0
for i in c.keys():
    n += 1
    
print(n)

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

c = dict(collections.Counter(s))

print(len(c))

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

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

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

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

print(len(set(s_list)))

Solution (Python):
n = int(input())
items = {}
for _ in range(n):
    s = input()
    if s not in items:
        items.setdefault(s,1)
    else:
        items[s] +=1
print(len(items))

Solution (Python):
numOfStr= int(input())
strlist = []
total = 1
for i in range(0,numOfStr):
    strlist.append(input())
strlist.sort()
for i in range(1,numOfStr):
    if strlist[i] != strlist[i-1]:
        total += 1
print(total)

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

Solution (Python):

N = int(input())

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

ans = set(S)

print(len(ans))

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


N = int(input())
dic = dict()

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

print(len(dic))

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

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

a=set(l)
print(len(a))

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

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

print(len(set(l)))

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

a = set()

for _ in range(n):
    k = input()
    a.add(k)

print(len(a))

Solution (Python):
from collections import defaultdict

N = int(input())

S = defaultdict(int)

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

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

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

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

Solution (Python):
n=int(input())
l=[]
while n>0:
    s=input()
    l.append(s)
    n -= 1
print(len(set(l)))

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

kuji_dict = {}
for i in range(N):
  name = input()
  kuji_dict[name] = 1
  
print(len(kuji_dict.keys()))

Solution (Python):
N=int(input())
s=[input() for i in range(N)]
s=sorted(s)
yobunn=0
for i in range(N-1):
    if s[i]==s[i+1]:
        yobunn=yobunn+1
print(N-yobunn)

Solution (Python):
from math import factorial as fact
import math
import fractions
import sys
import itertools
import numpy as np
from collections import Counter
import datetime

def input1():
	return int(input())


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


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

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(n,r))

def all_sets(num_list):
	subsets=[]
	for i in range(2,len(num_list) + 1):
		for c in combinations(num_list, i):
			subsets.append(c) 
	return subsets


def ch(x1):
	cf=[]
	for i in range(2,math.sqrt(x1)+1):
		if x1 % i==0:
			cf.append(i)
	return cf

def CountOneRoots(x,y):
	
	return fact(x+y)/fact(x)/fact(y)


def factorization(n):
	tmp=n
	count=0
	for i in range(2,int(n**0.5)+2):
		if tmp%i==0:
			cnt=0
			while tmp%i==0:
				cnt+=1
				tmp//=i
			count+=1
	if tmp!=1:
		count+=1

	return count
			




n=input1()
s=[]
d={}
for k in range(n):
	ch=str(input())
	s.append(ch)
	d[ch]=0
for i in s:
	d[i]+=1
print(len(d))

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

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

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

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

print(len(s))

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

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

sa = []
for i in range(n):
    line = input().rstrip()
    sa.append(line)

print(len(set(sa)))

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

print(len(set(S)))

Solution (Python):
n=int(input())
a={}
ans=0
for i in range(n):
  aa=str(input())
  if aa in a:
    b=0
  else:
    a[aa]=i
    ans+=1
    
print(ans)

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

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

print(len(S))

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

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

a = set(s)

print(len(a))

Solution (Python):






inputs: list = []
while True:
    try:
        inputs.append(input().strip('\n'))
    except EOFError:
        break



n = int(inputs[0])
goods = inputs[1:]

goods_list = set(goods)
print(len(goods_list))

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

Solution (Python):
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def init_dp1(init, N): return [init for _ in range(N)]
def init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if n is None:
            return

        if self.v is None:
            self.v = n
            return
        self.v = self.f(self.v, n) 


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

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


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    roop_num = int(input())

    get_freebie = {}
    for i in range(roop_num):
        freebie = input()

        if not freebie in get_freebie:
            get_freebie[freebie] = 0

    print(len(get_freebie))

if __name__ == '__main__':
    main()

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

arr = list(set(arr))
ans = len(arr)

print(ans)

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

print(len(a))

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

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

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

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

Solution (Python):
n = int(input())
ss = set({})

for i in range(n):
    ss.add(input())
    
print(len(ss))

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

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

  print(len(set(S)))
  
if __name__ == "__main__":
  main()

Solution (Python):

import sys
from collections import Counter
from itertools import permutations, combinations

from math import gcd
from math import ceil, floor
import bisect
sys.setrecursionlimit(10 ** 6)
inf = float("inf")

def input():
    return sys.stdin.readline()[:-1]

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
def resolve():
    '''
    code here
    '''
    N = int(input())
    S_list = [input() for _ in range(N)]

    print(len(set(S_list)))

if __name__ == "__main__":
    resolve()

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

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

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

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

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

from collections import Counter
counter = Counter(s)
print(len(counter))

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

l.sort()
cnt=0
for i in range(n-1):
    if l[i]==l[i+1]:
        cnt+=1
print(len(l)-cnt)

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

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

Solution (Python):

n=int(input())
string_list=[input() for i in range(n)]
print(len(list(set(string_list))))

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

print(len(set(S)))

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

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

List_s = set(List)
print(len(List_s))

Solution (Python):
from sys import stdin
import collections

lines = stdin.readlines()
n = int(lines[0].rstrip())
s_n = [str(lines[i].rstrip()) for i in range(1, n+1, 1)]

c = collections.Counter(s_n)

print(len(c))

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

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

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

print(len(s))

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

Solution (Python):
N = int(input())
list = {}
for i in range(N):
    A = str(input())
    list[A] = 1

print(len(list))

Solution (Python):
def func():
    return

n = int(input())

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




ans = len(d)

print(ans)

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

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

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

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

Solution (Python):
n=int(input())
from collections import Counter
l=[]
for i in range(n):
  s=input()
  l.append(s)
print(len(Counter(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 = []
for i in range(N):
    S.append(input())
a = 1
S.sort()
s = S[0]
for i in range(1,N):
    if s != S[i]:
        a += 1
    s = S[i]
print(a)

Solution (Python):
N = int(input())
S = []
count = 1


for i in range(N):
    S.append(input())
print(len(list(set(S))))

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

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

Solution (Python):
from sys import stdin

n = int(input())
s = {stdin.readline().rstrip("\n") for _ in range(n)}
  
print(len(s))

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

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

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

if __name__ == '__main__':
    resolve()

Solution (Python):
num = input()
inplist = [input() for i in range(int(num))]

newlist = set(inplist)
print(len(newlist))

Solution (Python):
from sys import stdin
n = int(stdin.readline().rstrip())
a = [0]*n
for i in range(n):
    a[i] = stdin.readline().rstrip()
a = sorted(a)
answer = 1
for i in range(n-1):
    if a[i] != a[i+1]:
        answer += 1
print(answer)

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

Solution (Python):
import numpy as np
N = int(input())
S = []
for i in range(N):
  S.append(input())
print(np.unique(S).size)

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

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

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

print(len(s))

Solution (Python):

N,*S = open(0).read().split()

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

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

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

Solution (Python):

def resolve():
    import sys
    input = sys.stdin.readline
    n = int(input())

    result = set()
    for _ in range(n):
        result.add(input().rstrip())
    print(len(result))



if __name__ == "__main__":
    resolve()

Solution (Python):

def resolve():
	n = int(input())
	s = []
	d = {}
	ans = 0
	for _ in range(n):
		s.append(input())
	for i in s:
		if not d.get(i):
			ans += 1
			d[i] = True
	print(ans)
resolve()

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


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

Solution (Python):
from math import ceil 

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

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

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

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

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


number_of_types = len(set(S))

print(number_of_types)

Solution (Python):
import collections

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

print(len(c))

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

Solution (Python):
import collections
N = int(input())
S = [input() for i in range(N)]
c = collections.Counter(S)

print(len(c))

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

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

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

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

Solution (Python):
N=int(input())
dic={}
for i in range(N):
  tmp=input()
  if tmp not in dic:
    dic[tmp]=1
  else:
    dic[tmp]+=1

print(len(dic))

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

d = {}
for _ in range(0, n):
    s = input()
    d[s] = 1


print(list(d).__len__())

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

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

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

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

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

d = {}

for i in S:
    if i in d:       
        continue
    else:
        d[i] = 1

print(len(d))

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

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

dic = {}
ans = 0

for _ in range(N):
  S = input()
  if not S in dic:
    ans += 1
    dic[S] = True

print(ans)

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

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

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

print(len(s))

Solution (Python):
import sys
input=lambda :sys.stdin.readline().rstrip()
n = int(input())
S = [input() for _ in range(n)]

S_unique = list(set(S))
print(len(S_unique))

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

mydict = {}

for s in S:
    if s in mydict:
        mydict[s] += 1
    else:
        mydict.setdefault(s, 1)

print(len(mydict.keys()))

Solution (Python):
from sys import stdin

def main():

    input = stdin.readline

    N = int(input())

    A = []
    for _ in range(N):
        A.append(input())
    
    print(len(set(A)))
    
if __name__ == "__main__":
    main()

Solution (Python):
from collections import Counter
n = int(input())
m = []
for i in range(n):
    m.append(input())
count = Counter(m)
keys, values = zip(*count.most_common())
print(len(keys))

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

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

Solution (Python):
n=int(input(''))
s={}
for a in range(n):
    t=input('')
    if t in s:
        p=0
    else:
        s[t]=1

print(len(s))

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

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

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