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 C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;
namespace AtCoder.AGC016
{
    class ColorfulHat
    {
        public static void Main()
        {
            var yes = "Yes";
            var no = "No";
            var n = int.Parse(ReadLine());
            var testinomial = ReadLine().Trim().Split(' ').Select(_ => int.Parse(_));
            var suspect = testinomial.Distinct().OrderBy(_ => _).ToArray();
            if (suspect.Length > 2) WriteLine(no);
            else if (suspect.Length == 2 && suspect[0] + 1 != suspect[1]) WriteLine(no);
            else {
                var smaller = new Color(suspect[0], n);
                var bigger = new Color(suspect[0] + 1, n);
                foreach (var t in testinomial) {
                    if (smaller == t) {
                        smaller.Many++;
                        bigger.Single++;
                    }
                    else {
                        bigger.Many++;
                    }
                }
                if (smaller.IsNotParadoxical() || bigger.IsNotParadoxical()) WriteLine(yes);
                else WriteLine(no);
            }
        }
        struct Color
        {
            int ColorNum;
            int Num;
            public int Single, Many;
            public Color(int color, int n)
            {
                ColorNum = color;
                Num = n;
                Single = Many = 0;
            }
            public static implicit operator int(Color c)
            {
                return c.ColorNum;
            }
            public bool IsNotParadoxical()
            {
                return Num == Single + Many && ColorNum >= Single + ((Many == 0) ? 0 : 1) && ColorNum <= Single + Many / 2;
            }
        }


    }
}