题目描述

开头和结尾都是元音字母（aeiouAEIOU）的字符串为元音字符串，其中混杂的非元音字母数量为其瑕疵度。比如:

1. “a” 、 “aa”是元音字符串，其瑕疵度都为0
2. “aiur”不是元音字符串（结尾不是元音字符）
3. “abira”是元音字符串，其瑕疵度为2

给定一个字符串，请找出指定瑕疵度的最长元音字符子串，并输出其长度，如果找不到满足条件的元音字符子串，输出0。

子串：字符串中任意个连续的字符组成的子序列称为该字符串的子串。

输入描述

首行输入是一个整数，表示预期的瑕疵度flaw，取值范围[0, 65535]。

接下来一行是一个仅由字符a-z和A-Z组成的字符串，字符串长度(0, 65535]。

输出描述

输出为一个整数，代表满足条件的元音字符子串的长度。

示例：

C算法源码

#include <stdio.h>
#include <string.h>

int main() {
    int flaw;
    scanf("%d", &flaw); // 输入瑕疵度

    char s[1000];
    scanf("%s", s); // 输入字符串

    char set[10] = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}; // 定义元音字符集合

    int idxs[100];
    int idxs_size = 0;
    for (int i = 0; i < strlen(s); i++) {
        for (int j = 0; j < 10; j++) {
            if (s[i] == set[j]) {
                idxs[idxs_size] = i; // 记录元音字符的位置
                idxs_size++;
                break;
            }
        }
    }

    int ans = 0;
    int n = idxs_size;

    int l = 0;
    int r = 0;

    while (r < n) {
        // 瑕疵度计算
        int diff = idxs[r] - idxs[l] - (r - l);

        if (diff > flaw) {
            l++;
        } else if (diff < flaw) {
            r++;
        } else {
            ans = (ans > idxs[r] - idxs[l] + 1) ? ans : idxs[r] - idxs[l] + 1; // 更新最长子串的长度
            r++;
        }
    }

    printf("%d\n", ans); // 输出结果

    return 0;
}

Python算法源码

assistant: ```python
flaw = int(input())  # 输入瑕疵度

s = input()  # 输入字符串

vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']  # 定义元音字符集合

idxs = []
for i in range(len(s)):
    if s[i] in vowels:
        idxs.append(i)  # 记录元音字符的位置

ans = 0
n = len(idxs)

l = 0
r = 0

while r < n:
    # 瑕疵度计算
    diff = idxs[r] - idxs[l] - (r - l)

    if diff > flaw:
        l += 1
    elif diff < flaw:
        r += 1
    else:
        ans = max(ans, idxs[r] - idxs[l] + 1)  # 更新最长子串的长度
        r += 1

print(ans)  # 输出结果

Java算法源码

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int flaw = sc.nextInt(); // 输入瑕疵度
        sc.nextLine();

        String s = sc.nextLine(); // 输入字符串

        Set<Character> set = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U')); // 定义元音字符集合

        List<Integer> idxs = new ArrayList<>();
        for (int i = 0; i < s.length(); i++) {
            if (set.contains(s.charAt(i))) {
                idxs.add(i); // 记录元音字符的位置
            }
        }

        int ans = 0;
        int n = idxs.size();

        int l = 0;
        int r = 0;

        while (r < n) {
            // 瑕疵度计算
            int diff = idxs.get(r) - idxs.get(l) - (r - l);

            if (diff > flaw) {
                l++;
            } else if (diff < flaw) {
                r++;
            } else {
                ans = Math.max(ans, idxs.get(r) - idxs.get(l) + 1); // 更新最长子串的长度
                r++;
            }
        }

        System.out.println(ans); // 输出结果
    }
}