Torej, tam ste. Olajšan. Izčrpani. Končno ste izbrali pristop k reševanju zapletenega kodirnega vprašanja, ki vam ga postavlja vaš sogovornik. Morda ste to celo zapisali na belo desko, vrstico za vrstico. In lepo ste se imeli! Samo 20 minut ste do sestanka. Vaš anketar mora biti navdušen.
Prav?
"To bo delovalo, ampak kakšne ideje, kako to storiti učinkoviteje?"
Srce vam tone. Mislili ste, da ste končali z zapletenim delom algoritma! Poskušate si omisliti več načinov za rešitev težave, toda vse, kar si lahko omislite, je en pristop, ki ste ga že izbrali.
To se zgodi skoraj vsem. In to ne zato, ker so neumni. Ker večina ljudi nima metode za izboljšanje učinkovitosti svojih algoritmov.
Toda resnica je, da jih je veliko. Ko se boste naslednjič spotaknili, poskusite uporabiti te tri običajne pristope.
1. Uporabite Hash Map
Tako je. Hash mape / asociativni nizi / slovarji (imajo veliko imen, odvisno od programskega jezika, ki ga uporabljate) imajo čarobno sposobnost, da zmanjšajo čas delovanja algoritmov.
Recimo, na primer, vprašanje je bilo najti največkrat ponovljeno številko v nizu števil.
Vaša prva misel je, da bi skočili v nekaj zank. Za vsako od naših številk si določite njegovo število in preverite, ali je največja. Kako dobimo štetje za vsako številko? Skozi matriko preštejte, kolikokrat se pojavi! Torej govorimo o dveh ugnezdenih zankah. V psevkodi:
def get_mode (nums): max_count = 0 mode = null za potencial_mode v številkah: count = 0 za število v našem_arrayu: count + = 1, če štejemo> = max_count: mode = potencial_mode max_count = štetje vrnitvenega načina
Trenutno enkrat pregledujemo celoten niz za vsak element v matriki - vendar lahko naredimo še boljše. V velikem številu O je to skupaj čas O (n 2 ).
Če svoje števce shranimo na zemljevidu hash-ja (preslikava številke na njihovo število), lahko težavo rešimo v samo enem sprehodu skozi matriko (O (n) čas!):
def get_mode (nums): max_count = 0 način = null counts = nov HashMap, začenši vsako vrednost pri 0 za potencial_mode v številkah: šteje + = 1, če šteje> max_count: način = potencial_mode max_count = šteje vrnitveni način
Veliko hitreje!
2. Uporabite Bit manipulacijo
To vas bo resnično ločilo od pakiranja. Ne velja za vsako težavo, toda če to hranite v zadnjem žepu in ga sprostite ob pravem času, boste videti kot rockstar.
Tu je primer: Recimo, da smo imeli niz števil, kjer se vsako število pojavi dvakrat, razen ene številke, ki se pojavi samo enkrat. Pišemo funkcijo za iskanje osamljenega, ponavljajočega se števila.
Vaš prvi nagon je morda uporaba heš zemljevida, saj smo ravnokar govorili o tem. To je dober nagon! In to bo delovalo za to. Lahko naredimo zelo podoben zemljevid "šteje" in ga uporabimo, da vidimo, katero število se konča s številom 1.
Toda obstaja še boljši način. Če poznate manipulacije z bitji, ste morda seznanjeni z XOR. Pri XOR-ju je nekaj posebnega to, da če XOR številko sami s seboj, bitovi "prekličejo" na 0. Za to težavo, če XOR vsako številko v nizu skupaj, bomo ostali z eno številko, ki je ni ne prekličem:
def find_unrepepeated (nums): neponovljeno = 0 za num v številkah: neponovljeno = neponovljeno vrnitev števila XOR neponovljeno
3. Pojdite od spodaj navzgor
Napišite funkcijo, ki odda "n" Fibonaccijevo število, ki ima število n. Ta je klasika in se zelo lepo podvrže rekurziji:
def fib (n): če je n 0 ali 1: vrnite 1 povratno fib (n-1) + fib (n-2)
Toda preprost rekurziven odgovor ni edini! Dobro razmislite, kaj ta funkcija počne. Predpostavimo, da je n 5. Če želite dobiti odgovor, rekurzivno kliče fib (4) in fib (3). Torej, kaj počne ta poziv k fibu (4)? Pokliče fib (3) in fib (2). Toda pravkar smo rekli, da že imamo klic za fib (3)! Ta simpatična rekurzivna funkcija veliko dela. Skupni časovni stroški se izkažejo kot O (2 n ). To je slabo - precej slabše kot O (n 2 ).
Namesto da bi od n rekurzivno prehajali navzdol na 1, gremo od spodaj navzgor, od 1 do n. Tako lahko preskočimo rekurzijo:
def fib (n): prejšnji = 0 prejšnji_predviden = 1 za i v območju od 1 do n: trenutni = prejšnji + prejšnji_predvidljivi prejšnji_previdni = prejšnji prejšnji = trenutni povratni tok
Koda je daljša, vendar je veliko bolj učinkovita! Dol do O (n) časa. Kot dodaten bonus z odvijanjem rekurzivnih algoritmov prihranimo prostor. Vsi ti rekurzivni klici se zberejo v paketu klicev, ki sedi v spominu in šteje za naše vesoljske stroške. Naša rekurzivna funkcija je imela prostor za O (n), vendar ta iterativna vzame prostor O (1).
Ko vas naslednjič vpraša, da izboljšate učinkovitost svoje rešitve, poskusite sprejeti te strategije in preveriti, ali pomagajo. Z dovolj prakse boste verjetno skočili naravnost na optimizirano rešitev in preskočili bolj naivno rešitev. In to je super stvar. To ne pomeni samo, da postajate boljši anketar - to pomeni, da postajate boljši inženir.
