Szóval itt vagy. Megkönnyebbült. Kimerült. Végül kidolgozott egy megközelítést, hogy megoldja azt a trükkös kódolási kérdést, amelyet az interjú készítője feltet. Talán még a táblára írta, sorról sorra. És időben elkészültél! Csak 20 perc alatt érkezel a találkozóra. Interjúkészítőjének lenyűgöznie kell.
Jobb?
"Ez működni fog, de van-e ötlete annak, hogyan lehet ezt hatékonyan megtenni?"
A szíved elsüllyed. Úgy gondolta, hogy elkészült a trükkös algoritmus tervezési részével! Megpróbál többféle módszert gondolkodni a probléma megoldására, de csak arra gondolhat, amelyre már felállt.
Ez szinte mindenkinek megtörténik. És nem azért, mert hülyék. Ennek oka az, hogy a legtöbb embernek nincs módszere az algoritmusok hatékonyságának javítására.
De az igazság az, hogy rengeteg van. Legközelebb, amikor megbotlik, próbálja meg alkalmazni ezt a három általános megközelítést.
1. Használjon hasító térképet
Úgy van. A hash térképek / asszociatív tömbök / szótárak (sok név szerint megy keresztül, attól függően, hogy milyen programozási nyelvet használ) varázslatosan képesek csökkenteni az algoritmusok futási idejét.
Tegyük fel például, hogy a kérdés az volt, hogy megtaláljuk-e a legtöbb ismétlődő számot egy tömbben.
Az első gondolatod az lehet, hogy átugorsz néhány hurkot. Mindegyik számunk esetében kitaláljuk számát, és nézze meg, hogy a legnagyobb-e. Hogyan szerezzük meg az egyes számok számát? Húzza át a tömböt, számolva hányszor fordul elő! Tehát két beágyazott hurokról beszélünk. Álnévben:
def get_mode (számok): max_count = 0 mód = null a potencia_mode számára numban: count = 0 számra a mi_array-ban: count + = 1, ha count> = max_count: mode = potenciál_mode max_count = count visszatérési mód
Jelenleg a tömb minden elemét egyszer áthágjuk a teljes tömbön, de jobban tudunk csinálni. Nagy O jelöléssel összesen ez az O (n 2 ) idő.
Ha a számunkat hash-térképen tároljuk (a számokat hozzászámoljuk számukhoz), akkor a problémát csak egy tömb átjárásával oldhatjuk meg (O (n) idő!):
def get_mode (számok): max_count = 0 mód = null count = new HashMap, minden értéket 0-val kezdve a potencia_mode számára számban: számít + = 1, ha számít> max_count: mode = potenciál_mode max_count = számít visszatérési mód
Sokkal gyorsabb!
2. Használja a Bit Manipulációt
Ez valóban megkülönbözteti Önt a csomagtól. Nem vonatkozik minden problémára, de ha ezt a hátsó zsebében tartja, és a megfelelő időben kibontja, úgy néz ki, mint egy sziklás csillag.
Íme egy példa: Tegyük fel, hogy volt egy olyan tömb, amelyben minden szám kétszer jelenik meg, kivéve egy számot, amely csak egyszer fordul elő. Funkciót írunk a magányos, nem ismétlődő szám megtalálására.
Lehet, hogy első ösztöne egy hash térkép használata, mivel éppen erről beszéltünk. Ez jó ösztöne annak! És ez működni fog. Készíthetünk egy nagyon hasonló „számláló” térképet, és ennek alapján megnézhetjük, melyik szám ér véget az 1-nek.
De van még jobb módszer. Ha ismeri a bit manipulációt, akkor ismeri az XOR-ot. Az egyik dolog, ami az XOR-ban különös, hogy ha önmagával XOR-ot ad meg, akkor a bitek „kivezetik” nullára. Erre a problémára, ha a tömb minden számát XOR-ban együtt XOR-ban viseljük, akkor az egyetlen szám marad, amely nem nem törölhető:
def find_unpeated (számadatok): nem ismétlődik = 0 a számok számakor: nem ismétlődik = ismétlődő XOR num visszatérés ismétlődés nélkül
3. Menj alulról felfelé
Írj egy olyan funkciót, amely kiadja az „n” számú Fibonacci számot, adott n számot. Ez egy klasszikus, és nagyon kedvezően rejtőzik:
def fib (n): ha n értéke 0 vagy 1: visszatér 1 visszatérő fib (n-1) + fib (n-2)
De az egyszerű rekurzív válasz nem az egyetlen! Gondoljon alaposan át ezen a funkción. Tegyük fel, hogy n értéke 5. A válasz megszerzéséhez rekurzívan hívja a fib (4) és a fib (3) -ot. Nos, mit tesz ez a fib (4) hívás? Fib (3) és fib (2) hívja. De azt mondtuk, hogy már hívtunk a fib-re (3)! Ez az aranyos rekurzív funkció sok ismétlődő munkát végez. A teljes időköltség O (2 n ). Ez rossz - sokkal rosszabb, mint O (n 2 ).
Ahelyett, hogy n-t rekurzívan lefelé 1-re lépnénk, menjünk "alulról felfelé" 1-ről n-re. Ez lehetővé teszi, hogy kihagyjuk a rekurziót:
def fib (n): előző = 0 előző_előző = 1 az i-nél az 1-től n-ig terjedő tartományban: áram = előző + előző_ előző előző_ előző = előző előző = jelenlegi visszatérő áram
A kód hosszabb, de sokkal hatékonyabb! Lejjebb O (n) időig. Kiegészítő bónuszként a rekurzív algoritmusok kicserélésével helyet takaríthatunk meg. Mindezek a rekurzív hívások felépülnek a hívásverembe, amely beilleszkedik a memóriába és beleszámít a helyköltségbe. Rekurzív függvényünknek O (n) térköltsége volt, de ez az iteratív függvény O (1) helyet vesz fel.
Legközelebb, amikor az interjúkészítő felkéri Önt, hogy javítsa a megoldás hatékonyságát, próbálkozzon végigmenni ezen stratégiákon, és nézd meg, segítenek-e ezek. Ha elegendő gyakorlattal rendelkezik, valószínűleg rögtön az optimális megoldás felé ugrik, és kihagyja a naivabb megoldást. És ez nagyszerű dolog. Ez nem csak azt jelenti, hogy jobb interjúkészítővé válsz - ez azt is jelenti, hogy jobb mérnökré válsz.
