Problem:
Score : 300 points

Problem Statement

Snuke can change a string t of length N into a string t' of length N - 1 under the following rule:

For each i (1 ≤ i ≤ N - 1), the i-th character of t' must be either the i-th or (i + 1)-th character of t.

There is a string s consisting of lowercase English letters.
Snuke's objective is to apply the above operation to s repeatedly so that all the characters in s are the same.
Find the minimum necessary number of operations.

Constraints

1 ≤ |s| ≤ 100

s consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

s

Output

Print the minimum necessary number of operations to achieve the objective.

Sample Input 1

serval

Sample Output 1

3

One solution is: serval → srvvl → svvv → vvv.

Sample Input 2

jackal

Sample Output 2

2

One solution is: jackal → aacaa → aaaa.

Sample Input 3

zzz

Sample Output 3

0

All the characters in s are the same from the beginning.

Sample Input 4

whbrjpjyhsrywlqjxdbrbaomnw

Sample Output 4

8

In 8 operations, he can change s to rrrrrrrrrrrrrrrrrr.

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::{BufRead, Write};
use std::io;
use std::usize;

fn solve<R: BufRead, W: Write>(mut input: R, mut output: W) {
    let mut st = String::new();
    input.read_line(&mut st).unwrap();
    let mut fin: usize = usize::MAX;
    let counts: Vec<usize> = (0..26)
        .map(|c| {
            st.trim()
                .chars()
                .filter(|x| *x as u32 == ('a' as u32 + c))
                .count()
        })
        .collect();
    let targets: Vec<char> = counts
        .iter()
        .enumerate()
        .filter(|&(_, x)| x == counts.iter().max().unwrap())
        .map(|(n, _)| (n as u8 + 'a' as u8) as char)
        .collect();
    for target in targets {
        let mut result: usize = 0;
        let mut s = st.trim().to_owned();
        while !s.chars().all(|x| x == s.chars().next().unwrap()) {
            s = (0..s.len() - 1)
                .map(|x| if s.chars().nth(x).unwrap() == target {
                    target
                } else {
                    s.chars().nth(x + 1).unwrap()
                })
                .collect();
            result += 1;
        }
        if result < fin {
            fin = result
        };
    }
    writeln!(output, "{}", fin).unwrap();
}

fn main() {
    let stdin = io::stdin();
    let stdout = io::stdout();
    solve(stdin.lock(), stdout.lock());
}

#[cfg(test)]
mod tests {
    fn test(input: &str, output: &str) {
        let mut v: Vec<u8> = Vec::new();
        ::solve(input.as_bytes(), &mut v);
        assert_eq!(String::from_utf8(v).unwrap(), output);
    }
    #[test]
    fn case1() {
        test("serval\n", "3\n");
    }
    #[test]
    fn case2() {
        test("jackal\n", "2\n");
    }
    #[test]
    fn case3() {
        test("zzz\n", "0\n");
    }
    #[test]
    fn case4() {
        test("whbrjpjyhsrywlqjxdbrbaomnw\n", "8\n");
    }
}