Problem:
Score : 100 points

Problem Statement

Given is a lowercase English letter C that is not z. Print the letter that follows C in alphabetical order.

Constraints

C is a lowercase English letter that is not z.

Input

Input is given from Standard Input in the following format:

C

Output

Print the letter that follows C in alphabetical order.

Sample Input 1

a

Sample Output 1

b

a is followed by b.

Sample Input 2

y

Sample Output 2

z

y is followed by z.

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

fn main() {
    let mut scan = Scanner::new();
    let c = scan.char();
    println!("{}", (c as u8 + 1) as char);
}

use std::io::{BufReader, stdin, Stdin, Read, Bytes};
use std::str::FromStr;

pub struct Scanner {
    buf: Bytes<BufReader<Stdin>>
}

#[allow(dead_code)]
impl Scanner {
    pub fn new() -> Scanner {
        Scanner {
            buf: BufReader::new(stdin()).bytes()
        }
    }

    pub fn read1<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.read1().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()
    }
}