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):
import sys
from math import log2,floor,ceil,sqrt


sys.setrecursionlimit(7*10**4)

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD =  998244353


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

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

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

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

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

Solution (Python):

import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
from math import gcd
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def lcm(a,b):return (a*b) // gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')

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

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

Solution (Python):
import sys


n, *s = sys.stdin.read().split()
def main():
    print(len(set(s)))

if __name__ == '__main__':
    main()

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

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

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

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

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

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

print(len(set(S)))

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
s = set()
for _ in range(N):
  s.add(input()[: -1])
print(len(s))

Solution (Python):
import sys,os
from collections import defaultdict, deque
from math import ceil, floor
if sys.version_info[1] >= 5:
    from math import gcd
else:
    from fractions import gcd
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    MOD = 10**9+7

    b = defaultdict(int)
    N = II()
    for i in range(N):
        b[input()] += 1
    print(len(list(b.keys())))
    

if __name__ == '__main__':
    main()

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

n = int(input())
S = list(map(lambda s: s.strip(), sys.stdin.readlines()))

x = {}

for s in S:
    x[s] = True

print(len(x.keys()))

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

for _ in range(N):
    s = input()
    d[s] += 1
    
print(len(d))

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

Solution (Python):
n=int(input())
s=[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):
n = int(input())
d = {}
for i in range(n):
    s = input()
    try:d[s]+=1
    except:d[s]=1
print(len(d))

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

print(len(set(S)))

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

print(len(set(s)))

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

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

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

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

    print(len(set(S)))


if __name__ == '__main__':
    main()

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

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

print(len(set(li)))

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



    print(len(set(str_list)))

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

print(len(set(si)))

Solution (Python):
N=int(input())
x=dict()
for i in range(N):
    s=input()
    x[s]=1
ans=0
for idx in x:
    ans+=1
print(ans)

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):
from sys import stdin
N = int(stdin.readline().rstrip())
data = []
for i in range(N):
    S = input()
    data.append(S)
print(len(set(data)))

Solution (Python):
mod=10**9+7



from collections import defaultdict
Hash=defaultdict(lambda:0)
N=int(input())
for i in range(N):
    Hash[input()]+=1
print(len(Hash.keys()))

Solution (Python):

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

print(len(set(L)))

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

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
from collections import Counter

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

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



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

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

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

A=list(set(A))
print(len(A))

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue

Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  
    n = int(input())
    s = [input() for i in range(n)]
    print(len(set(s)))
if __name__ == "__main__":
    main()

Solution (Python):
mod = 10**9+7
import sys
from collections import Counter, defaultdict, deque
from itertools import product, permutations, combinations
from itertools import accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil,floor
from copy import deepcopy
from heapq import heappop,heappush,heapify
import heapq





sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1


p2D = lambda x: print(*x, sep="\n")

def II(): return int(sys.stdin.readline())

def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())




def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI(): return list(map(lambda x:int(x), sys.stdin.readline().split()))
def HI(): return list(map(lambda x:int(x)*(-1), sys.stdin.readline().split()))


n = II()
l = []
for _ in range(n):
	l.append(input())

c = Counter(l)
print(len(c))

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

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

Solution (Python):
import collections

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

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

Solution (Python):
def main():
    n = int(input())
    s = [0 for i in range(n)]
    g = {}
    ans = 0
    for i in range(n):
        s[i] = input()
        if g.get(s[i]) == None:
            g[s[i]] = 1
            ans += 1

    print(ans)
    
main()

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

s = []

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

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

Solution (Python):

import sys


def solve(N: int, S: "List[str]"):
    keihin = set()
    for s in S:
        keihin.add(s)
    print(len(keihin))
    return



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


if __name__ == '__main__':
    main()

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

print(len(S))

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

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

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

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

print(len(set(S)))

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

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

def s_in():
    return input()

def n_in():
    return int(input())

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

def print_l(l):
    print(' '.join(map(str, l)))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

n = n_in()
s = set()
[s.add(s_in()) for _ in range(n)]
print(len(s))

Solution (Python):
import sys
import math  
import bisect  
import queue  


def input():
    return sys.stdin.readline().rstrip()


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

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

    print(len(prize))


if __name__ == '__main__':
    main()

Solution (Python):
import sys
input=sys.stdin.readline
n=int(input())
d=set()
for _ in range(n):
    s=input().rstrip()
    d.add(s)
print(len(d))

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

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

Solution (Python):
import sys

IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
MIIZ = lambda: list(map(lambda x: x-1, MII()))

INIT_VAL = 0
MD2 = lambda d1,d2: [[INIT_VAL]*d2 for _ in range(d1)]
MD3 = lambda d1,d2,d3: [MD2(d2,d3) for _ in range(d1)]

DIVC = lambda x,y: -(-x//y)
DIVF = lambda x,y: x//y
from collections import Counter

def main():
    n = II()
    ss = [IS() for _ in range(n)]
    c = Counter(ss)
    print(len(c))

if __name__ == '__main__':
    main()

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

l = []
for x in range(N):
  s = input()
  l.append(s)

c = collections.Counter(l)

print(len(c))

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

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

    print(len(items))
    

main()

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

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


if __name__ == '__main__':
    solve()

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

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

Solution (Python):



from math import *
from copy import *					
from heapq import *					
from string import *				
from random import *				
from bisect import *				
from sys import stdin				
from sys import maxsize				
from operator import *				
from itertools import *				
from collections import Counter		
from collections import defaultdict 

'''

'''

def solve(l):
	return (len(dict(Counter(l))))
	

T = int(input())
L = []
for _ in range(T):
	l = input()
	L.append(l)
print(solve(L))

Solution (Python):
def main():
    N = int(input())
    ans = set()
    for _ in range(N):
        S = input()
        ans.add(S)

    print(len(ans))
    


if __name__ == "__main__":
    main()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline

N, *S = map(str, read().split())
print(len(set(S)))

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

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

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

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

Solution (Python):



def main():
    import sys
    sys.setrecursionlimit(10**6)
    

    def dump(*args):
        sys.stderr.write(str(args))

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


if __name__ == '__main__':
    main()

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

Solution (Python):
from collections import Counter

N=int(input())
S=[0]*N
for i in range(N):
  S[i]=input()
  
d=dict(Counter(S))
print(len(d))

Solution (Python):
n = int(input())
lis = set()
count = 0
for _ in range(n):
    lis.add(input())

print(len(lis))

Solution (Python):
import sys

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


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


if __name__ == '__main__':
    solve()

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

result = {}

for i in range(n):
    result[input().rstrip()] = 1

print(len(result.keys()))

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

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

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())
dic={}
for i in range(0,N):
    s=input()
    if s not in dic.keys():
        dic[s]=0
        dic[s]=1

ans=0
for i in dic.keys():
    ans+=dic[i]
print(ans)

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

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
dat = dict()
for _ in range(n):
    s = input()
    dat[s] = True
k = dat.keys()
print(len(k))

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

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n = I()
s = [input() for _ in range(n)]
cnt = Counter(s)
print(len(cnt))

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

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

print(len(set(A)))

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

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

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    from collections import defaultdict
    counter = defaultdict(int)
    N = int(input())
    for _ in range(N):
        counter[input().rstrip()] += 1
    print(len(counter))

if __name__ == '__main__':
    main()

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

Solution (Python):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

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

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

Solution (Python):
n = int(input())
keihin = {}
for i in range(n):
    s = input()
    try:
        keihin[s] += 1
    except:
        keihin[s] = 1
print(len(keihin.keys()))

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

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

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

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

from collections import defaultdict
dic = defaultdict(int)

for _ in range(n):
    sl = input()
    dic[sl] += 1

print(len(dic.values()))

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

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

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

Solution (Python):



debug=1
def pront(*n):
    if debug==1:
        print(n)
        


base=10**9+7

def add(a,b):
    return (a+b)%base

def sub(a,b):
    return (a-b)%base

def multi(a,b):
    return (a*b)%base

def exp(a,b):
    x=1
    c=a
    d=b
    while d!=0:
        if d%2==1:
            x=multi(x,c)
        c=(c**2)%base
        d=d//2
    return x

def div(a,b):
    return(multi(a,exp(b,base-2)))



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




X={}
for i in S:
    if i in X:
        pass
    else:
        X[i]=1
print(len(X))

Solution (Python):
import sys
from collections import Counter

input = sys.stdin.readline


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

    c = Counter(S)
    ans = len(c.keys())
    print(ans)


if __name__ == "__main__":
    main()

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

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

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

print(len(S))

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

print(len(list(prize.keys())))

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

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

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

Solution (Python):

import sys




import numpy as np

"""Template"""


class IP:
    """
    入力を取得するクラス
    """

    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


"""ここからメインコード"""


def main():
    
    r, e = range, enumerate
    ip = IP()

    """この下から書いてね"""
    
    
    
    
    
    n = int(input())
    s = ip.SLS(n)
    print(len(set(s)))


main()

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

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

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

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

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

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

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

Solution (Python):
N = int(input())
items = set()
for _ in range(N):
	items.add(input().strip())

print(len(items))

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

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

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



L = []

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

print(len(set(L)))

Solution (Python):
def main():

    N = int(input())
    v = set()
    for _ in range(N):
        v.add(input())
    return len(v)

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

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

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

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

print(len(V))

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    s = []
    n = ii()
    for i in range(n):
        tmp = input()
        s.append(tmp)
    s = list(set(s))
    print(len(s))


main()

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

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

def solve(As):
    return len(set(As))

if __name__ == "__main__":
    N = int(input())
    As = []
    for _ in range(N):
        As.append(input())
    print(solve(As))

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

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

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

import sys


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

sets = set()
for s in S:
    sets.add(s)

print(len(list(sets)))