返回目录

题目描述

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

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

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

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

输入描述

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

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

输出描述

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

示例：

Python算法源码

def main():
    # 输入缺陷值
    flaw = int(input())
    # 输入字符串
    input_string = input()
    # 定义元音字母集合
    vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}
    # 找到字符串中元音字母的索引
    vowel_idxs = [idx for idx, char in enumerate(input_string) if char in vowels]
    left = 0
    right = 0
    lengths = []

    while right < len(vowel_idxs):
        # 计算当前连续元音字母子串长度与缺陷值的差值
        length_diff = vowel_idxs[right] - vowel_idxs[left] - (right - left)
        if length_diff > flaw:
            left += 1
        else:
            if length_diff == flaw:
                lengths.append(vowel_idxs[right] - vowel_idxs[left] + 1)
            right += 1

    if not lengths:
        print(0)
        return

    # 对长度列表进行排序并输出最大长度
    lengths.sort(reverse=True)
    print(lengths[0])

if __name__ == "__main__":
    main()

C算法源码

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

// 获取结果函数
int getResult(int flaw, char *s) {
    char vowels[] = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}; // 元音字母数组
    int vowels_count = 10; // 元音字母数量

    int idxs[100]; // 假设输入字符串的最大长度为100
    int idxs_idx = 0;

    // 遍历输入字符串，记录元音字母的索引
    for (int i = 0; i < strlen(s); i++) {
        for (int j = 0; j < vowels_count; j++) {
            if (s[i] == vowels[j]) {
                idxs[idxs_idx++] = i; // 记录元音字母的索引
                break;
            }
        }
    }

    int ans = 0; // 结果初始化为0
    int n = idxs_idx; // 元音字母索引数组的长度

    int l = 0; // 左指针初始化为0
    int r = 0; // 右指针初始化为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++;
        }
    }

    return ans; // 返回结果
}

int main() {
    int flaw;
    printf("请输入瑕疵度："); // 提示用户输入瑕疵度
    scanf("%d", &flaw);

    char s[100];
    printf("请输入字符串："); // 提示用户输入字符串
    scanf("%s", s);

    int result = getResult(flaw, s); // 调用函数获取结果
    printf("%d\n", result); // 输出结果

    return 0;
}

Java算法源码

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;

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

        System.out.print("请输入瑕疵度："); // 提示用户输入瑕疵度
        int flaw = sc.nextInt();
        System.out.print("请输入字符串："); // 提示用户输入字符串
        String s = sc.next();

        System.out.println(getResult(flaw, s)); // 输出结果
    }

    // 获取结果函数
    public static int getResult(int flaw, String s) {
        char[] vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}; // 元音字母数组
        HashSet<Character> set = new HashSet<>();
        for (char c : vowels) set.add(c);

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

        int ans = 0; // 结果初始化为0
        int n = idxs.size(); // 元音字母索引数组的长度

        int l = 0; // 左指针初始化为0
        int r = 0; // 右指针初始化为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++;
            }
        }

        return ans; // 返回结果
    }
}