ฉันได้สัมภาษณ์กับ บริษัท กองทุนป้องกันความเสี่ยงในนิวยอร์กเมื่อไม่กี่เดือนที่ผ่านมาและโชคไม่ดีที่ฉันไม่ได้รับการฝึกงานในฐานะวิศวกรข้อมูล / ซอฟต์แวร์ (พวกเขายังขอให้วิธีการแก้ปัญหาอยู่ในหลาม)

ฉันเมามากขึ้นกับปัญหาการสัมภาษณ์ครั้งแรก ...

คำถาม: รับสตริงเป็นล้านตัวเลข (เช่น Pi) เขียนฟังก์ชัน / โปรแกรมที่ส่งกลับตัวเลข 3 หลักซ้ำและจำนวนการทำซ้ำที่มากกว่า 1

ตัวอย่างเช่น: ถ้าสตริงเป็น: 123412345123456ดังนั้นฟังก์ชัน / โปรแกรมจะส่งคืน:

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

พวกเขาไม่ได้ให้คำตอบกับฉันหลังจากที่ฉันสัมภาษณ์ล้มเหลว แต่พวกเขาบอกฉันว่าเวลาในการแก้ปัญหานั้นมีค่าคงที่ 1,000 เนื่องจากผลลัพธ์ที่เป็นไปได้ทั้งหมดอยู่ระหว่าง:

000 -> 999

ตอนนี้ฉันกำลังคิดเกี่ยวกับมันฉันไม่คิดว่ามันเป็นไปได้ที่จะเกิดอัลกอริธึมเวลาคงที่ ใช่ไหม?

คุณปิดตัวลงเบา ๆ คุณอาจไม่ต้องการทำงานให้กองทุนเฮดจ์ฟันด์ที่นักวิจัยไม่เข้าใจอัลกอริธึมพื้นฐาน :-)

นอกจากนี้ไม่มีทางที่จะดำเนินการโดยพลการโครงสร้างข้อมูลกลางในO(1)ถ้าเป็นในกรณีนี้คุณต้องไปทุกองค์ประกอบอย่างน้อยหนึ่งครั้ง สิ่งที่ดีที่สุดที่คุณหวังคือO(n)ในกรณีnนี้ความยาวของสตริงอยู่ที่ไหน

ถึงแม้ว่าจะเป็นกันเล็กน้อยO(n)ขั้นตอนวิธีการจะเป็น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)แก้ปัญหาเนื่องจากโค้ดด้านบนให้ผลลัพธ์สำหรับสตริงหนึ่งล้านหลักภายในไม่ถึงครึ่งวินาที ดูเหมือนว่าจะขยายได้ค่อนข้างเป็นเส้นตรงเช่นกันเนื่องจากสตริง 10,000,000 อักขระใช้เวลา 3.5 วินาทีและ 100,000,000 ตัวอักษรใช้เวลา 36 วินาที

และหากพวกเขาต้องการสิ่งที่ดีกว่านั้นก็มีวิธีการเรียงลำดับของสิ่งต่าง ๆ เหล่านี้ที่สามารถเร่งความเร็วได้อย่างมาก

ไม่ได้อยู่ในที่เดียวล่ามหลามแน่นอนเนื่องจาก GIL แต่คุณสามารถแยกสตริงเป็นสิ่งที่ต้องการ (ระบุทับซ้อนกันโดยvvจะต้องอนุญาตให้มีการประมวลผลที่เหมาะสมของพื้นที่เขตแดน):

    vv
123412  vv
    123451
        5123456

คุณสามารถทำฟาร์มเหล่านี้เพื่อแยกคนงานออกจากกันและรวมผลลัพธ์หลังจากนั้น

การแยกอินพุตและการรวมเอาท์พุทมีแนวโน้มที่จะล้นการประหยัดด้วยสตริงเล็ก ๆ (และอาจเป็นสตริงล้านหลัก) แต่สำหรับชุดข้อมูลที่มีขนาดใหญ่กว่ามากมันอาจสร้างความแตกต่างได้ มนต์ปกติของฉันของ"วัดไม่ต้องเดา"ใช้ที่นี่แน่นอน

มนต์นี้ยังนำไปใช้กับความเป็นไปได้อื่น ๆเช่นการเลี่ยงผ่าน Python โดยสิ้นเชิงและใช้ภาษาอื่นซึ่งอาจเร็วกว่า

ตัวอย่างเช่นรหัส C ต่อไปนี้ซึ่งทำงานบนฮาร์ดแวร์เดียวกันกับรหัส Python ก่อนหน้านี้จัดการตัวเลขหนึ่งร้อยล้านหลักใน 0.6 วินาทีโดยประมาณในเวลาเดียวกับรหัส Python ที่ประมวลผลหนึ่งล้าน กล่าวอีกนัยหนึ่งเร็วกว่ามาก :

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

ไม่สามารถใช้เวลาคงที่ได้ ต้องดูอย่างน้อย 1 ล้านหลักทั้งหมดอย่างน้อยหนึ่งครั้งดังนั้นความซับซ้อนของเวลาของ O (n) โดยที่ n = 1 ล้านในกรณีนี้

สำหรับโซลูชัน O (n) แบบง่าย ๆ ให้สร้างอาร์เรย์ขนาด 1000 ที่แสดงจำนวนการเกิดขึ้นของแต่ละตัวเลข 3 หลักที่เป็นไปได้ เลื่อนครั้งละ 1 หลักดัชนีแรก == 0 ดัชนีล่าสุด == 999997 และอาร์เรย์ที่เพิ่มขึ้น [หมายเลข 3 หลัก] เพื่อสร้างฮิสโตแกรม (นับจำนวนที่เกิดขึ้นสำหรับแต่ละตัวเลข 3 หลักที่เป็นไปได้) จากนั้นเอาท์พุทเนื้อหาของอาร์เรย์ด้วยจำนวน> 1

ล้านมีขนาดเล็กสำหรับคำตอบที่ฉันให้ด้านล่าง คาดหวังเพียงว่าคุณจะต้องสามารถเรียกใช้โซลูชันในการสัมภาษณ์โดยไม่หยุดชั่วคราวจากนั้นการทำงานต่อไปนี้ในเวลาน้อยกว่าสองวินาทีและให้ผลลัพธ์ที่ต้องการ:

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)

หวังว่าผู้สัมภาษณ์จะมองหาการใช้งานคอลเลกชันห้องสมุดมาตรฐานชั้นเรียน

เวอร์ชันการทำงานแบบขนาน

ฉันเขียนบทความในบล็อกนี้พร้อมคำอธิบายเพิ่มเติม

วิธีแก้ปัญหา O (n) อย่างง่ายจะนับจำนวน 3 หลักแต่ละตัว:

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

นี่จะค้นหาทั้งหมด 1 ล้านหลัก 1,000 ครั้ง

การข้ามตัวเลขเพียงครั้งเดียว:

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แสดงให้เห็นว่าระยะเวลาการทำซ้ำเพียงครั้งเดียวในช่วงดัชนีรวดเร็วเป็นสองเท่าโดยใช้

นี่คือการดำเนินการ NumPy ของอัลกอริทึม "ฉันทามติ" O (n): เดินผ่านทริปเปิลและถังขยะตามที่คุณไป การทำ binning ทำได้โดยเมื่อพบว่า "385" โดยเพิ่มหนึ่งไปยัง bin [3, 8, 5] ซึ่งเป็นการดำเนินการ O (1) ช่องเก็บของถูกจัดเรียงเป็น10x10x10ลูกบาศก์ เนื่องจากการ binning นั้นถูกปรับเวกเตอร์อย่างสมบูรณ์จึงไม่มีการวนซ้ำในโค้ด

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 นั้นเร็วกว่าโซลูชัน Python ของ @ Daniel ในชุดข้อมูลขนาดใหญ่ ตัวอย่างผลลัพธ์:

# 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

ฉันจะแก้ปัญหาดังต่อไปนี้:

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 เป็นความยาวของสตริงที่ให้และฉันเดาที่ดีที่สุดที่คุณจะได้รับ

ตามความเข้าใจของฉันคุณไม่สามารถแก้ปัญหาได้ในเวลาที่แน่นอน มันจะใช้เวลาอย่างน้อยหนึ่งครั้งผ่านตัวเลขล้านหลัก (สมมติว่าเป็นสตริง) คุณสามารถมีการวนซ้ำ 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 ได้

ดังกล่าวในคำตอบอื่นคุณไม่สามารถทำอัลกอริทึมนี้ในเวลาคงที่เนื่องจากคุณต้องดูอย่างน้อย n หลัก เวลาเชิงเส้นเป็นวิธีที่เร็วที่สุดที่คุณจะได้รับ

อย่างไรก็ตามขั้นตอนวิธีที่สามารถทำได้ใน O (1) พื้นที่ คุณจะต้องเก็บจำนวนของตัวเลข 3 ตัวเท่านั้นดังนั้นคุณต้องมีอาร์เรย์ 1,000 รายการ จากนั้นคุณสามารถสตรีมตัวเลขใน

ฉันเดาว่าทั้งผู้สัมภาษณ์สะกดผิดเมื่อพวกเขาให้ทางออกหรือคุณคิดว่า "เวลาคงที่" เมื่อพวกเขาพูดว่า "พื้นที่คงที่"

นี่คือคำตอบของฉัน:

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!) แน่นอนมันโกงเพราะมันยังไม่เสร็จสิ้นหลังจาก technicailly เพราะมันกลับมากำเนิด นอกจากนี้ยังไม่ต้องตรวจสอบซ้ำทุกครั้งหากมีค่าอยู่แล้วซึ่งน่าจะช่วยได้มาก

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

ภาพเป็นคำตอบ:

ดูเหมือนหน้าต่างบานเลื่อน

นี่คือทางออกของฉัน:

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}

ด้วยความคิดสร้างสรรค์เล็กน้อยในการวนซ้ำ (และรายการค้นหาเพิ่มเติมด้วย True / False / None เป็นต้น) คุณควรจะสามารถกำจัดบรรทัดสุดท้ายได้เนื่องจากคุณต้องการสร้างคีย์ใน dict ที่เราเคยไปครั้งเดียวจนถึงจุดนั้น . หวังว่าจะช่วย :)

- การบอกจากมุมมองของ C. - คุณสามารถได้ผลลัพธ์แบบ 3 มิติ [10] [10] [10] - ไปจากตำแหน่งที่ 0 ถึงตำแหน่งที่ n-4 โดยที่ n เป็นขนาดของอาร์เรย์สตริง - ในแต่ละสถานที่ตรวจสอบปัจจุบันถัดไปและถัดไปของถัดไป - เพิ่ม cntr เป็น resutls [ปัจจุบัน] [ถัดไป] [ถัดไปของถัดไป] ++; พิมพ์ค่าของ

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]

- เป็นเวลา O (n) ไม่มีการเปรียบเทียบที่เกี่ยวข้อง - คุณสามารถเรียกใช้บางสิ่งที่ขนานกันได้ที่นี่โดยการแบ่งอาร์เรย์และคำนวณการแข่งขันรอบพาร์ติชัน

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