Folder kereső algoritmus

Itt van néhány Python pszeudokódokra, elég közel végrehajtható (szükségleteinek megfelelő import és a def egy writerow funkció, amely nem a tényleges írás - legyen szó akár egy köztes fájlt, DB, CSV, bármi):

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

Egy kétértelműséget a spec, és például az, hogy ez lehetséges, a default_version változtatni a sor fájlokat néhány évben - itt felteszem, hogy nem történik meg (csak a konkrét változat változtatni, hogy így, az alapértelmezett verzió mindig magában hordozza egy készlet fájlok).

Ha ez nem így van, mi történik, ha az alapértelmezett verzió változások éve (mondjuk) 1999-ben és 2003-ban és 2001-ben kivitelnél1 változások és 2005 - milyen fájlokat kell változat 1 felhasználás 03 és 04, az újakat az alapértelmezett verzió vagy az általa meghatározott 01?

A legbonyolultabb változatát spec (ahol mindkét default_version és specifikus lehet változtatni, a legutóbbi változás elsőbbségadás, és ha mind a specifikus és az alapértelmezett változás ebben az évben, akkor az adott szedési részesítendő) az egyik kell, hogy az összes „következő változás éve” sorozat, minden egyes változat, óvatos „prioritási összevonása” szekvenciák változás év alapértelmezett és egyedi változata, ahelyett, hogy csak a years(szekvencia változások a specifikus változat), mint én itt - és minden változást évente helyezni a sorrendben kell társítani a megfelelő sor fájlokat természetesen.

Tehát, ha a pontos specifikációt is kérem kifejezhető, egészen a sarokba esetekben tudom mutatni, hogyan kell csinálni a szükséges egyesülő módosításával ezt pszeudokódokra - Inkább nem azt a munkát, amíg a pontos specifikációk tisztázni, mert ha a szemüveg valóban egyszerűbb a munka lenne felesleges! -)

Szerkesztés : mint egy új hozzászólást tisztázni, hogy pontosan szemüveg valóban a legbonyolultabb, ezért meg kell tennünk ezt az egyesülő megfelelően. Tehát a ciklus végén a leegyszerűsített válasz fenti módosítások:

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)

A legfontosabb változás a merged = dict(...sort: Python, ez azt jelenti, hogy győződjön egyesült új dict (a dict generikus feltérképezése, ami jellemzően úgynevezett HashMap más nyelveken), amely az összeg, vagy összeolvad, az default_versionés years_dict, de ha egy kulcs egyaránt jelen van az említett, az értéket years_dictelőnyben -, amely megfelel a legfontosabb feltétele egy évre, ami jelen (azaz egy év a változás a fájlok) mindkettő.

Ezután ez sima vitorlázás: anydict.pop (somekey) visszaadja a megfelelő értéket a legfontosabb (és eltávolítja azt a anydict); min (anydict) visszatér a minimális kulcsot a szótárban. Megjegyzés: A „sentinel” idióma meg merged[max_year + 1] = None: ez azt mondja, hogy az év „egymás után max egy” mindig kell tekinteni a változás éve (dummy helykitöltő értéke None), úgy, hogy az utolsó sor a sorok mindig írva helyesen (maximum év max_year + 1 - 1, azaz pontosan max_year, ahogy szükséges).

Ez az algoritmus nem maximálisan hatékony, csak a legegyszerűbb! Csinálunk min(merged)újra és újra, ami O (N négyzeten) - Azt hiszem, magának, mert minden mergedkell egy pár tucat change-éves időszakra, de purista lenne összerezzen. Tudjuk persze bemutatni egy O (N logN) megoldás - csak rendezni az évek, egyszer és mindenkorra, és gyalog, hogy a sorozatot, hogy az egymást követő értékei next_change. Csak a teljesség kedvéért ...:

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

Itt sortedad egy listát a kulcsokat a mergedrendezett sorrendben, és én váltottunk, hogy a fornyilatkozat járni, hogy a listát az elejétől a végéig (és ha nyilatkozatok kiadási semmi először át). A sentinel most hozott default_version (így kívül a hurok, egy másik kis optimalizálás). Vicces látni, hogy ez optimalizált változatát (lényegében, mert működik egy kicsit magasabb absztrakciós szinten) kiderül, hogy kisebb és egyszerűbb, mint a korábbiak ;-).