题解 | #小红的大小写字母#

#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>

using namespace std;

void solve() {
    int n;
    long long k;
    cin >> n >> k;
    string s;
    cin >> s;

    int upper_count = 0;
    // 统计初始大写字母数量
    for (char c : s) {
        if (c >= 'A' && c <= 'Z') {
            upper_count++;
        }
    }

    // 从 n 到 0 遍历所有可能的大写字母目标数量 T
    for (int T = n; T >= 0; --T) {
        // 计算达到目标 T 所需的最小操作次数
        long long min_ops = abs(T - upper_count);
        
        // 检查是否满足两个条件：
        // 1. 总操作次数 k 不少于最小操作次数
        // 2. 剩余的操作次数 (k - min_ops) 是偶数，可以成对抵消
        if (k >= min_ops && (k - min_ops) % 2 == 0) {
            cout << T << endl;
            return;
        }
    }
}

int main() {
    solve();
    return 0;
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long k = sc.nextLong();
        String s = sc.next();

        int upper_count = 0;
        // 统计初始大写字母数量
        for (int i = 0; i < n; i++) {
            if (Character.isUpperCase(s.charAt(i))) {
                upper_count++;
            }
        }

        // 从 n 到 0 遍历所有可能的大写字母目标数量 T
        for (int T = n; T >= 0; T--) {
            // 计算达到目标 T 所需的最小操作次数
            long min_ops = Math.abs(T - upper_count);
            
            // 检查是否满足两个条件：
            // 1. 总操作次数 k 不少于最小操作次数
            // 2. 剩余的操作次数 (k - min_ops) 是偶数，可以成对抵消
            if (k >= min_ops && (k - min_ops) % 2 == 0) {
                System.out.println(T);
                return;
            }
        }
    }
}

def solve():
    n, k = map(int, input().split())
    s = input()

    upper_count = 0
    # 统计初始大写字母数量
    for char in s:
        if 'A' <= char <= 'Z':
            upper_count += 1
    
    # 从 n 到 0 遍历所有可能的大写字母目标数量 T
    for T in range(n, -1, -1):
        # 计算达到目标 T 所需的最小操作次数
        min_ops = abs(T - upper_count)
        
        # 检查是否满足两个条件：
        # 1. 总操作次数 k 不少于最小操作次数
        # 2. 剩余的操作次数 (k - min_ops) 是偶数，可以成对抵消
        if k >= min_ops and (k - min_ops) % 2 == 0:
            print(T)
            return

solve()