Složka algoritmus vyhledávání

Zde je několik Python pseudocode, dost blízko na spustitelný soubor (potřebuje vhodné dovoz a DEF pro funkci writerow, který bude dělat skutečné psaní - ať už k přechodnému souboru, DB, CSV, cokoliv):

# 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 nejednoznačnost v spec a například je, zda je možné, aby default_version změnit sadu souborů v některých letech - tady, já jsem za předpokladu, že se tak nestane (pouze určité verze změnit tímto způsobem, je výchozí verze vždy nese jednu sadu souborů).

Pokud toto není ten případ, co se stane v případě, že výchozí verze změny let (řekněme) 1999 a 2003, a změny version1 v letech 2001 a 2005 - jaké soubory by varianta 1 použít pro 03 a 04 novými ve výchozí verzi nebo těch, kterým je uvedeno v 01?

V nejsložitější verzi spec (kde oba default_version a konkrétní člověk může změnit, s nejnovější změny budou mít přednost, a je-li specifické i výchozí změna ve stejném roce pak specifický, který má přednost) je třeba, aby všechny „další změny rok“ sekvence, pro každou konkrétní verzi, opatrným „prioritní sloučení“ sekvencí změny let u třídy a konkrétní verzi, namísto pouhého použití years(sled změn v konkrétní verzi) jako já zde - a každá změna rok umístí v pořadí musí být spojena s příslušnou sadu souborů samozřejmě.

Takže v případě, že přesná specifikace může být vyjádřeno, prosím, až na případy kout, mohu ukázat, jak provést potřebné sloučení úpravou tohoto pseudocode - Raději bych dělat práci, dokud přesné specifikace jsou objasněny, protože v případě, že specifikace jsou skutečně jednodušší, práce by nepotřebné -!)

Edit : jako nový komentář vyjasnit přesné specifikace je skutečně velmi složitá, takže musíme dělat dělat sloučení odpovídajícím způsobem. Tak smyčky na konci zjednodušujícího odpovědi nad změnami:

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)

Klíčovou změnou je merged = dict(...podtrženo: v Pythonu, to znamená umožnit spojil nový dict (a dict je obecný mapování, bude typicky volal HashMap v jiných jazycích), což je částka, nebo sloučit, z default_versiona years_dict, ale když klíčem k úspěchu je přítomna v obou z nich, hodnota od years_dictpřednost - který splňuje klíčovou podmínku pro rok, který je k dispozici (tj je to rok se změnou souborů) v obojí.

Poté, že hračka: anydict.pop (somekey) vrátí hodnotu odpovídající klíče (a zároveň jej od anydict); min (anydict) vrátí minimální klíč slovníku. Všimněte si „sentinel“ idiom na merged[max_year + 1] = None: to říká, že rok „jeden po max jednom“ je vždy považována za změnu let (s fiktivní hodnotou zástupný nevznikla), takže poslední sada řádků je vždy správně napsaný (s maximální rok max_year + 1 - 1, který je přesně max_year, jak je požadováno).

Tento algoritmus není maximálně efektivní, jen nejjednodušší! Děláme min(merged)pořád dokola, takže je O (N SQUARED) - Myslím, že můžeme dovolit, protože každý mergedby měl mít několik desítek změnou roky na většinu, ale puristické by WinCE. Můžeme samozřejmě prezentovat (N logn) řešení je O - stačí roztřídit roky jednou provždy a chodit tuto sekvenci, aby si po sobě jdoucích hodnot next_change. Jen pro úplnost ...:

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

Zde sortedje uveden seznam s klávesami mergedv seřazeném pořadí, a já jsem přešel na forpříkazu k procházce tento seznam od začátku do konce (a jestli příkazy k výstupnímu nic poprvé projít). Hlídač je nyní dát do default_version (takže je mimo smyčku, na další mírné optimalizaci). Je to legrační vidět, že toto optimalizované verzi (v podstatě proto, že pracuje na mírně vyšší úrovni abstrakce) se ukáže být menší a jednodušší než předchozí ty ;-).