从给定的字符串中查找元音的子数组答案

【问题标题】：Finding Subarrays of Vowels from a given String从给定的字符串中查找元音的子数组
【发布时间】：2019-03-20 18:10:05
【问题描述】：

给你一个字符串 S，你必须找到 S 的所有惊人子串。

Amazing Substring 是以元音 (a, e, i, o, u, A, E, I, O, U) 开头的字符串。

输入

给出的唯一参数是字符串 S。

输出

返回一个整数 X mod 10003，这里 X 是给定字符串中惊人子字符串的数量。

约束

1
S 可以有特殊字符

示例

Input
    ABEC

Output
    6

Explanation
    Amazing substrings of given string are :
    1. A
    2. AB
    3. ABE
    4. ABEC
    5. E
    6. EC
    here number of substrings are 6 and 6 % 10003 = 6.

我已经针对上述问题实现了以下算法。

    class Solution:
        # @param A : string
        # @return an integer
        def solve(self, A):
            x = ['a', 'e','i','o', 'u', 'A', 'E', 'I', 'O', 'U']
            y = []
            z = len(A)
            for i in A:
                if i in x:
                    n = A.index(i)
                    m = z
                    while m > n:
                        y.append(A[n:m])
                        m -= 1
            if y:
                return len(y)%10003
            else:
            return 0

上述解决方案适用于正常长度的字符串，但不适用于更长的长度。

例如，

A = "pGpEusuCSWEaPOJmamlFAnIBgAJGtcJaMPFTLfUfkQKXeymydQsdWCTyEFjFgbSmknAmKYFHopWceEyCSumTyAFwhrLqQXbWnXSn"

算法输出 1630 个子数组，但预期的答案是 1244。

请帮助我改进上述算法。感谢您的帮助

【问题讨论】：

标签： python arrays string algorithm

【解决方案1】：

关注所需的输出：您不需要找到所有这些子字符串。您所需要的只是子字符串的数量。

再次查看您的简短示例，ABEC。有两个元音，A 和 E。

A 位于位置 0。总共有 4 个子字符串，以该位置和随后的每个位置结束。
E 位于位置 2。总共有 2 个子字符串，以该位置和随后的每个位置结束。

2+4 => 6

你需要做的就是找到每个元音的位置，从字符串长度中减去，然后累积这些差异：

A = "pGpEusuCSWEaPOJmamlFAnIBgAJGtcJaMPFTLfUfkQKXeymydQsdWCTyEFjFgbSmknAmKYFHopWceEyCSumTyAFwhrLqQXbWnXSn"

lenA = len(A)
vowel = "aeiouAEIOU"
count = 0

for idx, char in enumerate(A):
    if char in vowel:
       count += lenA - idx

print(count%10003)

输出：

在单个命令中：

print( sum(len(A) - idx if char.lower() in "aeiou" else 0
       for idx, char in enumerate(A)) )

【讨论】：

它如何关心重复的字符串？ aaa => a, aa, aaa, a, aa, a
@amirbeygi：我不清楚你想知道什么。你得到了什么结果，你不明白？

【解决方案2】：

当你在一个字符串中敲击一个元音时，所有以这个元音开头的子字符串都是“惊人的”，所以你可以数一数：

def solve(A):
            x = ['a', 'e','i','o', 'u', 'A', 'E', 'I', 'O', 'U']
            ans = 0

            for i in range(len(A)):
                if A[i] in x:
                    ans = (ans + len(A)-i)%10003
            return ans

【讨论】：

【解决方案3】：

当您查找元素n = A.index(i) 的索引时，您将获得该元素第一次出现的索引。通过使用enumerate，您可以同时循环遍历索引和元素。

def solve(A):
    x = ['a', 'e','i','o', 'u', 'A', 'E', 'I', 'O', 'U']
    y = []
    z = len(A)
    for n,i in enumerate(A):
        if i in x:
            m = z
            while m > n:
                y.append(A[n:m])
                m -= 1
    if y:
        return len(y)%10003
    else:
        return 0

【讨论】：

【解决方案4】：

一个更通用的解决方案是找到所有惊人的子字符串，然后对它们进行计数：

string = "pGpEusuCSWEaPOJmamlFAnIBgAJGtcJaMPFTLfUfkQKXeymydQsdWCTyEFjFgbSmknAmKYFHopWceEyCSumTyAFwhrLqQXbWnXSn"

amazing_substring_start = ['a','e','i','o','u','A','E','I','O','U']

amazing_substrings = []

for i in range(len(string)):
    if string[i] in amazing_substring_start:
        for j in range(len(string[i:])+1):
            amazing_substring = string[i:i+j]
            if amazing_substring!='':
                amazing_substrings += [amazing_substring]

print amazing_substrings,len(amazing_substrings)%10003

【讨论】：