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

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

Solution (Python):
order = int(input())
data = set([])

for i in range(order):
    data.add(input())

print(len(data))

Solution (Python):
import sys
input=sys.stdin.readline
N=int(input())
K=[]
z=0
for x in range(N):
    k=input()
    K.append(k)
T=set(K)
y=len(T)
print(y)

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

Solution (Python):
"""
// Author : snape_here - Susanta Mukherjee
     
 """
 
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
 
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())
 
 
def read():
    sys.stdin = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

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

mod=1000000007

import math

import bisect

abc="abcdefghijklmnopqrstuvwxyz"

def main():

    l=[]
    for _ in range(ii()):
        s=si()
        l.append(s)
    print(len(set(l)))



 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
 
if __name__ == "__main__":
    
    main()

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

    has = set()
    for s_i in s:
        if s_i not in has:
            has.add(s_i)
    print(len(has))

Solution (Python):
from collections import*
n,*a=open(0).read().split()

print(len(Counter(a).values()))

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())
ans = set(S)
print(len(ans))

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

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

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

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

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

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

def input_1line_list(number_of_input):
    return [input() for i in range(number_of_input)]

def print_unique_length(input_list):
    print(len(set(input_list)))

def main():
    n = input_number()
    print_unique_length(input_1line_list(n))

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

n = int(input().strip())
ans = set()
for _ in range(n):
	s = input().strip()
	ans.add(s)

print(len(ans))

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

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

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


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

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

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

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

Solution (Python):
t = int(input())
l = []
while t!= 0:
    a = input()
    l.append(a)
    t = t - 1
print(len(set(l)))

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

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

Solution (Python):
x = int(input())
y = []
result = []

for i in range(x):
  y.append(input())
  
print(len(set(y)))

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

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

print(len(S))

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))



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

print(len(set(S)))

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

Solution (Python):



def main():
    n = int(input())
    ans = set()

    for i in range(n):
        si = input()
        ans.add(si)

    print(len(ans))


if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):

def main():
    import sys
    N = int(sys.stdin.readline())
    presents = set()
    for _ in range(N):
        presents.add(sys.stdin.readline().rstrip())
    print(len(presents))




if __name__=='__main__':
    main()

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

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

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

Solution (Python):
n = int(input())
array = list(input() for i in range(n))

array = set(array)

len = len(array)

print(len)

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

Solution (Python):



count = int(input())
line = list()
for i in range(count):
    syurui = input()
    line.append(syurui)
    
line2 = set(line)
print(len(line2))

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

for _ in range(N):
    temp = input()
    S.append(temp)

print(len(set(S)))

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

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

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

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

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

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

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

Solution (Python):


ipnl = lambda n: [input() for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]
mp = lambda :map(int,input().split())

n = inp()
x = ipnl(n)
print(len(set(x)))

Solution (Python):


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

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

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

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

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

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

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

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

S = list(set(S))

print(len(S))

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

print(len(set(d)))

Solution (Python):
n = int(input())
dictionary = {}
for i in range(n):
  s = input()
  dictionary[s] = "get"

print(len(dictionary))

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

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

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

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

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

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

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

print(N - dupli)

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

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

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

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

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

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 = set()
for _ in range(n):
    s.add(input())

print(len(s))

Solution (Python):





import sys,os
from io import BytesIO, IOBase
import collections,itertools,bisect,heapq,math,string


BUFSIZE = 8192

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def main():
    t=int(input())
    strlist=[str(input()) for x in range(t)]
    
    ans=set()
    for s in strlist:
        ans.add(s)
    print (len(ans))
if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
import collections




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

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

    items = set()
    for i in range(N):
        item = input()
        items.add(item)

    print(len(items))

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())
ans=[]
for i in range(N):
    ans.append(input())
ans_l=set(ans)

print(len(ans_l))

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

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

Solution (Python):
n = int(input())
s=[]
ans = 1
for i in range(n):
    s += [input()]
s.sort()
for i in range(n-1):
    if s[i] != s[i+1]:
        ans += 1
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(input() for i in range(N))
S=set(S)
print(len(S))

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

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

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

Solution (Python):
def main():
    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
    import math

    
    

    n = int(input())
    s = {}
    for _ in range(n):
        a = input().rstrip()
        s[a] = 1
    print(len(s))

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    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
    import math

    
    

    n = int(input())
    s = {}
    for _ in range(n):
        a = input().rstrip()
        s[a] = 1
    res = 0
    for _ in s.keys():
        res += 1
    print(res)

if __name__ == '__main__':
    main()

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

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

print(len(dic))

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())
cnt = len(s)

print(cnt)

Solution (Python):

n = int(input())
st = set()

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

print(len(st))

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

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

n = int(input())
a = set()

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

print(len(a))

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

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

Solution (Python):

"""
Spyderエディタ

これは一時的なスクリプトファイルです
"""

n = int(input())

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

Solution (Python):

 
n = int(input())

s_set = {input() for i in range(n)}
print(len(s_set))

Solution (Python):
import collections

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

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

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

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

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

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

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

sorted_list = sorted(s)
i :int=0
k :int=0
kind :str=""
while i<N:
  if kind!=sorted_list[i]:
    kind=sorted_list[i]
    k+=1
  i+=1
  
print(k)

Solution (Python):


n = int(input())
s_set = {input() for i in range(n) }
print(len(s_set))

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

d = dict()
ans = 0

for i in range(n):
    s = str(input())
    if s in d:
        continue
    else:
        d[s] = s
        ans += 1
        
print(ans)

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

print(len(set(S)))

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

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

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

dic = {}

for i in range(n):
    s = input()
    dic[s] = dic.get(s, 0) + 1

print(len(dic.keys()))

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

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

Solution (Python):

N = int(input())
S = []
append = S.append

for n in range(N):
    append(str(input()))
    
S = set(S)

print(len(S))

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

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

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

s = set()

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

print(len(s))

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



dic={}

for i in range(n):
    s=input()
    dic[s]=dic.get(s,0)+1

print(len(dic.keys()))

Solution (Python):
from collections import defaultdict

n = int(input())

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

print(len(d))

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

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

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

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
def main():
    n = int(input())
    s = []
    for _ in range(n):
        a = input()
        s.append(a)
    s.sort()
    cnt = 1
    for i in range(n-1):
        if s[i] != s[i+1]:
            cnt += 1
    print(cnt)
if __name__ == '__main__':
    main()

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

IN=lambda : map(int, input().split())
LIN=lambda : list(IN())
mod=1000000007



def main():
	a = int(input())
	
	al = [input() for _ in range(a)]
	
	n=len(list(set(al)))
	print(n)
	
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

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

S = {}
for _ in range(N):
  S.setdefault(input())

print(len(S))

Solution (Python):
if __name__ == '__main__':
    n = int(input())
    print(len(set(input().rstrip('\n') for _ in range(n))))

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

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

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

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

Solution (Python):
_,*s=open(0).read().split()
print(len(list(set(s))))

Solution (Python):
s = set([])
things = int(input())

for i in range(things):
    p = input()
    s.add(p)

print(len(s))

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

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

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

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


solve()

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
lista = []
for x in range(n):
    item = input()
    lista.append(item)

lista.sort(reverse = False)
contador = 1

if len(lista) == 1:
    print(contador)
else:
    i = 0
    j = 1
    while i != len(lista)-1:
        if lista[i] != lista[j]:
            contador += 1
        i += 1
        j += 1

    print(contador)

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

Solution (Python):
def main():
    n = int(input())
    s = set()
    for _ in range(n):
        tmp = input()
        s.add(tmp)
    ans = 0
    for _ in s:
        ans += 1
    print(ans)

if __name__ == "__main__":
    main()

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

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

print(len(s))

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

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

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

a_num = len(a_set)

print(a_num)

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

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

Solution (Python):
import math as mt
import collections as cc
I=lambda:list(map(int,input().split()))
n,=I()
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):
S = set()
n = int(input())
for i in range(n):
  S.add(input().strip())
print (len(S))

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    n = int(input())
    print(len({input() for _ in range(n)}))
resolve()

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
count = int(input())
zenbu = set()
 
for x in range(count):
    keihin = input()
    zenbu.add(keihin)
print(len(zenbu))

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

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

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

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

s = set(s)

print(len(s))

Solution (Python):
n = int(input());
s = [0]*n;
for i in range(n):
    s[i] = input().rstrip('\n');
s.sort();
ans = 1;
for i in range(n-1):
    if not(s[i]==s[i+1]) :
        ans += 1;
print(ans);

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

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

print(len(set(s)))

Solution (Python):
def main():
    N = int(input())
    ans = {}
    for _ in range(N):
        ans[input()] = True
    print(len(ans))

    return 0

if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np


def solve(n, s_list):
    return np.unique(s_list).shape[0]


def main():
    n = int(input())
    s_list = [input() for _ in range(n)]
    res = solve(n, s_list)
    print(res)


def test():
    assert solve(3, ["apple", "orange", "apple"]) == 2
    assert solve(5, ["grape", "grape", "grape", "grape", "grape"]) == 1
    assert solve(4, ["aaaa", "a", "aaa", "aa"]) == 4


if __name__ == "__main__":
    test()
    main()

Solution (Python):

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

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

Ans=list(set(S))

print(len(Ans))

Solution (Python):
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


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

print(len(set(S)))

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

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

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

Solution (Python):
n = int(input())
dic = {}
cnt =0
for i in  range(n):
    get = input()

    if get not in dic:
        dic[get] = 1

print(len(dic))

Solution (Python):
N = int(input())
L = []
if not (1 <= N <= 2*(10**5)):
    exit()


for i in range(N):
    d = input()
    
    
    
    
    L.append(d)

print(len(set(L)))

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

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

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

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

print(len(set(s)))

Solution (Python):
def prb2():
    a,b,c,d = map(int,input().split())
    t = (a+b)
    ak = (c+d)
    print('Yes' if t>ak else "No")

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





prb3()

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

Solution (Python):
n = int(input())
d = {}
for i in range(n):
    buf = input()
    if buf not in d:
        d[buf] = 1

print(len(d.keys()))

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

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