Question

我正在完成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())))

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

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

基本上，迭代每个字符，如果它在元音集中，凯文的分数会增加字符串中剩余字符的数量。

我希望剩下的工作应该是显而易见的！

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

因为对每个辅音说，您可以从辅音开始 n子串。因此，对于 BANANA 示例，请查看第一个 B 。使用 B ，您可以制作：B, BA, BAN, BANA, BANAN, BANANA。这是从 B 或length(string) - indexof(character)开始的六个子字符串，这意味着B会在评分中添加6。因此，您浏览字符串，查找每个辅音，并将length(string) - index添加到乐谱中。

Answer 2

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

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

2 个答案: