Heap Overflow

我不认为你想要的形式有好的。你的方式已经很好了。我能想到的另一种方法是一次添加一个项目来构建它们。

prefix = []
for x in lst:
    prefix.append(x)
    print(prefix)

交换 'G' 和 'C' ,你 使用 'T' “T” “T”

>>> 'ATGC'.replace('A', 'U').replace('T', 'A').replace('C', 'T').replace('G', 'C').replace('T', 'G')
'UACG'

类似于两个变量的非Python交换 c 和 g

t = c
c = g
g = t

而不是

c, g = g, c

你的错误是 inp = input()[:-1] [:-1] 切掉这个词的最后一个字符。我想你是想删除换行符,但是 input() 已经是了“ stripping a trailing newline

>>> [input() for _ in range(2)]
foo
bar
['foo', 'bar']

更简单的解决方案,顺便说一句:

from collections import Counter

ctr = Counter(input() for _ in range(int(input())))
print(len(ctr))
print(*ctr.values())

from collections import Counter

ctr = Counter(map(input, [''] * int(input())))
print(len(ctr))
print(*ctr.values())

另一个:

from collections import Counter
import sys

next(sys.stdin)
ctr = Counter(map(str.strip, sys.stdin))
print(len(ctr))
print(*ctr.values())

这一个读整行,所以这里的字符串 做 包括换行符。那没关系,如果 全部的 strip 每一行都有。叹息。

如果不需要新的列表和修改 A 足够:

for a, b in zip(A, B):
    a.append(b)

它更有效,至少对于更长的内部列表。

不需要传递索引。如果值就在这里,则返回0。否则获取尾部的索引并添加1。

def index(self, x):
    if x == self.value:
        return 0
    return self.tail.index(x) + 1

l.__getitem__ 速度是它的两倍多,既然这是它自己的方法,我怀疑你能打败它。

>>> timeit('f(i)', 'l=[1,2,3]; i=1; f=lambda i:l[i]', number=10**8)
17.013631199999963
>>> timeit('f(i)', 'l=[1,2,3]; i=1; f=l.__getitem__', number=10**8)
7.722098399999936

它是O(n),但是索引查找参数是一个红鲱鱼。

如果这样做,索引查找速度将很重要:

for index in range(len(mystring)):
    char = mystring[index]
    ...

但你是 不 使用索引。你用的是 迭代器 ,更确切地说是 一串 迭代器:

>>> iter('test')
<str_iterator object at 0x03569820>

迭代器会记住它在字符串中的位置(不管它喜欢什么方式,都不需要是“索引”)。并且可以反复询问下一个字符:

>>> it = iter('test')
>>> next(it)
't'
>>> next(it)
'e'
>>> next(it)
's'
>>> next(it)
't'
>>> next(it)
Traceback (most recent call last):
  File "<pyshell#200>", line 1, in <module>
    next(it)
StopIteration

这就是 for -循环是的。它创建那个迭代器,然后重复地向它请求下一个值,直到迭代器告诉它停止为止。它从迭代器获得的每一个值,都会在您命名的变量中赋予您的代码。换句话说 对于 -循环实际上只是迭代器和循环体中的代码之间的中间人。

与字符串相反,想象一个简单的链表。链表中的索引查找采用O(n),因为每次查找都需要从链表的开头走到所需的节点。但是您仍然可以很容易地在O(n)中进行完整的迭代,对吗?迭代器对象将保留对下一个节点的引用,因此它将在O(1)时间内提供它(然后向前移动它的引用)。所以对于链表来说 对于 -使用索引的循环将花费O(n ^2个 )但是正常的蟒蛇 对于 -循环(隐式使用链表迭代器)将是O(n)。

你甚至可以模仿 对于 -用一个 while -循环和显式迭代器由您自己处理,而不是让 对于 -循环处理它给你。而不是

for char in 'test':
    print(char)

执行以下操作:

it = iter('test')
while True:
    try:
        char = next(it)
    except StopIteration:
        break
    print(char)

上面印着:

t
e
s
t