Så der er du. Lettet. Udmattet. Du har endelig fundet en tilgang til at løse det vanskelige kodningsspørgsmål, som din interviewer stiller dig. Måske har du endda skrevet det op på tavlen, linje for linje. Og du lavede god tid! Du er kun 20 minutter ind i mødet. Din interviewers bliver imponeret.
Ret?
”Dette fungerer, men nogle ideer til, hvordan man gør det mere effektivt?”
Dit hjerte synker. Du troede, at du var færdig med den vanskelige algoritme-designdel! Du prøver at tænke på flere måder at løse problemet på, men alt hvad du kan tænke på er den tilgang, du allerede har fundet ud af.
Dette sker for næsten alle. Og det er ikke fordi de er dumme. Det er fordi de fleste mennesker ikke har en metode til at forbedre effektiviteten af deres algoritmer.
Men sandheden er, at der er masser. Næste gang du er stubbet, kan du prøve at anvende disse tre almindelige tilgange.
1. Brug et Hash-kort
Det er rigtigt. Hash-kort / tilknyttede arrays / ordbøger (de går under mange navne, afhængigt af hvilket programmeringssprog du bruger) har en magisk evne til at nedbringe runtime for algoritmer.
Antag f.eks., At spørgsmålet var at finde det mest gentagne tal i en række numre.
Din første tanke kan være at hoppe ind i nogle løkker. For hvert af vores tal, regn det ud, og se, om det er det største. Hvordan får vi tællingen for hvert tal? Gå igennem matrixen, og tæl hvor mange gange det forekommer! Så vi taler om to indlejrede sløjfer. I pseudokode:
def get_mode (nums): max_count = 0 mode = null for potential_mode in nums: count = 0 for number in our_array: count + = 1 if count> = max_count: mode = potential_mode max_count = count count mode
Lige nu løber vi gennem hele vores matrix en gang for hvert element i matrixen - men vi kan gøre det bedre. I stor O-notation er det O (n 2 ) tid i alt.
Hvis vi gemmer vores tællinger på et hashkort (kortlægger numre til deres antal), kan vi løse problemet på kun en gåtur gennem matrisen (O (n) tid!):
def get_mode (nums): max_count = 0 mode = null count = new HashMap, start hver værdi på 0 for potential_mode i nums: tæller + = 1 hvis tæller> max_count: mode = potential_mode max_count = tæller returnering mode
Meget hurtigere!
2. Brug Bitmanipulation
Dette adskiller dig virkelig fra pakken. Det gælder ikke for ethvert problem, men hvis du holder dette i din baglomme og trækker det ud på det rigtige tidspunkt, ser du ud som en rockstar.
Her er et eksempel: Antag, at vi havde en række numre, hvor hvert tal vises to gange, undtagen et nummer, der kun forekommer en gang. Vi skriver en funktion for at finde det ensomme, ikke-gentagne tal.
Dit første instinkt kan være at bruge et hashkort, da vi lige har talt om det. Det er et godt instinkt at have! Og det fungerer for denne. Vi kan lave et meget lignende ”tæller” -kort, og bruge det til at se hvilket nummer, der ender med et antal på 1.
Men der er en endnu bedre måde. Hvis du er fortrolig med bitmanipulation, er du muligvis bekendt med XOR. Én ting, der er speciel ved XOR, er, at hvis du XOR et tal med sig selv, “brydder” bitene ud til 0. For dette problem, hvis vi XOR hvert tal i matrixen sammen, bliver vi tilbage med det ene nummer, der ikke gjorde annullerer ikke:
def find_unrepeated (nums): unrepeated = 0 for num in nums: unrepeated = unrepeated XOR num return unrepeated
3. Gå bund-op
Skriv en funktion, der udsender det “nde” Fibonacci-nummer, givet et tal n. Denne er en klassiker, og den egner sig meget pænt til rekursion:
def fib (n): hvis n er 0 eller 1: return 1 return fib (n-1) + fib (n-2)
Men det enkle rekursive svar er ikke det eneste! Tænk nøje over, hvad denne funktion gør. Antag, at n er 5. For at få svaret kalder det rekursivt fib (4) og fib (3). Hvad gør den kaldelse til fib (4) nu? Det kalder fib (3) og fib (2). Men vi sagde lige, at vi allerede havde et opkald til fib (3)! Denne søde rekursive funktion gør en masse gentagelsesarbejde. De samlede tidsomkostninger viser sig at være O (2 n ). Det er dårligt - langt værre end O (n 2 ).
I stedet for at gå fra n rekursivt ned til 1, lad os gå "bottom-up" fra 1 til n. Dette lader os springe over rekursionen:
def fib (n): forrige = 0 forrige_forud = 1 for i i området 1 til n: nuværende = forrige + forrige_forudgående forudgående = forrige forrige = nuværende returstrøm
Koden er længere, men den er meget mere effektiv! Ned til O (n) tid. Som en ekstra bonus med ikke-rullende rekursive algoritmer sparer vi plads. Alle disse rekursive opkald bygger sig op i opkaldsstakken, der sidder i hukommelsen og tæller mod vores pladsomkostninger. Vores rekursive funktion havde en O (n) pladsomkostninger, men denne iterative tager O (1) plads.
Næste gang din interviewer beder dig om at forbedre effektiviteten af din løsning, kan du prøve at gå gennem disse strategier og se, om de hjælper. Med nok praksis vil du sandsynligvis finde dig selv hoppe direkte til den optimerede løsning og springe over den mere naive løsning. Og det er en stor ting. Det betyder ikke bare, at du bliver en bedre interviewer - det betyder, at du bliver en bedre ingeniør.
