生成具有较低拉丁字母的大随机字符串的最快方法

Question

我正试图从蒂姆斯在线评判中解决这个问题.要解决此问题,您需要生成一个包含1 000 000个小写拉丁字母的序列,并在1秒内将其写入标准输入.

使用C++或Java很容易解决这个问题.我这里有python解决方案:

import os
from random import randint

s = ''.join(chr(97 + randint(0, 25)) for i in range(1000000))
os.write(1, bytes(s, 'utf8'))

需要1.7秒:

$ time python3.3 1219.py > /dev/null

real    0m1.756s
user    0m1.744s
sys     0m0.008s

我得到了"超出时间限制"的结果.所以问题是"如何更快地做到这一点？"

UPD1:使用randint(97, 122)减少16ms的时间.现在是1.740s

UPD2: @Martijn Pieters的解决方案需要0.979秒,但它也没有通过测试.

UPD3 Martijn Pieters提出了一个非常好的解决方案,但它仍然很慢:

from sys import stdin
from random import choice
from string import ascii_lowercase

s = ''.join([choice(ascii_lowercase) for _ in range(1000000)])
stdout.write(s) 

需要0.924秒

from sys import stdout
from random import choice
from string import ascii_lowercase

for _ in range(1000000):
    stdout.write(choice(ascii_lowercase))

需要1.173秒

from sys import stdout
from random import choice
from string import ascii_lowercase
bal = [c.encode('ascii') for c in ascii_lowercase]
out = stdout.buffer

for _ in range(1000000):
    out.write(choice(bal))

需要1.155秒

from sys import stdout
from random import choice
from string import ascii_lowercase

bal = [c.encode('ascii') for c in ascii_lowercase]
stdout.buffer.write(b''.join([choice(bal) for _ in range(1000000)]))

需要0.901s

UPD4

有些人刚刚解决了Timus的问题.我希望他能分享他的解决方案:)

UPD5 感谢Ashwini Chaudhary与我们分享他的Python 2.x解决方案:

from random import choice
from string import ascii_lowercase
lis=list(ascii_lowercase)
print ''.join(choice(lis) for _ in xrange(1000000)) 

我的电脑需要0.527秒才能通过Timus的测试.但是仍然存在Python3.x的问题.

UPD6 感谢Markku K.这段代码:

import os
from random import random
from string import ascii_lowercase

bal = [c.encode('ascii') for c in ascii_lowercase]
os.write(1, b''.join([bal[int(random() * 26)] for _ in range(1000000)]))

需要0.445秒,但仍未通过测试

Answer 1

这是Python 3代码,在0.28几秒钟内生成1000000个"随机"小写字母(另请参阅0.11最后的-seconds解决方案; @Ashwini Chaudhary的问题代码0.55在我的机器上需要几秒钟,@ Markku K.的代码 - 0.53):

#!/usr/bin/env python3
import os
import sys

def write_random_lowercase(n):
    min_lc = ord(b'a')
    len_lc = 26
    ba = bytearray(os.urandom(n))
    for i, b in enumerate(ba):
        ba[i] = min_lc + b % len_lc # convert 0..255 to 97..122
    sys.stdout.buffer.write(ba)

write_random_lowercase(1000000)

% len_lc 虽然它仍然满足条件(ascii,小写,1,2,3个字母序列的频率),但是会扭曲分布(最后看到如何修复它):

$ python3 generate-random.py | python3 check-seq.py

其中check-seq.py:

#!/usr/bin/env python3
import sys
from collections import Counter
from string import ascii_lowercase

def main():
    limits = [40000, 2000, 100]

    s = sys.stdin.buffer.readline() # a single line
    assert 1000000 <= len(s) <= 1000002 # check length +/- newline
    s.decode('ascii','strict') # check ascii
    assert set(s) == set(ascii_lowercase.encode('ascii')) # check lowercase

    for n, lim in enumerate(limits, start=1):
        freq = Counter(tuple(s[i:i+n]) for i in range(len(s)))
        assert max(freq.values()) <= lim, freq

main()

注意:在acm.timus.ru上generate-random.py给出"超出输出限制".

要提高性能,可以使用bytes.translate()方法(0.11秒):

#!/usr/bin/env python3
import os
import sys

# make translation table from 0..255 to 97..122
tbl = bytes.maketrans(bytearray(range(256)),
                      bytearray([ord(b'a') + b % 26 for b in range(256)]))
# generate random bytes and translate them to lowercase ascii
sys.stdout.buffer.write(os.urandom(1000000).translate(tbl))

如何修复% len_lc偏斜

256(字节数)不能被26(低位拉丁字母的数量)整除,因此公式min_lc + b % len_lc使得某些值看起来不像其他值,例如:

#!/usr/bin/env python3
"""Find out skew: x = 97 + y % 26 where y is uniform from [0, 256) range."""
from collections import Counter, defaultdict

def find_skew(random_bytes):
    char2freq = Counter(chr(ord(b'a') + b % 26) for b in random_bytes)
    freq2char = defaultdict(set)
    for char, freq in char2freq.items():
        freq2char[freq].add(char)
    return {f: ''.join(sorted(c)) for f, c in freq2char.items()}

print(find_skew(range(256)))
# -> {9: 'wxyz', 10: 'abcdefghijklmnopqrstuv'}

这里,输入range(256)是均匀分布的(每个字节恰好出现一次),但'wxyz'输出中的字母比休息9与10出现的次数少.要修复它,可以删除未对齐的字节:

print(find_skew(range(256 - (256 % 26))))
# -> {9: 'abcdefghijklmnopqrstuvwxyz'}

这里,输入是均匀分布的字节,[0, 234)输出均匀分布为小写字母.

bytes.translate() 接受第二个参数来指定要删除的字节:

#!/usr/bin/env python3
import os
import sys

nbytes = 256
nletters = 26
naligned = nbytes - (nbytes % nletters)
tbl = bytes.maketrans(bytearray(range(naligned)),
                      bytearray([ord(b'a') + b % nletters
                                 for b in range(naligned)]))
bytes2delete = bytearray(range(naligned, nbytes))
R = lambda n: os.urandom(n).translate(tbl, bytes2delete)

def write_random_ascii_lowercase_letters(write, n):
    """*write* *n* random ascii lowercase letters."""    
    while n > 0:
        # R(n) expected to drop `(nbytes - nletters) / nbytes` bytes
        # to compensate, increase the initial size        
        n -= write(memoryview(R(n * nbytes // naligned + 1))[:n])

write = sys.stdout.buffer.write
write_random_ascii_lowercase_letters(write, 1000000)

如果随机生成器(os.urandom此处)生成在对齐范围(>=234)之外的长字节序列,则while循环可以执行多次.

如果random.getrandbits(8*n).to_bytes(n, 'big')使用的话,时间性能可以提高另一个数量级os.urandom(n).前者使用Mersenne Twister作为核心生成器,可能比os.urandom()使用操作系统提供的源更快.如果您使用随机字符串作为秘密,后者更安​​全.

Answer 2

使用string.ascii_lowercase而不是chr生成小写字符：

from sys import stdin
from random import choice
from string import ascii_lowercase

s = ''.join([choice(ascii_lowercase) for _ in range(1000000)])
stdout.write(s)

同样stdout直接写入似乎更快，在 python 中编码自己并不比在 C 代码中处理它快。

我也使用列表理解；str.join()需要扫描输入序列两次，一次确定输出的长度，一次实际将输入元素复制到输出字符串。列表推导式击败了较慢的生成器到列表代码。

只需使用choice(ascii_lowercase)over 从整数生成每个字符的方法，速度就会快两倍多：

>>> timeit.timeit('f()', 'from __main__ import yours as f', number=3)
11.299837955011753
>>> timeit.timeit('f()', 'from __main__ import mine as f', number=3)
5.330044150992762

您可以尝试''.join()通过将单个字符直接写入来避免开销stdout：

from sys import stdout
from random import choice
from string import ascii_lowercase

for _ in range(1000000):
    stdout.write(choice(ascii_lowercase))

接下来要尝试的是写入原始字节：

from sys import stdout
from random import choice
from string import ascii_lowercase
bal = [c.encode('ascii') for c in ascii_lowercase]
out = stdout.buffer

for _ in range(1000000):
    out.write(choice(bal))

但''.join()在我的测试中这些都没有改进。

接下来，我们将 ASCII 字符编码为字节一次，然后使用bytes.join()：

from sys import stdout
from random import choice
from string import ascii_lowercase

bal = [c.encode('ascii') for c in ascii_lowercase]
stdout.buffer.write(b''.join([choice(bal) for _ in range(1000000)]))

bal 是一个编码为字节的小写 ASCII 字符列表，我们从中随机选择 100 万个项目，将它们连接成一个大字节字符串，然后将其一次性写入二进制标准输出缓冲区。

字节连接与字符串版本一样“慢”：

>>> timeit.timeit('f()', 'from __main__ import bytes as f', number=3)
5.41390264898655

但是我们编码了 26 个字符，而不是 100 万个，因此写入阶段更快。