Question

我是一名二年级学生，我正在练习面试。在这个问题中，我试图从字符开始重复的点打印输入参数的子字符串。换句话说，对于像大学这样的字符串，我想要打印＆＃39; col＆＃39;，＆＃39; lege＆＃39;，＆＃39; colleg＆＃39;，＆＃ 39; E＆＃39 ;.

代码实现如下所示，但我想问一下如何考虑解决这些类型的问题，因为它们非常棘手，我想知道是否有某些算法可以快速解决这些动态问题。

def checkrepeat(word):
i = 0
temp_w =''
check_char = {}
my_l = list()
while i < len(word)-1:
    if word[i] not in check_char:
        temp_w += word[i]
        check_char[word[i]] = i
    else:
        my_l.append(temp_w)
        temp_w=''
        i = check_char[word[i]]
        check_char.pop(word[i])
    i+=1
return my_l

print(checkrepeat('college'))

Answer 1

这可能不是最佳做法，但似乎有用：

def checkrepeat(word):
    for letter in set(word):
        split_word = []
        copyword = word
        while copyword.count(letter) > 1:
            split_loc = copyword.rfind(letter)
            split_word.insert(0, copyword[split_loc:])
            copyword = copyword[:split_loc]

        if len(split_word) > 0:
            split_word.insert(0, copyword)
            print split_word

checkrepeat('college')

set(word)为我们提供了word中唯一字符的列表。我们创建一个空列表（split_word）来维护单词的单独部分。 count让我们计算一个字母出现在单词中的次数 - 我们希望将单词分开，直到每个子字符串只包含给定的letter一次。

我们迭代word的副本（因为我们需要为每个重复的字母重复练习，因此不想篡改原始的word变量），并添加结尾 - 从letter开始到我们列表开头的单词部分。我们重复此操作，直到copyword只有letter一次，此时我们退出while循环。必须将copyword的剩余字符添加到列表的开头，然后打印给定的单词。此示例打印：

['colleg', 'e']
['col', 'lege']

Answer 2

EDIT2 - 工作解决方案，半优雅且几乎是Pythonic：

def split_on_recursion(your_string, repeat_character): #Recursive function
    temp_string = ''
    i = 0
    for character in your_string:
        if repeat_character == character:
            if i==1:
                return split_on_recursion(temp_string, repeat_character) #Recursion
            else:                                                        
                i += 1
        temp_string += character
    return temp_string

def split_on_repeat(your_string):
    temp_dict = {}
    your_dict = {}
    your_end_strings = []
    for char in set(your_string):
        temp_dict[char] = your_string.count(char) #Notice temp_dict

    for key in temp_dict:
        if temp_dict[key] >= 2:
            your_dict[key] = temp_dict[key] #Isolate only the characters which repeat

    if your_dict != {}:
        for key in your_dict:
            pre_repeat_string = split_on_recursion(your_string,key)
            post_repeat_string = your_string.replace(pre_repeat_string,'')
            your_end_strings.append((pre_repeat_string, post_repeat_string))
    else:
       your_end_strings = [(your_string)]

    return your_end_strings

使用：

>>> print(split_on_repeat('Innocent'))
[('In', 'nocent')]
>>> print(split_on_repeat('College'))
[('Colleg', 'e'), ('Col', 'lege')]
>>> print(split_on_repeat('Python.py'))
[('Python.p', 'y')]
>>> print(split_on_repeat('Systems'))
[('System', 's')]

在这种情况下，解决方案区分大小写，但这是一个小问题。

要了解解决方案，您需要了解递归的工作原理。如果你不这样做，这可能不是一个很好的例子;我建议人们从数学问题开始。

但是这里有一些关于索引如何在python中工作的快速上下文：

'Word'[:1] == 'Wo'

'Word'[-1] == 'd'

'Word'[:-1] == 'Wor'

此索引适用于每个可索引的对象。

Answer 3

来自原始@ asongtoruin的想法的解决方案：

import collections


def checkrepeat(word):
    out = collections.defaultdict(int)
    for c in word:
        out[c] += 1
    out = {k: [] for (k, v) in out.items() if v > 1}

    for letter, split_word in out.iteritems():
        copyword = word

        while copyword.count(letter) > 1:
            split_loc = copyword.rfind(letter)
            split_word.insert(0, copyword[split_loc:])
            copyword = copyword[:split_loc]

        if len(split_word) > 0:
            split_word.insert(0, copyword)

    return out

for word in ["bloomberg", "college", "systems"]:
    print checkrepeat(word)

输出：

{'b': ['bloom', 'berg'], 'o': ['blo', 'omberg']}
{'e': ['colleg', 'e'], 'l': ['col', 'lege']}
{'s': ['sy', 'stem', 's']}

Answer 4

def split_repeated(string):
  visited = set()
  res = []
  for i, c in enumerate(string):
    if c in visited: res.append([string[0:i], string[i:]]) 
    visited.add(c)
  return res

输出：

split_repeated("college")
#=> [['col', 'lege'], ['colleg', 'e']]
split_repeated("hello world")
#=> [['hel', 'lo world'], ['hello w', 'orld'], ['hello wor', 'ld']]

如果您需要在第一次遇到重复的字母时拆分字符串：

def split_repeated_unique(string):
  visited = set()
  shown = set()
  res = []
  for i, c in enumerate(string):
    if c in visited:
      if c not in shown:
        res.append([string[0:i], string[i:]])
        shown.add(c)
    else:
      visited.add(c)
  return res

关键区别如下：

split_repeated("Hello, Dolly")
#=> [('Hel', 'lo, Dolly'), ('Hello, D', 'olly'), ('Hello, Do', 'lly'), ('Hello, Dol', 'ly')]
split_repeated_unique("Hello, Dolly")
#=> [['Hel', 'lo, Dolly'], ['Hello, D', 'olly']]

从字符开始重复的点开始的字符串的子串

4 个答案:

EDIT2 - 工作解决方案，半优雅且几乎是Pythonic：