def countMinimumOperations(password: str) -> int:
    vowels = set('aeiou')
    v_chars = [c for c in password if c in vowels]
    c_chars = [c for c in password if c not in vowels]
    diff = len(v_chars) - len(c_chars)
    if diff == 0: return 0
    # Convert from larger group to smaller group |diff|/2 characters
    if diff > 0:
        candidates = v_chars; target_set = set('bcdfghjklmnpqrstvwxyz')
    else:
        candidates = c_chars; target_set = vowels
    def min_dist(ch):
        return min(abs(ord(ch) - ord(t)) for t in target_set)
    costs = sorted(min_dist(c) for c in candidates)
    return sum(costs[:abs(diff) // 2])

class Solution {
    int countMinimumOperations(String password) {
        Set<Character> vowels = new HashSet<>(Arrays.asList('a','e','i','o','u'));
        List<Character> vChars = new ArrayList<>(), cChars = new ArrayList<>();
        for (char c : password.toCharArray()) (vowels.contains(c) ? vChars : cChars).add(c);
        int diff = vChars.size() - cChars.size();
        if (diff == 0) return 0;
        List<Character> cands; Set<Character> targets;
        if (diff > 0) {
            cands = vChars;
            targets = new HashSet<>();
            for (char c = 'a'; c <= 'z'; c++) if (!vowels.contains(c)) targets.add(c);
        } else {
            cands = cChars; targets = vowels;
        }
        List<Integer> costs = new ArrayList<>();
        for (char c : cands) {
            int best = Integer.MAX_VALUE;
            for (char t : targets) best = Math.min(best, Math.abs(c - t));
            costs.add(best);
        }
        Collections.sort(costs);
        int total = 0;
        for (int i = 0; i < Math.abs(diff) / 2; i++) total += costs.get(i);
        return total;
    }
}

class Solution {
public:
    int countMinimumOperations(string password) {
        set<char> vowels = {'a','e','i','o','u'};
        vector<char> vChars, cChars;
        for (char c : password) (vowels.count(c) ? vChars : cChars).push_back(c);
        int diff = (int)vChars.size() - (int)cChars.size();
        if (diff == 0) return 0;
        vector<char>& cands = diff > 0 ? vChars : cChars;
        set<char> targets;
        if (diff > 0) for (char c = 'a'; c <= 'z'; c++) { if (!vowels.count(c)) targets.insert(c); }
        else targets = vowels;
        vector<int> costs;
        for (char c : cands) {
            int best = INT_MAX;
            for (char t : targets) best = min(best, abs(c - t));
            costs.push_back(best);
        }
        sort(costs.begin(), costs.end());
        int total = 0;
        for (int i = 0; i < abs(diff) / 2; i++) total += costs[i];
        return total;
    }
};

from typing import List
from collections import defaultdict
from datetime import datetime

def countUserLogins(logs: List[List[str]]) -> List[List[str]]:
    counter = defaultdict(int)
    for user, t, d in logs:
        try:
            h, m, s = map(int, t.split(':'))
            if not (0 <= h < 24 and 0 <= m < 60 and 0 <= s < 60): continue
            datetime.strptime(d, "%Y-%m-%d")
        except ValueError:
            continue
        counter[(user, d)] += 1
    keys = sorted(counter.keys())
    return [[u, d, str(counter[(u, d)])] for u, d in keys]

class Solution {
    String[][] countUserLogins(String[][] logs) {
        Map<String, Integer> counter = new TreeMap<>();
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern("uuuu-MM-dd").withResolverStyle(java.time.format.ResolverStyle.STRICT);
        for (String[] row : logs) {
            try {
                String[] tp = row[1].split(":");
                int h = Integer.parseInt(tp[0]), m = Integer.parseInt(tp[1]), s = Integer.parseInt(tp[2]);
                if (h < 0 || h >= 24 || m < 0 || m >= 60 || s < 0 || s >= 60) continue;
                java.time.LocalDate.parse(row[2], fmt);
            } catch (Exception e) { continue; }
            counter.merge(row[0] + "\t" + row[2], 1, Integer::sum);
        }
        List<String[]> out = new ArrayList<>();
        for (Map.Entry<String, Integer> e : counter.entrySet()) {
            String[] kp = e.getKey().split("\t");
            out.add(new String[]{kp[0], kp[1], String.valueOf(e.getValue())});
        }
        return out.toArray(new String[0][]);
    }
}

class Solution {
public:
    vector<vector<string>> countUserLogins(vector<vector<string>>& logs) {
        map<pair<string, string>, int> counter;
        for (auto& row : logs) {
            int h, m, s;
            if (sscanf(row[1].c_str(), "%d:%d:%d", &h, &m, &s) != 3) continue;
            if (h < 0 || h >= 24 || m < 0 || m >= 60 || s < 0 || s >= 60) continue;
            int yy, mm, dd;
            if (sscanf(row[2].c_str(), "%d-%d-%d", &yy, &mm, &dd) != 3) continue;
            if (mm < 1 || mm > 12 || dd < 1) continue;
            int dim[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
            bool leap = (yy % 4 == 0 && yy % 100 != 0) || yy % 400 == 0;
            if (mm == 2 && leap) dim[1] = 29;
            if (dd > dim[mm - 1]) continue;
            counter[{row[0], row[2]}]++;
        }
        vector<vector<string>> out;
        for (auto& [k, v] : counter) out.push_back({k.first, k.second, to_string(v)});
        return out;
    }
};

import heapq
from typing import List

def findMinimumPriceToSpend(price: List[int], m: int) -> int:
    h = [-p for p in price]
    heapq.heapify(h)
    while m > 0 and -h[0] > 0:
        top = -heapq.heappop(h)
        heapq.heappush(h, -(top // 2))
        m -= 1
    return -sum(h)

class Solution {
    long findMinimumPriceToSpend(int[] price, int m) {
        PriorityQueue<Long> pq = new PriorityQueue<>(Comparator.reverseOrder());
        for (int p : price) pq.add((long) p);
        while (m > 0 && pq.peek() > 0) {
            long top = pq.poll();
            pq.add(top / 2);
            m--;
        }
        long sum = 0;
        for (long v : pq) sum += v;
        return sum;
    }
}

class Solution {
public:
    long long findMinimumPriceToSpend(vector<int>& price, int m) {
        priority_queue<long long> pq;
        for (int p : price) pq.push(p);
        while (m > 0 && pq.top() > 0) {
            long long top = pq.top(); pq.pop();
            pq.push(top / 2);
            m--;
        }
        long long sum = 0;
        while (!pq.empty()) { sum += pq.top(); pq.pop(); }
        return sum;
    }
};