Tôi đã có một cuộc phỏng vấn với một công ty quỹ phòng hộ ở New York vài tháng trước và thật không may, tôi đã không nhận được lời mời thực tập với tư cách là một kỹ sư dữ liệu / phần mềm. (Họ cũng yêu cầu giải pháp là bằng Python.)

Tôi gặp khá nhiều rắc rối về vấn đề phỏng vấn đầu tiên ...

Câu hỏi: Cho một chuỗi gồm một triệu số (ví dụ Pi), hãy viết hàm / chương trình trả về tất cả các số có 3 chữ số lặp lại và số lần lặp lại lớn hơn 1

Ví dụ: nếu chuỗi là: 123412345123456thì hàm / chương trình sẽ trả về:

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

Họ đã không cho tôi giải pháp sau khi tôi thất bại trong cuộc phỏng vấn, nhưng họ đã nói với tôi rằng độ phức tạp thời gian cho giải pháp là không đổi 1000 vì tất cả các kết quả có thể xảy ra là:

000 -> 999

Bây giờ tôi đang nghĩ về nó, tôi không nghĩ rằng có thể đưa ra một thuật toán thời gian không đổi. Là nó?

Bạn bước ra một cách nhẹ nhàng, có lẽ bạn không muốn làm việc cho một quỹ phòng hộ mà người đi thuê không hiểu các thuật toán cơ bản :-)

Không có cách nào để xử lý cấu trúc dữ liệu có kích thước tùy ý O(1)trong trường hợp này, như trong trường hợp này, bạn cần phải truy cập mọi phần tử ít nhất một lần. Điều tốt nhất bạn có thể hy vọng là O(n)trong trường hợp này, nđộ dài của chuỗi.

Mặc dù, như là một sang một bên, một danh nghĩa O(n)thuật toán sẽ được O(1)cho một kích thước đầu vào cố định như vậy, về mặt kỹ thuật, họ có thể đã đúng ở đây. Tuy nhiên, đó thường không phải là cách mọi người sử dụng phân tích phức tạp.

Nó xuất hiện với tôi bạn có thể đã gây ấn tượng với họ theo một số cách.

Đầu tiên, bằng cách thông báo cho họ rằng không thể thực hiện được O(1), trừ khi bạn sử dụng lý do "nghi ngờ" nêu trên.

Thứ hai, bằng cách thể hiện các kỹ năng ưu tú của bạn bằng cách cung cấp mã Pythonic như:

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])

Kết quả này:

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

mặc dù bạn có thể, tất nhiên, sửa đổi định dạng đầu ra thành bất cứ điều gì bạn muốn.

Và cuối cùng, bằng cách nói với họ gần như chắc chắn không có vấn đề gì với một O(n)giải pháp, vì đoạn mã trên mang lại kết quả cho chuỗi một triệu chữ số trong chưa đầy nửa giây. Nó dường như cũng có quy mô khá tuyến tính, vì một chuỗi 10.000.000 ký tự mất 3,5 giây và một chuỗi 100.000.000 ký tự mất 36 giây.

Và, nếu họ cần tốt hơn thế, có nhiều cách để song song loại công cụ này có thể tăng tốc đáng kể.

Tất nhiên, không phải trong một trình thông dịch Python duy nhất , do GIL, nhưng bạn có thể chia chuỗi thành một cái gì đó giống như ( vvyêu cầu chồng chéo được chỉ định để cho phép xử lý đúng các khu vực biên):

    vv
123412  vv
    123451
        5123456

Bạn có thể nuôi chúng ra để tách công nhân và kết hợp các kết quả sau đó.

Việc phân tách đầu vào và kết hợp đầu ra có khả năng làm lu mờ bất kỳ sự tiết kiệm nào với các chuỗi nhỏ (và thậm chí có thể là chuỗi triệu chữ số), nhưng đối với các tập dữ liệu lớn hơn nhiều, nó cũng có thể tạo ra sự khác biệt. Tất nhiên, câu thần chú thông thường của tôi về "biện pháp, đừng đoán" áp dụng ở đây.

Câu thần chú này cũng áp dụng cho các khả năng khác , chẳng hạn như bỏ qua Python hoàn toàn và sử dụng một ngôn ngữ khác có thể nhanh hơn.

Ví dụ, mã C sau, chạy trên cùng phần cứng với mã Python trước đó, xử lý một trăm triệu chữ số trong 0,6 giây, gần bằng thời gian khi mã Python xử lý một triệu. Nói cách khác, nhanh hơn nhiều :

#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;
}

Thời gian liên tục là không thể. Tất cả 1 triệu chữ số cần được xem xét ít nhất một lần, do đó, đó là độ phức tạp thời gian của O (n), trong đó n = 1 triệu trong trường hợp này.

Đối với giải pháp O (n) đơn giản, hãy tạo một mảng có kích thước 1000 đại diện cho số lần xuất hiện của mỗi số có 3 chữ số có thể. Tiến lên 1 chữ số tại một thời điểm, chỉ mục đầu tiên == 0, chỉ mục cuối cùng == 999997 và mảng tăng [số 3 chữ số] để tạo biểu đồ (số lần xuất hiện cho mỗi số có 3 chữ số có thể). Sau đó xuất nội dung của mảng với số lượng> 1.

Một triệu là nhỏ cho câu trả lời tôi đưa ra dưới đây. Chỉ mong rằng bạn phải có thể chạy giải pháp trong cuộc phỏng vấn, không cần tạm dừng, sau đó Công việc sau chỉ trong chưa đầy hai giây và đưa ra kết quả cần thiết:

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)

Hy vọng rằng người phỏng vấn sẽ tìm kiếm việc sử dụng các bộ sưu tập thư viện tiêu chuẩn.

Phiên bản thực hiện song song

Tôi đã viết một bài đăng trên blog này với nhiều lời giải thích.

Giải pháp O (n) đơn giản sẽ là đếm từng số có 3 chữ số:

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

Điều này sẽ tìm kiếm thông qua tất cả 1 triệu chữ số 1000 lần.

Di chuyển các chữ số chỉ một lần:

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)

Thời gian cho thấy rằng việc lặp lại chỉ một lần so với chỉ mục nhanh gấp đôi so với sử dụng count.

Dưới đây là một triển khai NumPy của thuật toán "đồng thuận" O (n): đi qua tất cả các bộ ba và bin khi bạn đi. Việc tạo thùng được thực hiện bằng cách bắt gặp nói "385", thêm một vào bin [3, 8, 5] là thao tác O (1). Thùng được sắp xếp trong một 10x10x10khối. Vì binning được vector hóa hoàn toàn, không có vòng lặp trong mã.

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:]))

Không có gì đáng ngạc nhiên, NumPy nhanh hơn một chút so với giải pháp Python thuần túy của @ Daniel trên các tập dữ liệu lớn. Đầu ra mẫu:

# 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

Tôi sẽ giải quyết vấn đề như sau:

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

Áp dụng cho chuỗi ví dụ của bạn, điều này mang lại:

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

Giải pháp này chạy trong O (n) với n là độ dài của chuỗi được cung cấp, và, tôi đoán là tốt nhất bạn có thể nhận được.

Theo hiểu biết của tôi, bạn không thể có giải pháp trong một thời gian liên tục. Nó sẽ mất ít nhất một lần vượt qua số triệu chữ số (giả sử đó là một chuỗi). Bạn có thể lặp lại 3 chữ số trên các chữ số của số triệu chiều dài và tăng giá trị của khóa băm lên 1 nếu nó đã tồn tại hoặc tạo khóa băm mới (được khởi tạo bởi giá trị 1) nếu nó chưa tồn tại từ điển.

Mã sẽ trông giống như thế này:

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

Bạn có thể lọc xuống các khóa có giá trị mục lớn hơn 1.

Như đã đề cập trong một câu trả lời khác, bạn không thể thực hiện thuật toán này trong thời gian liên tục, bởi vì bạn phải xem ít nhất n chữ số. Thời gian tuyến tính là nhanh nhất bạn có thể nhận được.

Tuy nhiên, thuật toán có thể được thực hiện trong không gian O (1) . Bạn chỉ cần lưu trữ số đếm của mỗi số có 3 chữ số, vì vậy bạn cần một mảng gồm 1000 mục. Sau đó bạn có thể truyền số vào.

Tôi đoán là hoặc người phỏng vấn sai chính tả khi họ đưa ra giải pháp cho bạn, hoặc bạn nghe nhầm "thời gian không đổi" khi họ nói "không gian không đổi".

Đây là câu trả lời của tôi:

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]))

Phương pháp tra cứu mảng rất nhanh (thậm chí nhanh hơn phương pháp numpy của @ paul-panzer!). Tất nhiên, nó gian lận vì nó không hoàn thành về mặt kỹ thuật sau khi hoàn thành, bởi vì nó trả lại một máy phát điện. Nó cũng không phải kiểm tra mỗi lần lặp nếu giá trị đã tồn tại, có khả năng giúp ích rất nhiều.

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)]

Hình ảnh như câu trả lời:

Trông giống như một cửa sổ trượt.

Đây là giải pháp của tôi:

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}

Với một chút sáng tạo trong vòng lặp (và danh sách tra cứu bổ sung với True / Sai / Không có ví dụ), bạn sẽ có thể thoát khỏi dòng cuối cùng, vì bạn chỉ muốn tạo các khóa trong dict mà chúng tôi đã truy cập một lần cho đến thời điểm đó . Hy vọng nó giúp :)

-Tìm hiểu theo quan điểm của C. -Bạn có thể có kết quả mảng int 3-d [10] [10] [10]; -Đi từ vị trí thứ 0 đến vị trí thứ 4, trong đó n là kích thước của mảng chuỗi. -Trên mỗi địa điểm, kiểm tra hiện tại, tiếp theo và tiếp theo. -Xác định cntr dưới dạng resutls [current] [next] [next's next] ++; -Xác định các giá trị của

results[1][2][3]
results[2][3][4]
results[3][4][5]
results[4][5][6]
results[5][6][7]
results[6][7][8]
results[7][8][9]

-Đó là thời gian O (n), không có sự so sánh nào liên quan. -Bạn có thể chạy một số nội dung song song ở đây bằng cách phân vùng mảng và tính toán các trận đấu xung quanh các phân vùng.

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