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: Accepted)

use std::str::FromStr;
use std::fmt::Debug;
use std::cmp;
use std::collections::HashSet;
#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()
}

#[allow(dead_code)]
fn read_as_string() -> String{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

fn main(){
    let s  = read_as_string().chars().collect::<Vec<char>>();
    let mut hash: HashSet<char> = HashSet::new();

    for c in &s{
        hash.insert(*c);
    }

    let mut ans = std::usize::MAX;
    for target in hash{
        //println!("target = {}", target);
        let mut t = s.clone();
        let mut cur_cost = 0;
        while !t.iter().all(|x| *x == target){
            //println!("t = {:?}", t);
            let mut tn: Vec<char> = vec!['A';t.len()-1];
            for i in 0..t.len()-1{
                if t[i] == target || t[i+1] == target{
                    tn[i] = target;
                }else{
                    tn[i] = t[i];
                }
            }
            //println!("tn = {:?}", tn);
            cur_cost += 1;
            t = tn;
        }
        ans = cmp::min(cur_cost, ans);
    }

    println!("{}", ans);
}