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 Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.util.Scanner;

class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		String[] sSplit = s.split("");

		String alphabet = "abcdefghijklmnopqrstuvwxyz";
		String[] alphabetSplit = alphabet.split("");

		int[][] distance = new int[alphabetSplit.length][sSplit.length+1];
		int[] distanceCnt = new int[alphabetSplit.length];
		int currentAlphabet;
		int prev;
		for(int i=0; i<alphabetSplit.length; i++){
			distanceCnt[i] = 0;
			prev = -1;
			for(int j=0; j<sSplit.length; j++){
				if(sSplit[j].equals(alphabetSplit[i])){
					distance[i][distanceCnt[i]++] = j - prev - 1;
					prev = j;
				}
			}
			distance[i][distanceCnt[i]] = sSplit.length - prev - 1;
		}

		int[] count = new int[alphabetSplit.length];
		int max;
		int last;
		int maxIndex = -1;
		boolean flg;
		for(int i=0; i<alphabetSplit.length; i++){
			if(distance[i][0]== sSplit.length){
				count[i] = Integer.MAX_VALUE;
			}else{
				max = 0;
				for(int j=0; j<distanceCnt[i]; j++){
					if(distance[i][j]>max){
						max = distance[i][j];
						maxIndex = j;
					}
				}
				last = distance[i][distanceCnt[i]];
				if(last>=max){
					count[i] = last;
				}else{
					count[i] = max;
					/*
					for(int k=0; k<distanceCnt[i]; k++){
						distance[i][k] -= last;
					}
					count[i] = last;
					while(true){
						for(int k=0; k<distanceCnt[i]; k++){
							distance[i][k] -= 1;
							if(distance[i][k]>distance[i][maxIndex]){
								maxIndex = k;
							}
						}
						distance[i][maxIndex] -=1;
						count[i]++;
						flg = true;
						for(int k=0; k<distanceCnt[i]; k++){
							if(distance[i][k]>0){
								flg = false;
								break;
							}
						}
						if(flg == true){
							break;
						}
					}
					*/
				}
			}
		}

		int min = Integer.MAX_VALUE;
		for(int i=0; i<alphabetSplit.length; i++){
			if(count[i]<min){
				min = count[i];
			}
		}

		System.out.print(min);

	}

}