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 bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
import sys
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import lru_cache, reduce
from math import gcd
from operator import add, itemgetter, mul, xor

import numpy as np

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

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



N = int(sys.stdin.buffer.readline())
S = [sys.stdin.buffer.readline().decode().rstrip() for _ in range(N)]

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

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
from collections import Counter, deque, defaultdict
from bisect import bisect_left
setrecursionlimit(1000000)

INF = int(1e10)
MOD = int(1e9 + 7)

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


def main():
    from builtins import int, map
    n = int(input())
    count = defaultdict(int)
    for _ in range(n):
        s = input()
        count[s] += 1
    print(len(count))


if __name__ == '__main__':
    main()

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

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n = I()
    d = dict(zip([input() for i in range(n)],range(n)))
    print(len(d))
    return


if __name__ == "__main__":
    solve()

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

Solution (Python):
import collections

n=int(input())
arr=[input() for _ in range(n)]
cnt=collections.Counter(arr)
print(len(cnt.keys()))

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

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

Solution (Python):

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


def solve():
    N = Scanner.int()
    M = set()
    for _ in range(N):
        S = Scanner.string()
        M.add(S)
    print(len(M))


def main():
    
    solve()


if __name__ == "__main__":
    main()

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

f_lists = []

for i in range(N):
    tmp = input()
    f_lists.append(tmp)

ans = len(set(f_lists))
print(ans)

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

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

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

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

Solution (Python):


N=int(input())

ans=dict()
for i in range(N):
    S=input()
    if not S in ans:
        ans[S]=1

print(len(ans))

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

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

sdict = {}

for s in slist:
    sdict[s] = 1

print(len(sdict))

Solution (Python):

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    N=I()
    from collections import defaultdict
    dd = defaultdict(int)
    for i in range(N):
        S=input()
        dd[S]+=1
    
    ans=0
    for k,v in dd.items():
        ans+=1
        
    print(ans)

main()

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

l_set = set(l)

print(len(l_set))

Solution (Python):
def main():
    import sys
    from collections import Counter

    input = sys.stdin.readline

    n = int(input())
    s = [str(input()) for i in range(n)]
    co = Counter(s)
    print(len(co))

if __name__ == "__main__":
    main()

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

Solution (Python):

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

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

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

print(len(set(S)))

Solution (Python):
from collections import Counter


def read():
    N = int(input())
    S = []
    for i in range(N):
        s = input()
        S.append(s)
    return N, S

def solve(N, S):
    return len(Counter(S))


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("{}".format(outputs))

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

print(len(set(L)))

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

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

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

Solution (Python):


iim = lambda: map(int, input().rstrip().split())

def resolve():
    N = int(input())
    print(len(set(input() for i in range(N))))

if __name__ == "__main__":
    resolve()

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

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

print(len(set(S)))

Solution (Python):


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

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

Solution (Python):
mod = 1000000007
eps = 10**-9


def main():
    import sys
    input = sys.stdin.readline

    N = int(input())
    A = set()
    for _ in range(N):
        S = input().rstrip('\n')
        A.add(S)
    print(len(A))


if __name__ == '__main__':
    main()

Solution (Python):
import sys

if __name__ == '__main__':
    N = int(input())
    S = [sys.stdin.readline() for _ in range(N)]

    print(len(set(S)))

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H):
    '''
    H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_matrix(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from math import gcd


N = read_a_int()
mono = []
for _ in range(N):
    mono.append(read()[:-1])

print(len(set(mono)))

Solution (Python):

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

Solution (Python):



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


def main():
    s = set()
    for x in S:
        s.add(x)
    
    ans = len(s)
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import time
import math
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
N=int(input())
print(len(Counter([input() for i in range(N)])))

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

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

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

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