Problem:
Score: 100 points

Problem Statement

M-kun is a competitor in AtCoder, whose highest rating is X.

In this site, a competitor is given a kyu (class) according to his/her highest rating. For ratings from 400 through 1999, the following kyus are given:

From 400 through 599: 8-kyu

From 600 through 799: 7-kyu

From 800 through 999: 6-kyu

From 1000 through 1199: 5-kyu

From 1200 through 1399: 4-kyu

From 1400 through 1599: 3-kyu

From 1600 through 1799: 2-kyu

From 1800 through 1999: 1-kyu

What kyu does M-kun have?

Constraints

400 \leq X \leq 1999

X is an integer.

Input

Input is given from Standard Input in the following format:

X

Output

Print the kyu M-kun has, as an integer.
For example, if he has 8-kyu, print 8.

Sample Input 1

725

Sample Output 1

7

M-kun's highest rating is 725, which corresponds to 7-kyu.

Thus, 7 is the correct output.

Sample Input 2

1600

Sample Output 2

2

M-kun's highest rating is 1600, which corresponds to 2-kyu.

Thus, 2 is the correct output.

Solution in Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused_macros, unused_variables, dead_code, clippy::many_single_char_names)]
use std::io::{stdin, stdout, StdinLock, StdoutLock, BufWriter, prelude::*};

macro_rules! read {
    ($s: ident) => {
        {
            $s.read()
        }
    };
    ($s: ident, $t: ty) => {
        {
            let mut v: $t = 0;
            let num = $s.read();
            let l = num.len();
            
            if num[0] == b'-' {
                for d in &num[1..l] {
                    v = v*10 - (*d as $t) + (b'0' as $t);
                }
            } else {
                for d in &num[..l] {
                    v = v*10 + (*d as $t) - (b'0' as $t);
                }
            }
            v
        }
    }
}

macro_rules! to_str {
    ($v: expr) => {
        {
            let mut s = String::new();
            for x in $v {
                s.push(*x as char);
            }
            s
        }
    };
    ($v: expr, $l: expr) => {
        {
            let mut s = String::with_capacity($l);
            for x in $v {
                s.push(*x as char);
            }
            s
        }
    }
}

macro_rules! to_vec {
    ($v: expr) => {
        {
            let mut s = Vec::new();
            for x in $v {
                s.push(*x as char);
            }
            s
        }
    };
    ($v: expr, $l: expr) => {
        {
            let mut s = Vec::with_capacity($l);
            for x in $v {
                s.push(*x as char);
            }
            s
        }
    }
}

macro_rules! read_vec {
    ($s: ident, $l: expr) => {
        {
            let mut v = Vec::with_capacity($l);
            for _ in 0..$l {
                v.push(to_str!(read!($s)));
            }
            v
        }
    };
    ($s: ident, $t: ty, $l: expr) => { // for ints
        {
            let mut v = Vec::with_capacity($l);
            for _ in 0..$l {
                v.push(read!($s, $t));
            }
            v
        }
    };
}

macro_rules! void {
    ($s: ident, $l: expr) => {
        if $l > 0 {
            let mut n = 0;
            let mut first = true;

            while n < $l {
                if $s.pos != 0 {
                    $s.stdin.consume($s.pos);
                }

                let buf = $s.stdin.fill_buf().unwrap();

                let mut resume = true;

                for (i, x) in buf.iter().enumerate() {
                    if x == &b' ' || x == &b'\n' {
                        if i == 0 && first {
                            continue;
                        }

                        n += 1;

                        if n == $l {
                            $s.pos = i+1;
                            resume = false;
                            break;
                        }
                    }
                }

                if resume {
                    $s.pos = buf.len();
                    first = false;
                }
            }
        }
    };
}

macro_rules! pipe {
    ($s: ident, $($x: ident),*) => {
        $(
            $x = read!($s);
        )*
    };
    ($s: ident, $t: ty, $($x: ident),*) => {
        $(
            $x = read!($s, $t);
        )*
    };
    ($s: ident, $( ($x: ident, $t: ty) ),*) => {
        $(
            $x = read!($s, $t);
        )*
    };
}

struct Reader<'a> {
    stdin: StdinLock<'a>,
    pos: usize,
    v_temp: Vec<u8>
}

impl<'a> Reader<'a> {
    fn new(stdin: StdinLock<'a>)/*'*/ -> Self {
        Reader {stdin, pos: 0, v_temp: vec![]}
    }
    
    fn read(&mut self) -> &[u8] {
        if self.pos != 0 {
            self.stdin.consume(self.pos);
        }
        let mut s = 0;
        let mut i = 0;
        
        let buf = self.stdin.fill_buf().unwrap();
        
        loop {
            if unsafe {buf.get_unchecked(i)} < &33 {
                if i > buf.len() {
                    let b_len = buf.len();
                    let mut idx_char = 0;
                    
                    loop {
                        if unsafe {buf.get_unchecked(idx_char)} > &33 || idx_char == b_len {
                            break;
                        }
                        idx_char += 1;
                    }
                    let mut v1;
                    if b_len != idx_char {
                        v1 = vec![0; b_len-idx_char];
                        v1[..].copy_from_slice(&buf[idx_char..]);
                    } else {
                        v1 = vec![];
                    }

                    let new_buf = {
                        self.stdin.consume(b_len);
                        let buf = self.stdin.fill_buf().unwrap();
                        let mut i = 0;

                        loop {
                            if unsafe {buf.get_unchecked(i)} < &33 {
                                break if i == 0 {
                                    &[]
                                } else {
                                    &buf[..=i]
                                }
                            }
                            i += 1;
                        }
                    };
                    if !new_buf.is_empty() {
                        self.pos = new_buf.len();
                        v1.extend(new_buf.iter());
                    } else {
                        self.pos = 0;
                    }

                    self.v_temp = v1;

                    return &self.v_temp[..];
                } else if s == i {
                    s += 1;
                } else {
                    break;
                }
            }
            i += 1;
        }
        self.pos = i+1;

        if s == i {
            self.read()
        } else {
            &self.stdin.fill_buf().unwrap()[s..i]
        }
    }
}

fn main() {
    let stdin = stdin();
    let stdout = stdout();
    solve(&mut Reader::new(stdin.lock()), &mut BufWriter::new(stdout.lock()));
}

fn solve(r: &mut Reader, w: &mut BufWriter<StdoutLock>) {
    write!(w, "{}", 8-(read!(r, u16)-400)/200);
}