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 in Rust (1.42.0) (judge verdict: Accepted)

#![allow(dead_code)]
use crate::scanner::Scanner;
use crate::vec::IterLikeVec;
use std::collections::HashSet;
fn main() {
    let mut scan = Scanner::new();
    let n = scan.read::<usize>();
    let s = scan.readn::<String>(n).to::<HashSet<_>>();
    println!("{}", s.len());
}
mod vec {
    use std::iter::{FromIterator, Sum};
    pub trait IterLikeVec<T> {
        fn map<B, F>(&self, f: F) -> Vec<B>
        where
            F: FnMut(T) -> B;
        fn filter<P>(&self, predicate: P) -> Vec<T>
        where
            P: FnMut(&T) -> bool;
        fn filter_map<B, F>(&self, f: F) -> Vec<B>
        where
            F: FnMut(T) -> Option<B>;
        fn any<P>(&self, predicate: P) -> bool
        where
            P: FnMut(&T) -> bool;
        fn all<P>(&self, predicate: P) -> bool
        where
            P: FnMut(&T) -> bool;
        fn sum<S>(&self) -> S
        where
            S: Sum<T>;
        fn enumerate(&self) -> Vec<(usize, T)>;
        fn to<B: FromIterator<T>>(&self) -> B;
    }
    impl<T: Clone> IterLikeVec<T> for Vec<T> {
        fn map<B, F>(&self, f: F) -> Vec<B>
        where
            F: FnMut(T) -> B,
        {
            self.iter().cloned().map(f).collect()
        }
        fn filter<P>(&self, predicate: P) -> Vec<T>
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().cloned().filter(predicate).collect()
        }
        fn filter_map<B, F>(&self, f: F) -> Vec<B>
        where
            F: FnMut(T) -> Option<B>,
        {
            self.iter().cloned().filter_map(f).collect()
        }
        fn any<P>(&self, predicate: P) -> bool
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().any(predicate)
        }
        fn all<P>(&self, predicate: P) -> bool
        where
            P: FnMut(&T) -> bool,
        {
            self.iter().all(predicate)
        }
        fn sum<S>(&self) -> S
        where
            S: Sum<T>,
        {
            Sum::sum(self.iter().cloned())
        }
        fn enumerate(&self) -> Vec<(usize, T)> {
            self.iter().cloned().enumerate().collect()
        }
        fn to<B: FromIterator<T>>(&self) -> B {
            self.iter().cloned().collect()
        }
    }
}
mod scanner {
    use std::io::{stdin, BufReader, Bytes, Read, Stdin};
    use std::str::FromStr;
    pub struct Scanner {
        buf: Bytes<BufReader<Stdin>>,
    }
    impl Scanner {
        pub fn new() -> Scanner {
            Scanner {
                buf: BufReader::new(stdin()).bytes(),
            }
        }
        pub fn read_next<T: FromStr>(&mut self) -> Option<T> {
            let token = self
                .buf
                .by_ref()
                .map(|c| c.unwrap() as char)
                .skip_while(|c| c.is_whitespace())
                .take_while(|c| !c.is_whitespace())
                .collect::<String>();
            token.parse::<T>().ok()
        }
        pub fn read<T: FromStr>(&mut self) -> T {
            self.read_next().unwrap()
        }
        pub fn readn<T: FromStr>(&mut self, n: usize) -> Vec<T> {
            (0..n).map(|_| self.read::<T>()).collect()
        }
        pub fn chars(&mut self) -> Vec<char> {
            self.read::<String>().chars().collect()
        }
        pub fn char(&mut self) -> char {
            self.read::<String>().chars().next().unwrap()
        }
    }
}