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

【问题标题】：How to avoid Runtime error in this coding challenge?如何避免此编码挑战中的运行时错误？
【发布时间】：2016-07-05 04:19:00
【问题描述】：

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

编码挑战的结构是一个游戏，其中 Stuart 的分数是辅音起始子串的数量，Kevin 的分数是元音起始子串的数量。该程序输出获胜者，即具有最多子字符串的获胜者。

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

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())))

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

【问题讨论】：

您遇到了什么错误？当我尝试您的代码时，input() 失败，必须用raw_input() 替换。然后出现内存不足错误...
无论如何，给定字母的子串数是字符串的长度减去该字母在字符串中从零开始的位置。因此，两个人的分数都可以通过字符串计算一次，无需建立子字符串列表。
@KenY-N 对于给定字符串中的子字符串单词有额外的评分
@ADG no ... Ken Y-N 是对的...他的解决方案通过了所有 hackerranks 测试用例（至少）
@ADG 是的，刚刚创建了一个 HackerRank 帐户，完成了我的示例，一切都通过了第一次。措辞确实暗示您应该收集子字符串，但我认为这只是为了欺骗您并让您偏离轨道。

标签： python string python-3.x

【解决方案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 添加到分数中。

【讨论】：

@JoranBeasley 更不确定为什么其他未回答的人得到了 +2！
ok duh ...我终于找到了原因（我不得不查找剧透）（可能是-1，因为它有点破坏了挑战...）
哇。现在我觉得自己像个白痴一样没有注意到这一点。尽管如此，还是感谢您的回答。

【解决方案2】：

这里的问题是您的算法。您正在查找文本的所有子字符串。解决问题需要指数级的时间。这就是您在这里遇到运行时错误的原因。你必须使用另一种好的算法来解决这个问题，而不是使用子字符串。

【讨论】：