数か月前にニューヨークのヘッジファンド会社にインタビューをしましたが、残念ながら、データ/ソフトウェアエンジニアとしてのインターンシップのオファーはありませんでした。（彼らはまた、ソリューションをPythonにすることを求めました。）

私は最初のインタビューの問題でかなり失敗しました...

質問：100万の数字（Piなど）の文字列が与えられた場合、3桁の数字の繰り返しと1より大きい繰り返しの数をすべて返す関数/プログラムを作成します。

たとえば、文字列が：の123412345123456場合、関数/プログラムは次を返します。

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

私がインタビューに失敗した後、彼らは私に解決策を与えませんでしたが、考えられるすべての結果が次の間にあるため、解決策の時間の複雑さは1000で一定であると教えてくれました：

000-> 999

私はそれについて考えているので、一定の時間のアルゴリズムを思いつくことは可能ではないと思います。それは...ですか？

あなたは軽く降りました、あなたはおそらくクオンツが基本的なアルゴリズムを理解していないヘッジファンドのために働きたくないでしょう:-)

この場合のように、すべての要素に少なくとも1回アクセスする必要がある場合、任意のサイズのデータ​​構造を処理する方法はありません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)]

もちろん、出力形式を好きなように変更することもできます。

そして最後に、上記のコードは0.5秒未満で100万桁の文字列の結果を提供するので、ソリューションに問題がないことをほぼ確実に伝えますO(n)。10,000,000文字の文字列は3.5秒かかり、1億文字の文字列は36秒かかるため、これも非常に直線的にスケーリングされているようです。

そして、彼らがそれよりも良いものを必要とするなら、それを大幅にスピードアップできるこの種のものを並列化する方法があります。

もちろん、GILのため、単一の Pythonインタープリター内ではありませんが、文字列を次のようなものに分割できます（vv境界領域を適切に処理するには、で示されるオーバーラップが必要です）。

    vv
123412  vv
    123451
        5123456

これらを別々のワーカーにファームし、後で結果を組み合わせることができます。

入力の分割と出力の結合は、小さな文字列（場合によっては数百万桁の文字列）の節約を損なう可能性がありますが、はるかに大きなデータセットの場合は、違いが生じる可能性があります。もちろん、いつもの「対策、推測しないでください」というスローガンが当てはまります。

このマントラは、他の可能性にも適用されます。たとえば、Pythonを完全にバイパスして、より高速な別の言語を使用するなどです。

例えば、以下のCコードは、以前のPythonコードと同じハードウェア上で実行されている、ハンドル百 0.6秒で百万の桁、Pythonコードが処理され、時間のほぼ同じ量の1つの百万。言い換えれば、はるかに高速です：

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

一定の時間は不可能です。100万桁すべてを少なくとも1回見る必要があるため、これはO（n）の時間の複雑さです。この場合、n = 100万です。

単純なO（n）ソリューションの場合、考えられる3桁の数値それぞれの出現回数を表すサイズ1000の配列を作成します。一度に1桁ずつ進み、最初のインデックス== 0、最後のインデックス== 999997、増分配列[3桁の番号]で、ヒストグラム（可能な3桁の番号ごとの出現回数）を作成します。次に、カウントが1より大きい配列の内容を出力します。

100万は私が下に与える答えのために小さいです。面接で一時停止せずにソリューションを実行できる必要があることだけを期待している場合、以下は2秒未満で機能し、必要な結果が得られます。

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)

うまくいけば、インタビュアーは標準ライブラリcollections.Counterクラスの使用を探しているでしょう。

並列実行バージョン

私はこれについてブログ記事を書きました。

単純な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回検索されます。

数字のトラバースは1回だけです。

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)

タイミングは、インデックスに対して1回だけ繰り返すと、を使用する場合の2倍の速さであることを示していますcount。

以下は、「コンセンサス」O（n）アルゴリズムのNumPy実装です。移動しながらすべてのトリプレットとビンを調べます。ビニングは、たとえば「385」に遭遇したときにO（1）操作であるbin [3、8、5]に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

私は次のように問題を解決します：

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は提供された文字列の長さであり、おそらく、あなたが得ることができる最良のものです。

私の理解によると、あなたは一定の時間内に解決策を持つことはできません。100万桁の数字を少なくとも1回パスします（文字列を想定）。百万長の数字の桁で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桁の数値のカウントを保存するだけでよいので、1000エントリの配列が必要です。その後、その番号をストリーミングできます。

おそらく、インタビュアーがあなたに解決策を与えたときに間違って話したか、または「一定の空間」と言ったときに「一定の時間」を誤って聞いたと思います。

これが私の答えです：

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

答えとしての画像：

スライディングウィンドウのように見えます。

これが私の解決策です：

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を含む追加のルックアップリストなど）を使用すると、最後の行を取り除くことができるはずです。 。それが役に立てば幸い ：）

-Cの観点から説明します。-int3次元配列の結果を得ることができます[10] [10] [10]; -0番目の場所からn-4番目の場所に移動します。nは文字列配列のサイズです。-各場所で、現在、次、次の次を確認してください。-cntrをresutls [current] [next] [next's next] ++としてインクリメントします。-の値を印刷する

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