python - 如何避免此编码挑战中的运行时错误？

Question

我正在完成 this HackerRank编码挑战。本质上，挑战要求我们在不混淆字母的情况下找到输入字符串的所有子字符串。然后，我们计算以元音开头的子串的数量和以辅音开头的子串的数量。

编码挑战的结构是一个游戏，其中斯图尔特的分数是辅音起始子串的数量，凯文的分数是元音起始子串的数量。该程序输出获胜者，即具有最多子串的那个。

例如，我创建了以下代码:

def constwordfinder(word):
    word = word.lower()
    return_lst = []
    for indx in range(1,len(word)+1):
        if word[indx-1:indx] not in ['a','e','i','o','u']:
            itr = indx
            while itr < len(word)+1:
                return_lst.append(word[indx-1:itr])
                itr +=1
    return return_lst

def vowelwordfinder(word): 
    word = word.lower()
    return_lst = []
    for indx in range(1,len(word)+1):
        if word[indx-1:indx] in ['a','e','i','o','u']:
            itr = indx
            while itr < len(word)+1:
                return_lst.append(word[indx-1:itr])
                itr +=1
    return return_lst

def game_scorer(const_list, vow_list):
    if  len(const_list) == len(vow_list):
        return 'Draw'
    else:
        if len(const_list) > len(vow_list):
            return 'Stuart ' + str(len(const_list))
        else:
            return 'Kevin ' + str(len(vow_list))

input_str = input()
print(game_scorer(constwordfinder(input_str), vowelwordfinder(input_str)))

这适用于像 BANANA 这样的较小字符串，尽管当 HackerRank 开始输入如下字符串时，我在测试用例上遇到了多个运行时错误:

NANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANANNANAN

我尝试将程序构建得更简洁一些，尽管在较长的测试用例上我仍然遇到运行时错误:

def wordfinder(word):
    word = word.lower()
    return_lst = []
    for indx in range(1,len(word)+1):
        itr = indx
        while itr < len(word)+1:
            return_lst.append(word[indx-1:itr])
            itr +=1
    return return_lst

def game_scorer2(word_list):
    kevin_score = 0
    stuart_score = 0
    for word in word_list:
        if word[0:1] not in ['a','e','i','o','u']:
            stuart_score += 1
        else: 
            kevin_score +=1
    if stuart_score == kevin_score:
        return 'Draw'
    else:
        if stuart_score > kevin_score: 
            return 'Stuart ' + str(stuart_score)
        else:
            return 'Kevin ' + str(kevin_score)

print(game_scorer2(wordfinder(input())))

我还应该做些什么来构建我的程序以避免像以前那样出现运行时错误？

Answer 1

根据我的提示，这是一个快速而肮脏的部分解决方案:

input_str = raw_input()
kevin = 0
for i, c in enumerate(input_str):
    if c.lower() in "aeiou":
        kevin += len(input_str) - i
print kevin

基本上，遍历每个字符，如果它在元音集中，则 Kevin 的分数会增加字符串中剩余字符的数量。

我希望剩下的工作应该是相当明显的!

[从相关网站的剧透部分盗取]

因为对于每个辅音，您可以生成以该辅音开头的n 个子串。因此，对于 BANANA 示例，请查看第一个 B。有了 B，您可以制作:B, BA, BAN, BANA, BANAN, BANANA。这是六个以 B 或 length(string) - indexof(character) 开头的子字符串，这意味着 B 添加了 6 到分数。因此，您遍历字符串，寻找每个辅音，然后将 length(string) - index 添加到分数中。