Python 如何避免此编码挑战中的运行时错误？_Python_String_Python 3.x

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

python string python-3.x

Python 如何避免此编码挑战中的运行时错误？,python,string,python-3.x,Python,String,Python 3.x,我正在完成编码挑战。本质上，挑战要求我们在不混淆字母的情况下找到输入字符串的所有子字符串。然后，我们计算以元音开头的子串的数量，并计算以辅音开头的子串的数量编码挑战是一个游戏，其中Stuart的分数是辅音起始子串的数量，Kevin的分数是元音起始子串的数量。程序输出获胜者，即子字符串最多的获胜者例如，我创建了以下代码： def constwordfinder(word): word = word.lower() return_lst = [] for indx in

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

编码挑战是一个游戏，其中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)))

我尝试将程序构造得更简洁一些，尽管在较长的测试用例中仍然会出现运行时错误：

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

def wordfinder（word）：
word=word.lower（）
return_lst=[]
对于范围（1，len（word）+1）内的indx：
itr=indx
而itrkevin_得分：
返回“斯图尔特”+str（斯图尔特大学分数）
其他：
返回“凯文”+str（凯文分数）
打印（游戏记分2（wordfinder（输入（）））

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

这里的问题是您的算法。您正在查找文本的所有子字符串。解决这个问题需要指数时间。这就是为什么这里会出现运行时错误。您必须使用另一个好的算法来解决此问题，而不是使用子字符串。

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

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个子串，从该辅音开始。因此，对于香蕉示例，请看第一个B。使用该B，您可以制作：
B、BA、BAN、BANA、BANAN、BANANA
。这是以B或
length（string）-indexof（character）
开头的六个子字符串，这意味着
B
将
6
添加到分数中。因此，您遍历字符串，查找每个辅音，并将
length（string）-index
添加到分数中
根据我的提示，这里有一个快速而肮脏的部分解决方案：

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个子串，从该辅音开始。因此，对于香蕉示例，请看第一个B。使用该B，您可以制作：
B、BA、BAN、BANA、BANAN、BANANA
。这是以B或
length（string）-indexof（character）
开头的六个子字符串，这意味着
B
将
6
添加到分数中。因此，您遍历字符串，查找每个辅音，并将
length（string）-index
添加到分数中
你犯了什么错误？当我尝试您的代码时，
input（）
失败，必须用
raw\u input（）
替换。然后出现了内存不足的错误…不管怎样，给定字母的子字符串数是字符串长度减去字母在字符串中的零基位置。因此，两个人的分数只需通过字符串一次即可计算出来，无需建立子字符串列表。@KenY-N对于给定字符串中的子字符串，还有额外的分数string@ADG不肯恩是对的。。。他的解决方案通过了HackerRank的所有测试用例（至少）@ADG是的，刚刚创建了一个HackerRank帐户，完成了我的示例，所有测试都第一次通过。措辞确实有点建议你应该收集子字符串，但我认为这只是为了欺骗你，让你偏离正轨。你犯了什么错误？当我尝试您的代码时，
input（）
失败，必须用
raw\u input（）
替换。然后出现了内存不足的错误…不管怎样，给定字母的子字符串数是字符串长度减去字母在字符串中的零基位置。因此，两个人的分数只需通过字符串一次即可计算出来，无需建立子字符串列表。@KenY-N对于给定字符串中的子字符串，还有额外的分数string@ADG不肯恩是对的。。。他的解决方案通过了HackerRank的所有测试用例（至少）@ADG是的，刚刚创建了一个HackerRank帐户，完成了我的示例，所有测试都第一次通过。措辞确实有点建议你收集子字符串，但我认为这只是为了欺骗你，让你偏离轨道。@JoranBeasley更不确定为什么另一个非答案得到+2！好的，嗯。。。我终于找到了原因（我必须查看扰流板）（可能-1，因为它有点破坏了挑战…）哇。现在我觉得自己像个白痴