def ss(arr):
    from bisect import bisect_left
    def so(nums):
        if not nums:
            return 0
        tails = []
        for num in nums:
            pos = bisect_left(tails, num)
            if pos == len(tails):
                tails.append(num)
            else:
                tails[pos] = num
        return len(tails)
    n = len(arr)
    if n == 0:
        return 0
    a = so(arr)
    t = n - a
    return t

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
int solve(const string& str) {
    vector<char> vowels = {'a', 'e', 'i', 'o', 'u'};
    const int a = 10;
        vector<int> freq(26, 0);
    for (char c : str) {
        freq[c - 'a']++;
    }
    
    int n = str.size();
    int minCost = INT_MAX;
        for (char target : vowels) {
        int cost = 0;
        for (int i = 0; i < 26; ++i) {
            char c = 'a' + i;
            if (c == target) continue; 
            if (freq[i] > 0) {
                if (find(vowels.begin(), vowels.end(), c) != vowels.end()) {
                    cost += freq[i] * abs(c - target);
                } else {
                    cost += freq[i] * a;
                }
            }
        }
        minCost = min(minCost, cost);
    }
        for (char c : str) {
        if (find(vowels.begin(), vowels.end(), c) == vowels.end()) {
            return minCost; 
        }
    }
    
    return -1; 
}

int main() {
    string str;
    cin >> str;
    
    cout << solve(str) << endl;
    
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int solve(int N, const vector<int>& A) {
    if (N == 0) return 0;
    vector<int> dp(N, 0);
    for (int i = 0; i < N; ++i) {
        int a = A[i];
        int b = A[i];
                for (int j = i; j >= 0; --j) {
            a = min(a, A[j]);
            b = max(b, A[j]);
            int c = b - a;
            if (j > 0) {
                dp[i] = max(dp[i], dp[j - 1] + c);
            } else {
                dp[i] = max(dp[i], c);
            }
        }
    }
    
    return dp[N - 1];
}

long getPairs(int x, vector<int> cost) {
    unordered_map<long, long> mp;
    long count = 0;

    for (int c : cost) {
        long rem = c % x;
        long comp = (x - rem) % x;
        count += mp[comp];
        mp[rem]++;
    }

    return count;
}