Algorytm poszukiwania folderu

Oto niektóre Python pseudokod, całkiem blisko do pliku wykonywalnego (wymaga odpowiedniego importu i def dla funkcji writerow że zrobi to samo pisanie - czy to do pliku pośredniego, DB, CSV, cokolwiek):

# first, collect all the data in a dict of dicts of lists
# first key is version, second key is year (only for non-empty years)

tree = dict()
for root, dirs, files in os.walk('make_1/model_1'):
    head, tail = os.path.split(root)
    if dirs:
       # here, tail is a version
       tree[tail] = dict
    elif files:
       # here, tail is a year
       tree[os.path.basename(head)][tail] = files

# now specialcase default_version
default_version = tree.pop('default_version')
# determine range of years; rule is quite asymmetrical:
#   for min, only years with files in them count
min_year = min(d for d in default_version if default_version[d])
#   for max, all years count, even if empty
max_year = max(default_version)

for version, years in tree.iteritems():
    current_files = default_version[min_year]
    years.append(max_year + 1)
    y = min_year
    while years:
        next_change = min(years)
        if y < next_change:
            for f in current_files:
                writerow(version, y, next_change-1, f)
        y = next_change
        current_files = years.pop(y)

Jeden dwuznaczność w specyfikacji i przykładem jest to, czy jest to możliwe dla default_version zmienić zestaw plików w niektórych latach - tu, jestem przy założeniu, że nie nastąpi (tylko w wybranych wersjach zmienić w ten sposób, wersja domyślna zawsze niesie jeden zestaw plików).

Jeśli tak nie jest, to, co się dzieje w przypadku zmiany domyślnej wersji w latach (powiedzmy) 1999 i 2003 oraz zmiany version1 w 2001 i 2005 roku - jakie pliki powinny wersja 1 stosowanie do 03 i 04 nowymi, w wersji domyślnej lub tych, których określono w 01?

W najbardziej skomplikowanej wersji specyfikacji (gdzie zarówno default_version i specyficzny można zmienić, z ostatniej zmiany mającego pierwszeństwo, a jeśli zarówno specyficzne i domyślne zmiana w tym samym roku, a następnie konkretne mającego pierwszeństwo) trzeba uzyskać wszystkie „w przyszłym roku zmiana” sekwencja, dla każdej wersji, poprzez ostrożne „priorytetowej” łączenia sekwencji przemian lat za zwłokę i określonej wersji, zamiast tylko za pomocą years(kolejność zmian w konkretnej wersji), jak to zrobić tutaj - a każdy rok zmiana umieszczone w kolejności muszą być powiązane z odpowiednim zestawem plików oczywiście.

Więc jeśli dokładna specyfikacja może być wyrażona proszę, aż do przypadków narożnych, mogę pokazać jak wykonać potrzebne łączenie poprzez modyfikację tego Pseudokod - Wolałbym nie wykonywać pracę aż dokładne specyfikacje są wyjaśnione, ponieważ, jeśli specyfikacje są rzeczywiście prostsze, praca byłoby niepotrzebne! -)

Edit : jak nowy komentarz wyjaśnić, dokładne specyfikacje rzeczywiście jest najbardziej skomplikowana, więc musimy zrobić zrobić łączących odpowiednio. Więc pętli na końcu odpowiedź uproszczonym powyżej zmian:

for version, years_dict in tree.iteritems():
    # have years_dict override default_version when coincident
    merged = dict(default_version, **years_dict)
    current_files = merged.pop(min_year)
    merged[max_year + 1] = None
    y = min_year
    while merged:
        next_change = min(merged)
        for f in current_files:
            writerow(version, y, next_change-1, f)
        y = next_change
        current_files = merged.pop(y)

Kluczową zmianą jest merged = dict(...linia: w Pythonie, to znaczy, aby połączyły się nowy dict (dict jest ogólnym mapping, będzie zazwyczaj nazywa HashMap w innych językach), która jest sumą lub łączenia, z default_version, a years_dict, ale kiedy kluczem jest obecny w obu tych, wartość ze years_dictma pierwszeństwo - która spełnia warunek kluczowy dla roku, który jest obecny (czyli jest rok ze zmianą plików) w obu.

Po tym, że to całkiem proste: anydict.pop (somekey) zwraca wartość odpowiadającą klucza (a także usuwa go z anydict); min (anydict) zwraca co najmniej klucz słownika. Zwróć uwagę na „pusta” idiom w merged[max_year + 1] = None: ten mówi, że rok „jeden po max jednego” jest zawsze uważane za zmianę roku (z manekina wartości zastępczego z None), tak, że ostatni zestaw wierszy jest zawsze poprawnie napisane (z maksymalnym roku max_year + 1 - 1, to znaczy dokładnie max_year, jak to pożądane).

Algorytm ten nie jest maksymalnie wydajny, wystarczy najprostsza! Robimy min(merged)kółko, co czyni go O (N kwadratu) - myślę, że możemy sobie na to pozwolić, ponieważ każdy mergedpowinien mieć kilkadziesiąt przełączeń lat co najwyżej, ale purist by skrzywić. Możemy oczywiście przedstawić O Solution (N logN) - wystarczy posortować lat raz na zawsze i iść tą sekwencję, aby dostać kolejne wartości next_change. Tylko dla zasady ...:

default_version[max_year + 1] = None

for version, years_dict in tree.iteritems():
    merged = dict(default_version, **years_dict)
    for next_change in sorted(merged):
        if next_change > min_year:
            for f in merged[y]:
                writerow(version, y, next_change-1, f)
        y = next_change

Tutaj sorteddaje listę kluczy mergedposortowanych, a ja już włączony do forrachunku chodzić tę listę od początku do końca (i jeśli nic oświadczenia do wyjścia za pierwszym razem). Sentinel jest teraz umieścić w default_version (dlatego na zewnątrz pętli, na innym lekkim optymalizacji). To zabawne, aby zobaczyć, że ta wersja zoptymalizowana (głównie dlatego, że działa na nieco wyższym poziomie abstrakcji) okazuje się być mniejsze i prostsze niż poprzednie ;-).