如何避免在這個編碼挑戰中的運行時錯誤？

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

這裏的問題是你的算法。你正在尋找文本的所有子字符串。需要指數時間來解決問題。這就是你在這裏遇到運行時錯誤的原因。你必須使用另一個好的算法來解決這個問題，而不是使用子字符串。

Answer 2

這裏有一個快速和骯髒的部分解決方案基於我的提示：

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 

基本上，遍歷每個字符，如果是在集元音，凱文的得分剩餘字符的數目增加字符串。

其餘的工作應該是相當明顯的，我希望！

[從有問題的網站的擾流板部分被盜]由於地說每個輔音，可以使ň子與consanant開始。因此，對於BANANA示例請看第一個B。有了這個B，你可以：B, BA, BAN, BANA, BANAN, BANANA。這就是以B或length(string) - indexof(character)開頭的六個子字符串，這意味着B將6加到了分數上。所以你通過字符串，尋找每個輔音，並將length(string) - index添加到分數。