给定一百万个数字的字符串，返回所有重复的3位数字

Question

几个月前我在纽约接受了一家对冲基金公司的采访，不幸的是，我没有获得数据/软件工程师的实习机会。 （他们还要求解决方案使用Python。）

我几乎搞砸了第一个面试问题......

  

问题：给出一百万个数字的字符串（例如Pi），写一下   一个函数/程序，返回所有重复的3位数字和数字   重复大于1

例如：如果字符串是：123412345123456，那么函数/程序将返回：

123 - 3 times
234 - 3 times
345 - 2 times

在我面试失败后，他们没有给我解决方案，但他们确实告诉我，解决方案的时间复杂度始终为1000，因为所有可能的结果都介于：

000 - ＆gt; 999

既然我正在考虑它，我认为不可能提出一个恒定的时间算法。是吗？

Answer 1

你轻描淡写，你可能不想要为一个对手基金工作，那里的量子不懂基本算法： - ）

如果在O(1)中处理任意大小的数据结构，则有 no 方法，因为在这种情况下，您需要至少访问一次每个元素。在这种情况下，您可以希望的最佳是O(n)，其中n是字符串的长度。

  

尽管如此，对于固定的输入大小，标称O(n)算法 将<{em} O(1)，因此从技术上讲，它们可能在这里是正确的。但是，人们通常不会使用复杂性分析。

在我看来，你可以通过多种方式给他们留下深刻印象。

首先，通知他们 可以在O(1)中执行此操作，除非您使用上面给出的“可疑”推理。

其次，通过提供Pythonic代码来展示您的精英技能，例如：

inpStr = '123412345123456'

# O(1) array creation.
freq = [0] * 1000

# O(n) string processing.
for val in [int(inpStr[pos:pos+3]) for pos in range(len(inpStr) - 2)]:
    freq[val] += 1

# O(1) output of relevant array values.
print ([(num, freq[num]) for num in range(1000) if freq[num] > 1])

输出：

[(123, 3), (234, 3), (345, 2)]

但是，当然可以将输出格式修改为您想要的任何内容。

最后，通过告诉他们O(n)解决方案几乎肯定存在 no 问题，因为上面的代码可以提供一个数百万字节的字符串的结果。第二。它似乎也非常线性地扩展，因为一个10,000,000字符的字符串需要3.5秒而一个100,000,000字符的字符串需要36秒。

而且，如果他们需要比这更好，那么就有办法将这种东西并行化，这样可以大大加快速度。

当然，由于GIL，不在单个 Python解释器中，但您可以将字符串拆分为类似的内容（需要vv表示的重叠，以便正确处理边界地区）：

    vv
123412  vv
    123451
        5123456

您可以将这些分类为单独的工作人员，然后将结果合并。

输入的分割和输出的组合可能会淹没任何使用小字符串（甚至可能是数百万字符串）的保存，但是，对于更大的数据集，它可能会有所不同。当然，我常用的“测量，不要猜测”的咒语在这里适用。

这个口头禅也适用于其他的可能性，例如完全绕过Python并使用可能更快的不同语言。

例如，以下C代码在与早期Python代码相同的硬件上运行，在0.6秒内处理百百万个数字，与Python代码处理的时间大致相同< em>一个百万。换句话说，很多更快：

#include <stdio.h>
#include <string.h>

int main(void) {
    static char inpStr[100000000+1];
    static int freq[1000];

    // Set up test data.

    memset(inpStr, '1', sizeof(inpStr));
    inpStr[sizeof(inpStr)-1] = '\0';

    // Need at least three digits to do anything useful.

    if (strlen(inpStr) <= 2) return 0;

    // Get initial feed from first two digits, process others.

    int val = (inpStr[0] - '0') * 10 + inpStr[1] - '0';
    char *inpPtr = &(inpStr[2]);
    while (*inpPtr != '\0') {
        // Remove hundreds, add next digit as units, adjust table.

        val = (val % 100) * 10 + *inpPtr++ - '0';
        freq[val]++;
    }

    // Output (relevant part of) table.

    for (int i = 0; i < 1000; ++i)
        if (freq[i] > 1)
            printf("%3d -> %d\n", i, freq[i]);

    return 0;
}

Answer 2

不可能有恒定时间。所有100万个数字至少需要查看一次，因此这是O（n）的时间复杂度，在这种情况下n = 100万。

对于简单的O（n）解决方案，创建一个大小为1000的数组，表示每个可能的3位数的出现次数。一次前进1位，第一个索引== 0，最后一个索引== 999997，并增加数组[3位数字]以创建直方图（每个可能的3位数字的出现次数）。然后输出数组＆gt;的数组内容。 1。

Answer 3

简单的O（n）解决方案是计算每个3位数字：

for nr in range(1000):
    cnt = text.count('%03d' % nr)
    if cnt > 1:
        print '%03d is found %d times' % (nr, cnt)

这将搜索所有100万个数字1000次。

仅遍历数字一次：

counts = [0] * 1000
for idx in range(len(text)-2):
    counts[int(text[idx:idx+3])] += 1

for nr, cnt in enumerate(counts):
    if cnt > 1:
        print '%03d is found %d times' % (nr, cnt)

时间显示在索引上只迭代一次的速度是使用count的两倍。

Answer 4

对于我在下面给出的答案，一百万是小的。期待您必须能够在面试中运行解决方案，而不会暂停，然后以下工作在不到两秒钟内完成并提供所需的结果：

from collections import Counter

def triple_counter(s):
    c = Counter(s[n-3: n] for n in range(3, len(s)))
    for tri, n in c.most_common():
        if n > 1:
            print('%s - %i times.' % (tri, n))
        else:
            break

if __name__ == '__main__':
    import random

    s = ''.join(random.choice('0123456789') for _ in range(1_000_000))
    triple_counter(s)

希望面试官能够使用标准库集合.Counter class。

并行执行版

我在此上写了一个blog post并附有更多解释。

Answer 5

这是＆＃34;共识＆＃34;的NumPy实现。 O（n）算法：随你走遍所有三胞胎和箱子。通过遇到说＆＃34; 385＆＃34;完成分箱，向bin [3,8,5]添加一个，这是O（1）操作。箱被安排在10x10x10立方体中。由于分箱是完全矢量化的，因此代码中没有循环。

def setup_data(n):
    import random
    digits = "0123456789"
    return dict(text = ''.join(random.choice(digits) for i in range(n)))

def f_np(text):
    # Get the data into NumPy
    import numpy as np
    a = np.frombuffer(bytes(text, 'utf8'), dtype=np.uint8) - ord('0')
    # Rolling triplets
    a3 = np.lib.stride_tricks.as_strided(a, (3, a.size-2), 2*a.strides)

    bins = np.zeros((10, 10, 10), dtype=int)
    # Next line performs O(n) binning
    np.add.at(bins, tuple(a3), 1)
    # Filtering is left as an exercise
    return bins.ravel()

def f_py(text):
    counts = [0] * 1000
    for idx in range(len(text)-2):
        counts[int(text[idx:idx+3])] += 1
    return counts

import numpy as np
import types
from timeit import timeit
for n in (10, 1000, 1000000):
    data = setup_data(n)
    ref = f_np(**data)
    print(f'n = {n}')
    for name, func in list(globals().items()):
        if not name.startswith('f_') or not isinstance(func, types.FunctionType):
            continue
        try:
            assert np.all(ref == func(**data))
            print("{:16s}{:16.8f} ms".format(name[2:], timeit(
                'f(**data)', globals={'f':func, 'data':data}, number=10)*100))
        except:
            print("{:16s} apparently crashed".format(name[2:]))

不出所料，NumPy比@ Daniel在大型数据集上的纯Python解决方案快一点。样本输出：

# n = 10
# np                    0.03481400 ms
# py                    0.00669330 ms
# n = 1000
# np                    0.11215360 ms
# py                    0.34836530 ms
# n = 1000000
# np                   82.46765980 ms
# py                  360.51235450 ms

Answer 6

我会按如下方式解决问题：

def find_numbers(str_num):
    final_dict = {}
    buffer = {}
    for idx in range(len(str_num) - 3):
        num = int(str_num[idx:idx + 3])
        if num not in buffer:
            buffer[num] = 0
        buffer[num] += 1
        if buffer[num] > 1:
            final_dict[num] = buffer[num]
    return final_dict

应用于您的示例字符串，这会产生：

>>> find_numbers("123412345123456")
{345: 2, 234: 3, 123: 3}

这个解决方案在O（n）中运行，因为n是所提供字符串的长度，我猜，这是你能得到的最好的。

Answer 7

根据我的理解，你无法在一个恒定的时间内获得解决方案。至少需要一次通过百万位数字（假设它是一个字符串）。您可以对百万个长度数字的数字进行3位滚动迭代，如果已存在，则将散列键的值增加1，或者如果它不存在则创建新的散列键（由值1初始化）已经在字典里了。

代码看起来像这样：

def calc_repeating_digits(number):

    hash = {}

    for i in range(len(str(number))-2):

        current_three_digits = number[i:i+3]
        if current_three_digits in hash.keys():
            hash[current_three_digits] += 1

        else:
            hash[current_three_digits] = 1

    return hash

您可以向下过滤到项目值大于1的键。

Answer 8

正如另一个答案中所提到的，你不能在恒定时间内完成这个算法，因为你必须至少看n个数字。线性时间是您获得的最快时间。

但是，算法可以在O（1）空间中完成。您只需要存储每个3位数的计数，因此您需要一个包含1000个条目的数组。然后，您可以在中输入数字。

我的猜测是，当他们给你解决方案时，面试官是错误的，或者当他们说“恒定空间”时你听错了“恒定时间”。

Answer 9

这是我的答案：

from timeit import timeit
from collections import Counter
import types
import random

def setup_data(n):
    digits = "0123456789"
    return dict(text = ''.join(random.choice(digits) for i in range(n)))


def f_counter(text):
    c = Counter()
    for i in range(len(text)-2):
        ss = text[i:i+3]
        c.update([ss])
    return (i for i in c.items() if i[1] > 1)

def f_dict(text):
    d = {}
    for i in range(len(text)-2):
        ss = text[i:i+3]
        if ss not in d:
            d[ss] = 0
        d[ss] += 1
    return ((i, d[i]) for i in d if d[i] > 1)

def f_array(text):
    a = [[[0 for _ in range(10)] for _ in range(10)] for _ in range(10)]
    for n in range(len(text)-2):
        i, j, k = (int(ss) for ss in text[n:n+3])
        a[i][j][k] += 1
    for i, b in enumerate(a):
        for j, c in enumerate(b):
            for k, d in enumerate(c):
                if d > 1: yield (f'{i}{j}{k}', d)


for n in (1E1, 1E3, 1E6):
    n = int(n)
    data = setup_data(n)
    print(f'n = {n}')
    results = {}
    for name, func in list(globals().items()):
        if not name.startswith('f_') or not isinstance(func, types.FunctionType):
            continue
        print("{:16s}{:16.8f} ms".format(name[2:], timeit(
            'results[name] = f(**data)', globals={'f':func, 'data':data, 'results':results, 'name':name}, number=10)*100))
    for r in results:
        print('{:10}: {}'.format(r, sorted(list(results[r]))[:5]))

数组查找方法非常快（甚至比@ paul-panzer的numpy方法更快！）。当然，它作弊因为它完成后没有技术完成，因为它返回了一台发电机。如果值已经存在，它也不必检查每次迭代，这可能会有很大帮助。

n = 10
counter               0.10595780 ms
dict                  0.01070654 ms
array                 0.00135370 ms
f_counter : []
f_dict    : []
f_array   : []
n = 1000
counter               2.89462101 ms
dict                  0.40434612 ms
array                 0.00073838 ms
f_counter : [('008', 2), ('009', 3), ('010', 2), ('016', 2), ('017', 2)]
f_dict    : [('008', 2), ('009', 3), ('010', 2), ('016', 2), ('017', 2)]
f_array   : [('008', 2), ('009', 3), ('010', 2), ('016', 2), ('017', 2)]
n = 1000000
counter            2849.00500992 ms
dict                438.44007806 ms
array                 0.00135370 ms
f_counter : [('000', 1058), ('001', 943), ('002', 1030), ('003', 982), ('004', 1042)]
f_dict    : [('000', 1058), ('001', 943), ('002', 1030), ('003', 982), ('004', 1042)]
f_array   : [('000', 1058), ('001', 943), ('002', 1030), ('003', 982), ('004', 1042)]

Answer 10

图片作为回答：

看起来像一个滑动窗口。

Answer 11

这是我的解决方案：

from collections import defaultdict
string = "103264685134845354863"
d = defaultdict(int)
for elt in range(len(string)-2):
    d[string[elt:elt+3]] += 1
d = {key: d[key] for key in d.keys() if d[key] > 1}

在for循环中有一些创造力（以及其他查找列表，例如True / False / None），您应该能够摆脱最后一行，因为您只想在我们访问过的dict中创建密钥到那时。 希望它有所帮助：）

Answer 12

inputStr = '123456123138276237284287434628736482376487234682734682736487263482736487236482634'

count = {}
for i in range(len(inputStr) - 2):
    subNum = int(inputStr[i:i+3])
    if subNum not in count:
        count[subNum] = 1
    else:
        count[subNum] += 1

print count